Re-wrote from scratch in Golang

- Re-implemented the project in Golang, and deprecated Python entirely
- Implemented several new, long-requested features
- Refactored cheatsheets into a separate repository

cmd/cheat/cmd_directories.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/cheat/cheat/internal/config"
+)
+
+// cmdDirectories lists the configured cheatpaths.
+func cmdDirectories(opts map[string]interface{}, conf config.Config) {
+
+	// initialize a tabwriter to produce cleanly columnized output
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
+
+	// generate sorted, columnized output
+	for _, path := range conf.Cheatpaths {
+		fmt.Fprintln(w, fmt.Sprintf(
+			"%s:\t%s",
+			path.Name,
+			path.Path,
+		))
+	}
+
+	// write columnized output to stdout
+	w.Flush()
+}

cmd/cheat/cmd_edit.go

@@ -0,0 +1,111 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"strings"
+
+	"github.com/cheat/cheat/internal/cheatpath"
+	"github.com/cheat/cheat/internal/config"
+	"github.com/cheat/cheat/internal/sheets"
+)
+
+// cmdEdit opens a cheatsheet for editing (or creates it if it doesn't exist).
+func cmdEdit(opts map[string]interface{}, conf config.Config) {
+
+	cheatsheet := opts["--edit"].(string)
+
+	// load the cheatsheets
+	cheatsheets, err := sheets.Load(conf.Cheatpaths)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to list cheatsheets: %v", err))
+		os.Exit(1)
+	}
+
+	// filter cheatcheats by tag if --tag was provided
+	if opts["--tag"] != nil {
+		cheatsheets = sheets.Filter(
+			cheatsheets,
+			strings.Split(opts["--tag"].(string), ","),
+		)
+	}
+
+	// consolidate the cheatsheets found on all paths into a single map of
+	// `title` => `sheet` (ie, allow more local cheatsheets to override less
+	// local cheatsheets)
+	consolidated := sheets.Consolidate(cheatsheets)
+
+	// the file path of the sheet to edit
+	var editpath string
+
+	// determine if the sheet exists
+	sheet, ok := consolidated[cheatsheet]
+
+	// if the sheet exists and is not read-only, edit it in place
+	if ok && !sheet.ReadOnly {
+		editpath = sheet.Path
+
+		// if the sheet exists but is read-only, copy it before editing
+	} else if ok && sheet.ReadOnly {
+		// compute the new edit path
+		// begin by getting a writeable cheatpath
+		writepath, err := cheatpath.Writeable(conf.Cheatpaths)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to get writeable path: %v\n", err)
+			os.Exit(1)
+		}
+
+		// compute the new edit path
+		editpath = path.Join(writepath.Path, sheet.Title)
+
+		// create any necessary subdirectories
+		dirs := path.Dir(editpath)
+		if dirs != "." {
+			if err := os.MkdirAll(dirs, 0755); err != nil {
+				fmt.Fprintf(os.Stderr, "failed to create directory: %s, %v\n", dirs, err)
+				os.Exit(1)
+			}
+		}
+
+		// copy the sheet to the new edit path
+		err = sheet.Copy(editpath)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to copy cheatsheet: %v\n", err)
+			os.Exit(1)
+		}
+
+		// if the sheet does not exist, create it
+	} else {
+		// compute the new edit path
+		// begin by getting a writeable cheatpath
+		writepath, err := cheatpath.Writeable(conf.Cheatpaths)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to get writeable path: %v\n", err)
+			os.Exit(1)
+		}
+
+		// compute the new edit path
+		editpath = path.Join(writepath.Path, cheatsheet)
+
+		// create any necessary subdirectories
+		dirs := path.Dir(editpath)
+		if dirs != "." {
+			if err := os.MkdirAll(dirs, 0755); err != nil {
+				fmt.Fprintf(os.Stderr, "failed to create directory: %s, %v\n", dirs, err)
+				os.Exit(1)
+			}
+		}
+	}
+
+	// edit the cheatsheet
+	cmd := exec.Command(conf.Editor, editpath)
+	cmd.Stdout = os.Stdout
+	cmd.Stdin = os.Stdin
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "failed to edit cheatsheet: %v\n", err)
+		os.Exit(1)
+	}
+}

cmd/cheat/cmd_init.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	"fmt"
+)
+
+// cmdInit displays an example config file.
+func cmdInit() {
+	fmt.Println(configs())
+}

