commands

Documentation

Index

• Variables
• func NewBase(name, desc string) base
• type Category
  • func NewCategory(title, prompt string, subcommands ...Command) *Category
  • func (c *Category) CursorDown()
  • func (c *Category) CursorUp()
  • func (c *Category) Selected() Command
• type Command
• type Result
  • func NewResult(result string, commandName string) Result
  • func (r Result) Command() string
  • func (r Result) IsFromCommand(cmd Command) bool
  • func (r Result) Out() string

Variables

var (
	Converters = func() []Command {
		var converters []Command

		converters = append(converters, yamlToJson{
			base: NewBase("YAML -> JSON", "Convert YAML to JSON"),
		})
		converters = append(converters, jsonToYaml{
			base: NewBase("JSON -> YAML", "Convert JSON to YAML"),
		})

		bases := []int{2, 8, 10, 16}
		for _, from := range bases {
			for _, to := range bases {
				if from != to {
					converters = append(converters, numberBaseConverter{
						base:     NewBase(fmt.Sprintf("%s -> %s", toPrettyBase(from), toPrettyBase(to)), ""),
						fromBase: from,
						toBase:   to,
					})
				}
			}
		}
		return converters
	}
)

var (
	EncodersDecoders = func() []Command {
		var converters []Command
		converters = append(converters, base64enc{
			base: NewBase("Base64 Encode", "Encode input to base64"),
		})
		converters = append(converters, base64dec{
			base: NewBase("Base64 Decode", "Decode input from base64"),
		})
		converters = append(converters, urlenc{
			base: NewBase("URL Encode", "Encode input to url"),
		})
		converters = append(converters, urldec{
			base: NewBase("URL Decode", "Decode input from url encoded"),
		})
		converters = append(converters, htmlenc{
			base: NewBase("HTML Escape", "Encode input to HTML escape characters"),
		})
		converters = append(converters, htmldec{
			base: NewBase("HTML Unescape", "Decode input from HTML escape characters"),
		})
		converters = append(converters, jwtdec{
			base: NewBase("JWT Decode", ""),
		})
		return converters
	}
)

var (
	Formatters = func() []Command {
		var commands []Command

		commands = append(commands, jsonPrettifier{
			base: NewBase("JSON Pretty Print", ""),
		})

		commands = append(commands, jsonMinifier{
			base: NewBase("JSON Minifier", ""),
		})

		return commands
	}
)

var (
	Generators = func() []Command {
		var commands []Command

		commands = append(commands, hashGenerator{
			base:   NewBase("MD5 Hash Generator", ""),
			hasher: md5.New(),
		})

		commands = append(commands, hashGenerator{
			base:   NewBase("SHA1 Hash Generator", ""),
			hasher: sha1.New(),
		})

		commands = append(commands, hashGenerator{
			base:   NewBase("SHA256 Hash Generator", ""),
			hasher: sha256.New(),
		})

		commands = append(commands, hashGenerator{
			base:   NewBase("SHA512 Hash Generator", ""),
			hasher: sha512.New(),
		})

		commands = append(commands, secretGenerator{
			base:   NewBase("16 Character Secret", "").withoutInputDisplay(),
			length: 16,
		})

		commands = append(commands, secretGenerator{
			base:   NewBase("32 Character Secret", "").withoutInputDisplay(),
			length: 32,
		})

		commands = append(commands, secretGenerator{
			base:   NewBase("64 Character Secret", "").withoutInputDisplay(),
			length: 64,
		})

		commands = append(commands, uuidGenerator{
			base:   NewBase("UUID v1", "date-time and mac address").withoutInputDisplay(),
			random: false,
		})

		commands = append(commands, uuidGenerator{
			base:   NewBase("UUID v4", "randoms").withoutInputDisplay(),
			random: false,
		})

		commands = append(commands, uuidGenerator{
			base: NewBase("Nil UUID", "zero").withoutInputDisplay(),
			zero: true,
		})

		commands = append(commands, lipsumGenerator{
			base:       NewBase("Lipsum - 1 Paragraph", "").withoutInputDisplay(),
			paragraphs: 1,
		})
		commands = append(commands, lipsumGenerator{
			base:       NewBase("Lipsum - 2 Paragraphs", "").withoutInputDisplay(),
			paragraphs: 2,
		})
		commands = append(commands, lipsumGenerator{
			base:       NewBase("Lipsum - 3 Paragraphs", "").withoutInputDisplay(),
			paragraphs: 3,
		})

		return commands
	}
)

Functions

func NewBase

func NewBase(name, desc string) base

Types

type Category

type Category struct {
	Title       string
	Prompt      string
	Subcommands []Command
	Cursor      int
}

func NewCategory

func NewCategory(title, prompt string, subcommands ...Command) *Category

func (*Category) CursorDown

func (c *Category) CursorDown()

func (*Category) CursorUp

func (c *Category) CursorUp()

func (*Category) Selected

func (c *Category) Selected() Command

type Command

type Command interface {
	Name() string
	Exec(string) (string, error)
	DisplayInput(string) string
	DisplayOutput(string) string
	ShouldDisplayInput() bool
}

type Result

type Result struct {
	// contains filtered or unexported fields
}

func NewResult

func NewResult(result string, commandName string) Result

func (Result) Command

func (r Result) Command() string

func (Result) IsFromCommand

func (r Result) IsFromCommand(cmd Command) bool

func (Result) Out

func (r Result) Out() string