The best way to make a easy interactive shell in Go

What’s extra thrilling than making real-world functions? 🤔
for me, it is educating individuals tips on how to make them once more!

Our Examine

As I’ve spoken about my Dockeroller undertaking earlier in my articles, it is a undertaking that show you how to management your docker deamon by way of totally different gates, comparable to Telegram or API.

I noticed this gates needs to be simply configurable by person,
We should always have the ability to flip some gates on or off, change their tokens, ports, and passwords, and so on.
One strategy, was utilizing Viper and dockeroller.yml file (implementing and educating this strategy is in my todo checklist)

One other strategy, will be an interactive shell!
Let’s do it!

Accomplished code is out there in my Github gists (Hyperlink).

Welcome to the stage!

Attempt to be clear by separating issues!
On this case, I separated my code into totally different phases,
comparable to:

• Welcome stage
• Assist stage
• Gates stage
• Telegram
• API

Every stage has a message that we outlined utilizing constants at the start of the code, in greater initiatives, they could possibly be positioned in for instance a msg bundle.

We used backtick for multiline strings and we wrote fixed sort solely as soon as as a result of all of them are in identical sort.

const (
    msg_welcome string = `
Welcome to Dockeroller!
It is pattern multiline!
`

    msg_help = `
Dockeroller is an open-source undertaking made for enjoyable.
It is pattern multiline!
`

Do it without end!

The only type of interactive shells, use an infinite loop and it iterates till you break it,
However don’t fret, it is not unhealthy in any respect, I will inform you why.

In any iteration, we get one thing new from the person, in that point, our app isn’t consuming any useful resource,
After passing desired enter to the shell, it’s going to course of the end result and go to the subsequent iteration.
Really, our shell is continually sleeping between iterations, it is ready for us to go it our enter.

Take a look at this code:

func major() {
  var stage int = 0
  for {
    swap stage {
    case 0:
      stage = StageWelcome()
    case 1:
      stage = StageHelp()
    case 2:
      stage = StageGates()
    case 11:
      stage = StageTelegram()
    case 12:
      stage = StageAPI()
    }
  }
}

Capabilities began with the phrase StageXxx() are our handlers, they deal with what occurs in (on 😅) a stage, we’ll get into them quickly.

Additionally it might be clear that any stage is assigned to a quantity, but it surely could possibly be assigned to anything, however that is probably not wanted for a undertaking this dimension.

As a recap
We have now a for loop, we iterate over it and in each iteration, we test which stage we’re on (utilizing swap) and deal with that stage.

Additionally, we replace our stage after every iteration, however why?

The place would you prefer to go after?

It is time to replace our welcome message!

const (
    msg_welcome string = `
Welcome to Dockeroller!
The place would you prefer to go after? (select solely quantity)
1 - assist
2 - gates
`

So we let person resolve which stage is its subsequent place!
and it is the rationale we replace stage each time.
Updating stage variable is part of navigating between Phases.
And every handler, in line with its inputs, will resolve the place we’d go subsequent.

Shell enter & output

What’s the level of this text with out going into terminal itself?
That is simply really easy, you might know tips on how to use fmt.Print() perform, it Prints one thing on the terminal, With none default formatting.
There are another variants of it comparable to fmt.Println() for printing with a line break and fmt.Printf() for printing with a specified format.

OK, there are just a few extra capabilities in fmt bundle, right here we’d like fmt.Scanln() or fmt.Scan() (there may be additionally a fmt.Scanf() for scanning in line with a specified format)

Let’s have a quite simple instance:

bundle major

import "fmt"

func major() {
  var title string
  fmt.Scanln(&title)
  fmt.Println("hi there", title)
}

In case you do not go pointer to Scanln, it will not have any impact.

We will add additional print statements to make it extra stunning.
We will additionally go a number of pointers of various sorts to it, Scan will separate them by area after which populate them.

bundle major

import "fmt"

func major() {
  var title string
  var age int
  fmt.Print("> ") // Only for magnificence
  fmt.Scanln(&title, &age)
  fmt.Println("Howdy", title, "you are", age, "years outdated.")
}

Output will probably be like:

Fundamental Handlers

I feel this could make sense now:

// Welcome stage handler
func StageWelcome() int {
  fmt.Print(msg_welcome)
  return getStage()
}

// Assist stage handler
func StageHelp() int {
  fmt.Print(msg_help)
  return getStage()
}

// Helper perform for asking stage quantity and return it for subsequent choices
func getStage() (stage int) {
  fmt.Print("> ")
  fmt.Scanln(&stage)
  return
}

In case you suppose it is not clear, I recommend you to place this codes collectively at times transfer on.

Gates handlers

Welcome is a primary stage stage
Assist and Gates are Second stage
Telegram & API are third stage
and there will be extra ranges.

How can we understand it?
properly, there are various algorithms for it, however right here, if we’re in gates stage and we should always go on with possibility 1 (telegram) or 2 (api) I add 10 to stage quantity, and in major swap, telegram will probably be 11 and api will probably be 12.
if we need to come again from this stage, we are going to return 0 which means Welcome (stage) handler.

func StageGates() int {
  fmt.Print(msg_gates)
  if stage := getStage(); stage != 0 {
    return stage + 10
  }
  return 0
}

Telegram & API handlers

I simply clarify one among them, comply with the identical strategy.

func StageTelegram() int {
  fmt.Print(msg_telegram)

  // Get a worth (token) 
  var token string
  getInput("Token: ", &token)

  // Get one other worth (username) 
  var username string
  getInput("Username: @", &username)
  // Telegram usernames begin with @,
  // Some customers could embrace it, some could not,
  // So we helped customers by together with it.
  // And username variable will not have @ in it.

  fmt.Println("Username and token efficiently sat!")
  return 0 // Return to the principle menu after succefull config
}

// Helper perform to print a message and get a worth (by populating a pointer)
func getInput(msg string, worth interface{}) {
  fmt.Print(msg)
  fmt.Scanln(worth) // DO NOT embrace &, as a result of it is a pointer when is handed to this perform!
}

Closing quote

I hope you loved this text, be happy to share your ideas and critics with me.