cmd/cheat/cmd_list.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/cheat/cheat/internal/config"
+	"github.com/cheat/cheat/internal/sheet"
+	"github.com/cheat/cheat/internal/sheets"
+)
+
+// cmdList lists all available cheatsheets.
+func cmdList(opts map[string]interface{}, conf config.Config) {
+
+	// load the cheatsheets
+	cheatsheets, err := sheets.Load(conf.Cheatpaths)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to list cheatsheets: %v", err))
+		os.Exit(1)
+	}
+
+	// filter cheatcheats by tag if --tag was provided
+	if opts["--tag"] != nil {
+		cheatsheets = sheets.Filter(
+			cheatsheets,
+			strings.Split(opts["--tag"].(string), ","),
+		)
+	}
+
+	// instead of "consolidating" all of the cheatsheets (ie, overwriting global
+	// sheets with local sheets), here we simply want to create a slice
+	// containing all sheets.
+	flattened := []sheet.Sheet{}
+	for _, pathSheets := range cheatsheets {
+		for _, s := range pathSheets {
+			flattened = append(flattened, s)
+		}
+	}
+
+	// sort the "flattened" sheets alphabetically
+	sort.Slice(flattened, func(i, j int) bool {
+		return flattened[i].Title < flattened[j].Title
+	})
+
+	// exit early if no cheatsheets are available
+	if len(flattened) == 0 {
+		os.Exit(0)
+	}
+
+	// initialize a tabwriter to produce cleanly columnized output
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
+
+	// generate sorted, columnized output
+	fmt.Fprintln(w, "title:\tfile:\ttags:")
+	for _, sheet := range flattened {
+		fmt.Fprintln(w, fmt.Sprintf(
+			"%s\t%s\t%s",
+			sheet.Title,
+			sheet.Path,
+			strings.Join(sheet.Tags, ","),
+		))
+	}
+
+	// write columnized output to stdout
+	w.Flush()
+}

cmd/cheat/cmd_search.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/cheat/cheat/internal/config"
+	"github.com/cheat/cheat/internal/sheets"
+)
+
+// cmdSearch searches for strings in cheatsheets.
+func cmdSearch(opts map[string]interface{}, conf config.Config) {
+
+	phrase := opts["--search"].(string)
+
+	// load the cheatsheets
+	cheatsheets, err := sheets.Load(conf.Cheatpaths)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to list cheatsheets: %v", err))
+		os.Exit(1)
+	}
+
+	// filter cheatcheats by tag if --tag was provided
+	if opts["--tag"] != nil {
+		cheatsheets = sheets.Filter(
+			cheatsheets,
+			strings.Split(opts["--tag"].(string), ","),
+		)
+	}
+
+	// consolidate the cheatsheets found on all paths into a single map of
+	// `title` => `sheet` (ie, allow more local cheatsheets to override less
+	// local cheatsheets)
+	consolidated := sheets.Consolidate(cheatsheets)
+
+	// sort the cheatsheets alphabetically, and search for matches
+	for _, sheet := range sheets.Sort(consolidated) {
+
+		// colorize output?
+		colorize := false
+		if conf.Colorize == true || opts["--colorize"] == true {
+			colorize = true
+		}
+
+		// assume that we want to perform a case-insensitive search for <phrase>
+		pattern := "(?i)" + phrase
+
+		// unless --regex is provided, in which case we pass the regex unaltered
+		if opts["--regex"] == true {
+			pattern = phrase
+		}
+
+		// compile the regex
+		reg, err := regexp.Compile(pattern)
+		if err != nil {
+			fmt.Errorf("failed to compile regexp: %s, %v", pattern, err)
+			os.Exit(1)
+		}
+
+		// search the sheet
+		matches := sheet.Search(reg, colorize)
+
+		// display the results
+		if len(matches) > 0 {
+			fmt.Printf("%s:\n", sheet.Title)
+			for _, m := range matches {
+				fmt.Printf("  %d: %s\n", m.Line, m.Text)
+			}
+			fmt.Print("\n")
+		}
+	}
+
+}

