Added the Node notation to define paths to screens..

cmd/test/main.go

@@ -51,10 +51,7 @@ func ExtractSessionData(c *tg.Context) *SessionData {
 }
 
 var (
-	startScreenButton = tg.NewButton("Back").ActionFunc(func(c *tg.Context){
+	startScreenButton = tg.NewButton("Home").Go("/")
-		c.GoUp()
-	})
-
 	incDecKeyboard = tg.NewKeyboard().Row(
 		tg.NewButton("+").ActionFunc(func(c *tg.Context) {
 			d := ExtractSessionData(c)
@@ -71,14 +68,14 @@ var (
 	)
 
 	navKeyboard = tg.NewKeyboard().Row(
-		tg.NewButton("Inc/Dec").ScreenChange("/start/inc-dec"),
+		tg.NewButton("Inc/Dec").Go("/inc-dec"),
 	).Row(
 		tg.NewButton("Upper case").ActionFunc(func(c *tg.Context){
-			c.Go("/start/upper-case", "this shit", "works")
+			c.Go("/upper-case", "this shit", "works")
 		}),
-		tg.NewButton("Lower case").ScreenChange("/start/lower-case"),
+		tg.NewButton("Lower case").Go("/case"),
 	).Row(
-		tg.NewButton("Send location").ScreenChange("/start/send-location"),
+		tg.NewButton("Send location").Go("/send-location"),
 	).Reply().WithOneTime(true)
 
 	sendLocationKeyboard = tg.NewKeyboard().Row(
@@ -106,29 +103,14 @@ var (
 	).Reply()
 )
 
-var theNode = tg.NewNode(
-	"/", tg.WidgetFunc(func(c *tg.Context){
-		c.Go("/start")
-	}),
-	tg.NewNode(
-		"start", tg.WidgetFunc(func(c *tg.Context){}),
-		tg.NewNode(
-			"profile", tg.WidgetFunc(func(c *tg.Context){}),
-		),
-		tg.NewNode(
-			"upper-case", tg.WidgetFunc(func(c *tg.Context){}),
-		),
-	),
-)
-
 var beh = tg.NewBehaviour().
 WithInitFunc(func(c *tg.Context) {
 	// The session initialization.
 	c.Session.Data = &SessionData{}
-	}).WithScreens(
+}).WithRootNode(tg.NewRootNode(
-		tg.NewScreen("/start", tg.NewPage(
+	// The "/" widget.
-				"",
+	tg.NewPage().
-			).WithInline(
+		WithInline(
 			tg.NewKeyboard().Row(
 				tg.NewButton("GoT Github page").
 					WithUrl("https://github.com/mojosa-software/got"),
@@ -136,13 +118,9 @@ var beh = tg.NewBehaviour().
 		).WithReply(
 			navKeyboard.Widget("Choose what you are interested in"),
 		),
-		),
+
-		tg.NewScreen("/start/inc-dec", tg.NewPage(
+	tg.NewNode(
-				"The screen shows how "+
+		"inc-dec", tg.NewPage().WithReply(
-					"user separated data works "+
-					"by saving the counter for each of users "+
-					"separately. ",
-			).WithReply(
 				incDecKeyboard.Reply().Widget("Press the buttons to increment and decrement"),
 			).ActionFunc(func(c *tg.Context) {
 				// The function will be calleb before serving page.
@@ -151,7 +129,8 @@ var beh = tg.NewBehaviour().
 			}),
 	),
 
-		tg.NewScreen("/start/upper-case", tg.NewPage(
+	tg.NewNode(
+		"upper-case", tg.NewPage().WithText(
 				"Type text and the bot will send you the upper case version to you",
 			).WithReply(
 				navToStartKeyboard.Widget(""),
@@ -160,7 +139,8 @@ var beh = tg.NewBehaviour().
 			),
 	),
 
-		tg.NewScreen("/start/lower-case", tg.NewPage(
+	tg.NewNode(
+		"lower-case", tg.NewPage().WithText(
 				"Type text and the bot will send you the lower case version",
 			).WithReply(
 				navToStartKeyboard.Widget(""),
@@ -169,9 +149,8 @@ var beh = tg.NewBehaviour().
 			),
 	),
 
-		tg.NewScreen("/start/send-location", tg.NewPage(
+	tg.NewNode(
-				"",
+		"send-location", tg.NewPage().WithReply(
-			).WithReply(
 			sendLocationKeyboard.Widget("Press the button to send your location!"),
 		).WithInline(
 			tg.NewKeyboard().Row(
@@ -186,7 +165,7 @@ var beh = tg.NewBehaviour().
 			).Inline().Widget("Press the button to display your counter"),
 		),
 	),
-	).WithCommands(
+)).WithCommands(
 	tg.NewCommand("start").
 		Desc("start or restart the bot or move to the start screen").
 		ActionFunc(func(c *tg.Context){
@@ -239,8 +218,7 @@ var gBeh = tg.NewGroupBehaviour().
 	)
 
 func main() {
-	log.Println(theNode.ScreenMap())
+	log.Println(beh.Screens)
-	return
 	token := os.Getenv("BOT_TOKEN")
 
 	bot, err := tg.NewBot(token)

tg/beh.go

@@ -37,8 +37,13 @@ func (b *Behaviour) WithInitFunc(
 	return b.WithInit(fn)
 }
 
+func (b *Behaviour) WithRootNode(node *RootNode) *Behaviour {
+	b.Screens = node.ScreenMap()
+	return b
+}
+
 // The function sets screens.
-func (b *Behaviour) WithScreens(
+/*func (b *Behaviour) WithScreens(
 	screens ...*Screen,
 ) *Behaviour {
 	for _, screen := range screens {
@@ -52,7 +57,7 @@ func (b *Behaviour) WithScreens(
 		b.Screens[screen.Id] = screen
 	}
 	return b
-}
+}*/
 
 // The function sets as the standard root widget CommandWidget
 // and its commands..
@@ -69,18 +74,19 @@ func (b *Behaviour) WithCommands(cmds ...*Command) *Behaviour {
 }
 
 // Check whether the screen exists in the behaviour.
-func (beh *Behaviour) ScreenExist(id ScreenId) bool {
+func (beh *Behaviour) PathExist(pth Path) bool {
-	_, ok := beh.Screens[id]
+	_, ok := beh.Screens[pth]
 	return ok
 }
 
 // Returns the screen by it's ID.
-func (beh *Behaviour) GetScreen(id ScreenId) *Screen {
+func (beh *Behaviour) GetScreen(pth Path) *Screen {
-	if !beh.ScreenExist(id) {
+	pth = pth.Clean()
+	if !beh.PathExist(pth) {
 		panic(ScreenNotExistErr)
 	}
 
-	screen := beh.Screens[id]
+	screen := beh.Screens[pth]
 	return screen
 }
 

tg/button.go

@@ -63,7 +63,7 @@ func (btn *Button) ActionFunc(fn ActionFunc) *Button {
 	return btn.WithAction(fn)
 }
 
-func (btn *Button) ScreenChange(sc ScreenChange) *Button {
+func (btn *Button) Go(sc ScreenChange) *Button {
 	return btn.WithAction(sc)
 }
 

tg/command.go

@@ -165,7 +165,7 @@ func (widget *CommandWidget) Serve(c *Context) {
 
 	var cmdUpdates *UpdateChan
 	for u := range c.Input() {
-		if c.CurScreen() == "" && u.Message != nil {
+		if c.Path() == "" && u.Message != nil {
 			// Skipping and executing the preinit action
 			// while we have the empty screen.
 			// E. g. the session did not start.

tg/page.go

@@ -15,12 +15,16 @@ type Page struct {
 }
 
 // Return new page with the specified text.
-func NewPage(text string) *Page {
+func NewPage() *Page {
 	ret := &Page{}
-	ret.Text = text
 	return ret
 }
 
+func (p *Page) WithText(text string) *Page {
+	p.Text = text
+	return p
+}
+
 // Set the inline keyboard.
 func (p *Page) WithInline(inline *InlineKeyboardWidget) *Page {
 	p.Inline = inline

tg/private.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 
 	//tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
-	"path"
+	//"path"
 )
 
 type ContextType string
@@ -25,7 +25,7 @@ type context struct {
 	Bot     *Bot
 	skippedUpdates *UpdateChan
 	// Current screen ID.
-	screenId, prevScreenId ScreenId
+	path, prevPath Path
 }
 
 // Goroutie function to handle each user.
@@ -42,17 +42,17 @@ func (c *context) run(a Action, u *Update) {
 	a.Act(&Context{context: c, Update:  u})
 }
 
-func (c *Context) CurScreen() ScreenId {
+func (c *Context) Path() Path {
-	return c.screenId
+	return c.path
 }
 
-func (c *Context) PrevScreen() ScreenId {
+func (c *Context) PrevPath() Path {
-	return c.prevScreenId
+	return c.prevPath
 }
 
 func (c *Context) Run(a Action, u *Update) {
 	if a != nil {
-		a.Act(&Context{context: c.context, Update: u})
+		a.Act(c.Copy().WithUpdate(u))
 	}
 }
 
@@ -144,13 +144,13 @@ func (af ActionFunc) Act(c *Context) {
 }
 
 // The type implements changing screen to the underlying ScreenId
-type ScreenChange ScreenId
+type ScreenChange Path
 
 func (sc ScreenChange) Act(c *Context) {
-	if !c.Bot.behaviour.ScreenExist(ScreenId(sc)) {
+	if !c.Bot.behaviour.PathExist(Path(sc)) {
 		panic(ScreenNotExistErr)
 	}
-	err := c.Go(ScreenId(sc))
+	err := c.Go(Path(sc))
 	if err != nil {
 		panic(err)
 	}
@@ -159,18 +159,22 @@ func (sc ScreenChange) Act(c *Context) {
 type C = Context
 
 // Changes screen of user to the Id one.
-func (c *Context) Go(screenId ScreenId, args ...any) error {
+func (c *Context) Go(pth Path, args ...any) error {
-	if !c.Bot.behaviour.ScreenExist(screenId) {
+	if !c.PathExist(pth) {
 		return ScreenNotExistErr
 	}
 
 	// Getting the screen and changing to
 	// then executing its widget.
-	screen := c.Bot.behaviour.Screens[screenId]
+	if !pth.IsAbs() {
-	c.prevScreenId = c.screenId
+		pth = (c.Path() + "/" + pth).Clean()
-	c.screenId = screenId
+	}
+
+	c.prevPath = c.path
+	c.path = pth
 
 	// Stopping the current widget.
+	screen := c.Bot.behaviour.Screens[pth]
 	c.skippedUpdates.Close()
 	if screen.Widget != nil {
 		c.skippedUpdates = c.RunWidget(screen.Widget, args...)
@@ -181,6 +185,10 @@ func (c *Context) Go(screenId ScreenId, args ...any) error {
 	return nil
 }
 
+func (c *Context) PathExist(pth Path) bool {
+	return c.Bot.behaviour.PathExist(pth)
+}
+
 // Run widget in background returning the new input channel for it.
 func (c *Context) RunWidget(widget Widget, args ...any) *UpdateChan {
 	if widget == nil {
@@ -209,12 +217,18 @@ func (c *Context) RunWidget(widget Widget, args ...any) *UpdateChan {
 	return updates
 }
 
+// Go to the root screen.
+func (c *Context) GoRoot() {
+	c.Go("/")
+}
+
+// Go one level upper in the screen hierarchy.
 func (c *Context) GoUp() {
-	c.Go(ScreenId(path.Dir(string(c.CurScreen()))))
+	c.Go(c.Path().Dir())
 }
 
 // Change screen to the previous.
 // To get to the parent screen use GoUp.
 func (c *Context) GoPrev() {
-	c.Go(c.PrevScreen())
+	c.Go(c.PrevPath())
 }

tg/screen.go

@@ -1,60 +1,100 @@
 package tg
 
-// Unique identifier for the screen.
+import (
-type ScreenId string
+	"path"
+)
+
+// Unique identifier for the screen
+// and relative paths to the screen.
+type Path string
+
+// Returns true if the path is empty.
+func (p Path) IsEmpty() bool {
+	return p == ""
+}
+
+// Returns true if the path is absolute.
+func (p Path) IsAbs() bool {
+	if len(p) == 0 {
+		return false
+	}
+	return p[0] == '/'
+}
+
+func (p Path) Dir() Path {
+	return Path(path.Dir(string(p)))
+}
+
+// Clean the path deleting exceed ., .. and / .
+func (p Path) Clean() Path {
+	return Path(path.Clean(string(p)))
+}
 
 // Screen statement of the bot.
 // Mostly what buttons to show.
 type Screen struct {
-	// Unique identifer to change to the screen
-	// via Context.ChangeScreen method.
-	Id ScreenId
 	// The widget to run when reaching the screen.
 	Widget Widget
 }
 
+// The first node with the "/" path.
+type RootNode struct {
+	Screen *Screen
+	Subs []*Node
+}
+
 // The node is a simple way to represent
 // tree-like structured applications.
 type Node struct {
+	Path Path
 	Screen *Screen
 	Subs []*Node
 }
 
-func NewNode(id ScreenId, widget Widget, subs ...*Node) *Node {
+// Return new root node with the specified widget in the screen.
-	ret := &Node{}
+func NewRootNode(widget Widget, subs ...*Node) *RootNode {
-	ret.Screen = NewScreen(id, widget)
+	ret := &RootNode{}
+	ret.Screen = NewScreen(widget)
 	ret.Subs = subs
 	return ret
 }
 
-func (n *Node) ScreenMap() ScreenMap {
+func NewNode(relPath Path, widget Widget, subs ...*Node) *Node {
-	m := make(ScreenMap)
+	ret := &Node{}
-	id := n.Screen.Id
+	ret.Path = relPath
-	m[id] = n.Screen
+	ret.Screen = NewScreen(widget)
-	n.Screen.Id = id
+	ret.Subs = subs
-	var root ScreenId
+	return ret
-	if id == "/" {
-		root = ""
-	} else {
-		root = id
 }
+
+func (n *RootNode) ScreenMap() ScreenMap {
+	m := make(ScreenMap)
+	var root Path = "/"
+	m[root] = n.Screen
 	for _, sub := range n.Subs {
-		buf := sub.screenMap(root + "/")
+		buf := sub.ScreenMap(root)
 		for k, v := range buf {
+			_, ok := m[k]
+			if ok {
+				panic("duplicate paths in node definition")
+			}
 			m[k] = v
 		}
 	}
 	return m
 }
 
-func (n *Node) screenMap(root ScreenId) ScreenMap {
+func (n *Node) ScreenMap(root Path) ScreenMap {
 	m := make(ScreenMap)
-	id := root+ n.Screen.Id
+	pth := (root + n.Path).Clean()
-	m[id] = n.Screen
+	m[pth] = n.Screen
-	n.Screen.Id = id
 	for _, sub := range n.Subs {
-		buf := sub.screenMap(id + "/")
+		buf := sub.ScreenMap((pth + "/").Clean())
 		for k, v := range buf {
+			_, ok := m[k]
+			if ok {
+				panic("duplicate paths in node definition")
+			}
 			m[k] = v
 		}
 	}
@@ -62,12 +102,11 @@ func (n *Node) screenMap(root ScreenId) ScreenMap {
 }
 
 // Map structure for the screens.
-type ScreenMap map[ScreenId]*Screen
+type ScreenMap map[Path] *Screen
 
 // Returns the new screen with specified name and widget.
-func NewScreen(id ScreenId, widget Widget) *Screen {
+func NewScreen(widget Widget) *Screen {
 	return &Screen{
-		Id: id,
 		Widget: widget,
 	}
 }