hofstadter-io / hofmod-cli Goto Github PK

View Code? Open in Web Editor NEW

25.0 3.0 2.0 136 KB

Hofstadter generator for Golang CLIs

Home Page: https://github.com/hofstadter-io/hof

License: BSD 3-Clause "New" or "Revised" License

Go 71.57% CUE 25.83% Makefile 2.60%

cue cuelang hof-lang hof cli golang dsl code-generator

hofmod-cli's Introduction

hofmod-cli

A hof generator for creating advanced Golang CLIs.

Design your CLI structure, arguments, flags, and a whole host of addons and then generate the implementation. Changed your mind about what your CLI should look like? Redesign, regenerate, and keep adding you custom code.

Features:

Quickly architect your CLI commands, arguments, flags, configuration
Built on the fantastic [spf13/cobra](https://github.com/ andspf13/cobra)library for Golang CLIs
Cross-platform builds and releases using GoReleaser, GitHub, and Docker
Supports config files in local project falling back to OS specific application dir
Your CLI will self check for updates and can self install with a user command
Shell auto completion for bash, fish, zsh, and power shell
Advanced help system with support for custom overviews, extra topics, and examples
Telemetry systems which can hook up to Google Analytics
Golang pprof and many other ENV VARs to control inner behavior

Sites to see:

Schema - the design spec your write a CLI in
Generator - hof generator definition you invoke
Templates and partials - files which implement the code
Example - the hof tool leverages and powers this, see the hof.cue and design directory for relevant files

Usage

You'll need the hof tool installed. You can download hof from the releases page.

Let's start a new project:

# Start a project
hof init github.com/verdverm/my-cli
cd my-cli

Add the following to the cue.mods file (same format as go.mod)

module github.com/verdverm/my-cli

cue master

require (
    github.com/hofstadter-io/hofmod-cli v0.7.0
)

To fetch the module, run:

hof mod vendor cue

# and after the next file, run
hof gen

Create a file named cli.cue and add the following content:

package cli

import (
	"github.com/hofstadter-io/hofmod-cli/schema"

	"github.com/hofstadter-io/hof/design/cli/cmds"
)

# Typically we put the cli under a nested directory
#Outdir: "./cmd/hof"

#CLI: schema.#Cli & {
    # Name and package path (matches outdir)
	Name:    "hof"
	Package: "github.com/hofstadter-io/hof/cmd/hof"

    # Usage and help
	Usage:      "hof"
	Short:      "Polyglot Development Tool and Framework"
	Long:       Short
	CustomHelp: #RootCustomHelp

    # Print the help when no subcommands are supplied
	OmitRun: true

    # Command stage hooks
	PersistentPrerun:     true
    # You can write code here or...
	PersistentPrerunBody: "runtime.Init()"
 
	PersistentPostrun: true
    # ...or add custom code right in the output

    # Persistent flags work for all subcommands too
    Pflags: [{
		Name:    "labels"
		Long:    "label"
		Short:   "l"
		Type:    "[]string"
		Default: "nil"
		Help:    "Labels for use across all commands"
	}, {
		Name:    "config"
		Long:    "config"
		Short:   ""
		Type:    "string"
		Default: ""
		Help:    "Path to a hof configuration file"
	}, ...]

    # Subcommands and nested down as far as you need
	Commands: [

	]

	//
	// Addons
	//
	Releases: #CliReleases
	Updates:  true

    ...
}

(this was adapted from the [hof](https://github.com/hofstadter-io/hof t) tool)

Now run hof gen to generate your code. Try adding implementation, and then build:

go build -o my-cli cmd/my-cli/main.go

./my-cli

Update your designs, rerun hof gen, rebuild and keep iterating away!

hofmod-cli's People

Contributors

Stargazers

Watchers

Forkers

mrunkel jornh

hofmod-cli's Issues

Go embed several types of files

Long help as Go embed
command examples as txtar files, also embed
topics & tutorials too

Update for GoReleaser v1

also incorp Cosign

FlagPole updates

Docs strings, default to help & flag default
DeaultFlagPole func for when not using via CLI

always generates update and version subcommands

I'm explicitly setting the schema fields to false:

#CLI: schema.#Cli & {
	Name: "test"
	Package: "example.com/test/test/cmd/test"
	Short: "a test"

	CompletionCommands: false
	Updates: false
	
    OmitRun: false

	Pflags: [...schema.#Flag] & [{
		Name: "test"
		Long: "test"
		Short: "t"
		Type: "string"
		Default: ""
		Help: "test test test"
	}]

	// Commands: []
}

and while they are not added to the Cmd in root.go the actual commands still get generated:

cmd/test
├── cmd
│  ├── completions.go
│  ├── hls
│  │  └── cli
│  │     └── root
│  │        └── help.hls
│  ├── root.go
│  ├── root_test.go
│  ├── update.go
│  └── version.go
├── flags
│  └── root.go
├── main.go
└── verinfo
   └── verinfo.go

which makes the build fail like this:

building go files...
go build -o test ./cmd/test
go: finding module for package example.com/test/test/cmd/test/ga
cmd/test/cmd/completions.go:8:2: cannot find module providing package example.com/test/test/cmd/test/ga: module example.com/test/test/cmd/test/ga: git ls-remote -q origin in /home/user/go/pkg/mod/cache/vcs/BLAAAAAAAAAA: exit status 128:
	ERROR: Repository not found.
	fatal: Could not read from remote repository.
	
	Please make sure you have the correct access rights
	and the repository exists.
make: *** [Makefile:10: build] Error 1

generated "rest" args will panic when the extra arg is not present

This below was generated from, not sure why the rest is there? I think we use it to pass remaining args to the template, but where is the config? Did I put this in manually?

#CreateCommand: schema.#Command & {
	Name:  "create"
	Usage: "create <module location>"
	Short: "dynamic blueprints from any git repo"
	Long:  #CreateRootHelp

	Args: [{
		Name: "module"
		Type: "string"
		Required: false
		Help: "git repository or directory with a creator, accepts subdirs on both"
	}]

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		// Argument Parsing

		var module string

		if 0 < len(args) {

			module = args[0]

		}

		err = CreateRun(module, args[1:])
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},