cmd/cheat/cmd_view.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/alecthomas/chroma/quick"
+
+	"github.com/cheat/cheat/internal/config"
+	"github.com/cheat/cheat/internal/sheets"
+)
+
+// cmdView displays a cheatsheet for viewing.
+func cmdView(opts map[string]interface{}, conf config.Config) {
+
+	cheatsheet := opts["<cheatsheet>"].(string)
+
+	// load the cheatsheets
+	cheatsheets, err := sheets.Load(conf.Cheatpaths)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to list cheatsheets: %v", err))
+		os.Exit(1)
+	}
+
+	// filter cheatcheats by tag if --tag was provided
+	if opts["--tag"] != nil {
+		cheatsheets = sheets.Filter(
+			cheatsheets,
+			strings.Split(opts["--tag"].(string), ","),
+		)
+	}
+
+	// consolidate the cheatsheets found on all paths into a single map of
+	// `title` => `sheet` (ie, allow more local cheatsheets to override less
+	// local cheatsheets)
+	consolidated := sheets.Consolidate(cheatsheets)
+
+	// fail early if the requested cheatsheet does not exist
+	sheet, ok := consolidated[cheatsheet]
+	if !ok {
+		fmt.Printf("No cheatsheet found for '%s'.\n", cheatsheet)
+		os.Exit(0)
+	}
+
+	// if colorization is not desired, output un-colorized text and exit
+	if conf.Colorize == false && opts["--colorize"] == false {
+		fmt.Print(sheet.Text)
+		os.Exit(0)
+	}
+
+	// otherwise, colorize the output
+	// if the syntax was not specified, default to bash
+	lex := sheet.Syntax
+	if lex == "" {
+		lex = "bash"
+	}
+
+	// apply syntax highlighting
+	err = quick.Highlight(
+		os.Stdout,
+		sheet.Text,
+		lex,
+		conf.Formatter,
+		conf.Style,
+	)
+
+	// if colorization somehow failed, output non-colorized text
+	if err != nil {
+		fmt.Print(sheet.Text)
+	}
+}

cmd/cheat/docopt.txt

@@ -0,0 +1,43 @@
+Usage:
+  cheat [options] [<cheatsheet>]
+
+Options:
+  --init                Write a default config file to stdout
+  -c --colorize         Colorize output
+  -d --directories      List cheatsheet directories
+  -e --edit=<sheet>     Edit cheatsheet
+  -l --list             List cheatsheets
+  -p --path=<name>      Return only sheets found on path <name>
+  -r --regex            Treat search <phrase> as a regex
+  -s --search=<phrase>  Search cheatsheets for <phrase>
+  -t --tag=<tag>        Return only sheets matching <tag>
+  -v --version          Print the version number
+
+Examples:
+
+  To initialize a config file:
+    mkdir -p ~/.config/cheat && cheat --init > ~/.config/cheat/conf.yml
+
+  To view the tar cheatsheet:
+    cheat tar
+
+  To edit (or create) the foo cheatsheet:
+    cheat -e foo
+
+  To edit (or create) the foo/bar cheatsheet on the "work" cheatpath:
+    cheat -p work -e foo/bar
+
+  To view all cheatsheet directories:
+    cheat -d
+
+  To list all available cheatsheets:
+    cheat -l
+
+  To list available cheatsheets that are tagged as "personal":
+    cheat -l -t personal
+
+  To search for "ssh" among all cheatsheets, and colorize matches:
+    cheat -c -s ssh
+
+  To search (by regex) for cheatsheets that contain an IP address:
+    cheat -c -r -s '(?:[0-9]{1,3}\.){3}[0-9]{1,3}'

cmd/cheat/main.go

@@ -0,0 +1,92 @@
+package main
+
+//go:generate go run ../../build/embed.go
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+
+	"github.com/docopt/docopt-go"
+
+	"github.com/cheat/cheat/internal/cheatpath"
+	"github.com/cheat/cheat/internal/config"
+)
+
+const version = "3.0.0-rc0"
+
+func main() {
+
+	// initialize options
+	opts, err := docopt.Parse(usage(), nil, true, version, false)
+	if err != nil {
+		// panic here, because this should never happen
+		panic(fmt.Errorf("docopt failed to parse: %v", err))
+	}
+
+	// if --init was passed, we don't want to attempt to load a config file.
+	// Instead, just execute cmd_init and exit
+	if opts["--init"] != nil && opts["--init"] == true {
+		cmdInit()
+		os.Exit(0)
+	}
+
+	// load the config file
+	confpath, err := config.Path(runtime.GOOS)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "could not locate config file")
+		os.Exit(1)
+	}
+
+	// initialize the configs
+	conf, err := config.New(opts, confpath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to load config: %v\n", err)
+		os.Exit(1)
+	}
+
+	// assert that the configs are valid
+	if err := conf.Validate(); err != nil {
+		fmt.Fprintf(os.Stderr, "failed to load config: %v\n", err)
+		os.Exit(1)
+	}
+
+	// filter the cheatpaths if --path was passed
+	if opts["--path"] != nil {
+		conf.Cheatpaths, err = cheatpath.Filter(
+			conf.Cheatpaths,
+			opts["--path"].(string),
+		)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "invalid option --path: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	// determine which command to execute
+	var cmd func(map[string]interface{}, config.Config)
+
+	switch {
+	case opts["--directories"].(bool):
+		cmd = cmdDirectories
+
+	case opts["--edit"] != nil:
+		cmd = cmdEdit
+
+	case opts["--list"].(bool):
+		cmd = cmdList
+
+	case opts["--search"] != nil:
+		cmd = cmdSearch
+
+	case opts["<cheatsheet>"] != nil:
+		cmd = cmdView
+
+	default:
+		fmt.Println(usage())
+		os.Exit(0)
+	}
+
+	// execute the command
+	cmd(opts, conf)
+}

cmd/cheat/str_config.go

@@ -0,0 +1,65 @@
+package main
+
+// Code generated .* DO NOT EDIT.
+
+import (
+	"strings"
+)
+
+func configs() string {
+	return strings.TrimSpace(`---
+# The editor to use with 'cheat -e <sheet>'. Defaults to $EDITOR or $VISUAL.
+editor: vim
+
+# Should 'cheat' always colorize output?
+colorize: true
+
+# Which 'chroma' colorscheme should be applied to the output?
+# Options are available here:
+#   https://github.com/alecthomas/chroma/tree/master/styles
+style: monokai
+
+# Which 'chroma' "formatter" should be applied?
+# One of: "terminal", "terminal256", "terminal16m"
+formatter: terminal16m
+
+# The paths at which cheatsheets are available. Tags associated with a cheatpath
+# are automatically attached to all cheatsheets residing on that path.
+#
+# Whenever cheatsheets share the same title (like 'tar'), the most local
+# cheatsheets (those which come later in this file) take precedent over the
+# less local sheets. This allows you to create your own "overides" for
+# "upstream" cheatsheets.
+#
+# But what if you want to view the "upstream" cheatsheets instead of your own?
+# Cheatsheets may be filtered via 'cheat -f <tag>' in combination with other
+# commands. So, if you want to view the 'tar' cheatsheet that is tagged as
+# 'community' rather than your own, you can use: cheat tar -f community
+cheatpaths:
+
+  # Paths that come earlier are considered to be the most "global", and will
+  # thus be overridden by more local cheatsheets. That being the case, you
+  # should probably list community cheatsheets first.
+  #
+  # Note that the paths and tags listed below are just examples. You may freely
+  # change them to suit your needs.
+  - name: community
+    path: ~/.dotfiles/cheat/community
+    tags: [ community ]
+    readonly: true
+
+  # Maybe your company or department maintains a repository of cheatsheets as
+  # well. It's probably sensible to list those second.
+  - name: work
+    path: ~/.dotfiles/cheat/work
+    tags: [ work ]
+    readonly: false
+
+  # If you have personalized cheatsheets, list them last. They will take
+  # precedence over the more global cheatsheets.
+  - name: personal
+    path: ~/.dotfiles/cheat/personal
+    tags: [ personal ]
+    readonly: false
+`)
+}

cmd/cheat/str_usage.go

@@ -0,0 +1,54 @@
+package main
+
+// Code generated .* DO NOT EDIT.
+
+import (
+	"strings"
+)
+
+func usage() string {
+	return strings.TrimSpace(`Usage:
+  cheat [options] [<cheatsheet>]
+
+Options:
+  --init                Write a default config file to stdout
+  -c --colorize         Colorize output
+  -d --directories      List cheatsheet directories
+  -e --edit=<sheet>     Edit cheatsheet
+  -l --list             List cheatsheets
+  -p --path=<name>      Return only sheets found on path <name>
+  -r --regex            Treat search <phrase> as a regex
+  -s --search=<phrase>  Search cheatsheets for <phrase>
+  -t --tag=<tag>        Return only sheets matching <tag>
+  -v --version          Print the version number
+
+Examples:
+
+  To initialize a config file:
+    mkdir -p ~/.config/cheat && cheat --init > ~/.config/cheat/conf.yml
+
+  To view the tar cheatsheet:
+    cheat tar
+
+  To edit (or create) the foo cheatsheet:
+    cheat -e foo
+
+  To edit (or create) the foo/bar cheatsheet on the "work" cheatpath:
+    cheat -p work -e foo/bar
+
+  To view all cheatsheet directories:
+    cheat -d
+
+  To list all available cheatsheets:
+    cheat -l
+
+  To list available cheatsheets that are tagged as "personal":
+    cheat -l -t personal
+
+  To search for "ssh" among all cheatsheets, and colorize matches:
+    cheat -c -s ssh
+
+  To search (by regex) for cheatsheets that contain an IP address:
+    cheat -c -r -s '(?:[0-9]{1,3}\.){3}[0-9]{1,3}'
+`)
+}