Merge pull request #532 from chrisallenlane/auto-config-bugfix

fix(config generation): issue #501

.travis.yml

@@ -2,3 +2,14 @@ language: go
 
 go:
   - 1.13.x
+
+os:
+  - linux
+  - osx
+
+env:
+  - GO111MODULE=on
+
+install: true
+
+script: make ci

Makefile

@@ -19,7 +19,7 @@ SORT   := sort
 ZIP    := zip -m
 
 # build flags
-BUILD_FLAGS  := -ldflags="-s -w" -mod vendor
+BUILD_FLAGS  := -ldflags="-s -w" -mod vendor -trimpath
 GOBIN        :=
 
 # release binaries
@@ -33,37 +33,41 @@ releases :=                        \
 
 ## build: builds an executable for your architecture
 .PHONY: build
-build: $(dist_dir)
+build: $(dist_dir) clean generate
 	$(GO) build $(BUILD_FLAGS) -o $(dist_dir)/cheat $(cmd_dir)
 
 ## build-release: builds release executables
 .PHONY: build-release
 build-release: $(releases)
 
+## ci: builds a "release" executable for the current architecture (used in ci)
+.PHONY: ci
+ci: | setup prepare build
+
 # cheat-darwin-amd64
 $(dist_dir)/cheat-darwin-amd64: prepare
 	GOARCH=amd64 GOOS=darwin \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@
+	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-amd64
 $(dist_dir)/cheat-linux-amd64: prepare
 	GOARCH=amd64 GOOS=linux \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@
+	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-arm5
 $(dist_dir)/cheat-linux-arm5: prepare
 	GOARCH=arm GOOS=linux GOARM=5 \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@
+	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-arm6
 $(dist_dir)/cheat-linux-arm6: prepare
 	GOARCH=arm GOOS=linux GOARM=6 \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@
+	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-arm7
 $(dist_dir)/cheat-linux-arm7: prepare
 	GOARCH=arm GOOS=linux GOARM=7 \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@
+	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-windows-amd64
 $(dist_dir)/cheat-windows-amd64.exe: prepare
@@ -91,7 +95,7 @@ clean: $(dist_dir)
 ## distclean: removes the tags file
 .PHONY: distclean
 distclean:
-	$(RM) ./tags
+	$(RM) -f tags
 
 ## setup: installs revive (linter) and scc (sloc tool)
 .PHONY: setup
@@ -106,7 +110,7 @@ sloc:
 ## tags: builds a tags file
 .PHONY: tags
 tags:
-	$(CTAGS) -R . --exclude=./vendor
+	$(CTAGS) -R --exclude=vendor --languages=go
 
 ## vendor: downloads, tidies, and verifies dependencies
 .PHONY: vendor

cmd/cheat/main.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"runtime"
+	"strings"
 
 	"github.com/docopt/docopt-go"
 
@@ -13,7 +14,7 @@ import (
 	"github.com/cheat/cheat/internal/config"
 )
 
-const version = "3.3.1"
+const version = "3.4.1"
 
 func main() {
 
@@ -31,13 +32,42 @@ func main() {
 		os.Exit(0)
 	}
 
-	// load the config file
+	// read the envvars into a map of strings
-	confpath, err := config.Path(runtime.GOOS)
+	envvars := map[string]string{}
+	for _, e := range os.Environ() {
+		pair := strings.SplitN(e, "=", 2)
+		envvars[pair[0]] = pair[1]
+	}
+
+	// load the os-specifc paths at which the config file may be located
+	confpaths, err := config.Paths(runtime.GOOS, envvars)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "could not locate config file")
+		fmt.Fprintf(os.Stderr, "failed to load config: %v\n", err)
 		os.Exit(1)
 	}
 
+	// search for the config file in the above paths
+	confpath, err := config.Path(confpaths)
+	if err != nil {
+
+		// the config file does not exist, so we'll try to create one
+		if err = config.Init(confpaths[0], configs()); err != nil {
+			fmt.Fprintf(
+				os.Stderr,
+				"failed to create config file: %s: %v\n",
+				confpaths[0],
+				err,
+			)
+			os.Exit(1)
+		}
+
+		confpath = confpaths[0]
+
+		fmt.Printf("Created config file: %s\n", confpath)
+		fmt.Println("Please edit this file now to configure cheat.")
+		os.Exit(0)
+	}
+
 	// initialize the configs
 	conf, err := config.New(opts, confpath, true)
 	if err != nil {

cmd/cheat/str_config.go

@@ -43,22 +43,23 @@ cheatpaths:
   #
   # Note that the paths and tags listed below are just examples. You may freely
   # change them to suit your needs.
+  #
+  # TODO: regarding community cheatsheets: these must be installed separately.
+  # You may download them here:
+  #
+  # https://github.com/cheat/cheatsheets
+  #
+  # Once downloaded, ensure that 'path' below points to the location at which
+  # you downloaded the community cheatsheets.
   - name: community
-    path: ~/.dotfiles/cheat/community
+    path: ~/cheat/cheatsheets/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
+    path: ~/cheat/cheatsheets/personal
     tags: [ personal ]
     readonly: false
 

configs/conf.yml

@@ -34,22 +34,23 @@ cheatpaths:
   #
   # Note that the paths and tags listed below are just examples. You may freely
   # change them to suit your needs.
+  #
+  # TODO: regarding community cheatsheets: these must be installed separately.
+  # You may download them here:
+  #
+  # https://github.com/cheat/cheatsheets
+  #
+  # Once downloaded, ensure that 'path' below points to the location at which
+  # you downloaded the community cheatsheets.
   - name: community
-    path: ~/.dotfiles/cheat/community
+    path: ~/cheat/cheatsheets/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
+    path: ~/cheat/cheatsheets/personal
     tags: [ personal ]
     readonly: false
 

internal/config/config.go

@@ -75,14 +75,16 @@ func New(opts map[string]interface{}, confPath string, resolve bool) (Config, er
 		// `resolve` is a switch that allows us to turn off symlink resolution when
 		// running the config tests.
 		if resolve {
-			expanded, err = filepath.EvalSymlinks(expanded)
+			evaled, err := filepath.EvalSymlinks(expanded)
 			if err != nil {
 				return Config{}, fmt.Errorf(
-					"failed to resolve symlink: %s, %v",
+					"failed to resolve symlink: %s: %v",
 					expanded,
 					err,
 				)
 			}
+
+			expanded = evaled
 		}
 
 		conf.Cheatpaths[i].Path = expanded

internal/config/init.go

@@ -0,0 +1,24 @@
+package config
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+// Init initializes a config file
+func Init(confpath string, configs string) error {
+
+	// assert that the config directory exists
+	if err := os.MkdirAll(filepath.Dir(confpath), 0755); err != nil {
+		return fmt.Errorf("failed to create directory: %v", err)
+	}
+
+	// write the config file
+	if err := ioutil.WriteFile(confpath, []byte(configs), 0644); err != nil {
+		return fmt.Errorf("failed to create file: %v", err)
+	}
+
+	return nil
+}

internal/config/path.go

@@ -3,43 +3,10 @@ package config
 import (
 	"fmt"
 	"os"
-	"path"
-
-	"github.com/mitchellh/go-homedir"
 )
 
 // Path returns the config file path
-func Path(sys string) (string, error) {
+func Path(paths []string) (string, error) {
-
-	var paths []string
-
-	// if CHEAT_CONFIG_PATH is set, return it
-	if os.Getenv("CHEAT_CONFIG_PATH") != "" {
-
-		// expand ~
-		expanded, err := homedir.Expand(os.Getenv("CHEAT_CONFIG_PATH"))
-		if err != nil {
-			return "", fmt.Errorf("failed to expand ~: %v", err)
-		}
-
-		return expanded, nil
-	}
-
-	switch sys {
-	case "darwin", "linux", "freebsd":
-		paths = []string{
-			path.Join(os.Getenv("XDG_CONFIG_HOME"), "/cheat/conf.yml"),
-			path.Join(os.Getenv("HOME"), ".config/cheat/conf.yml"),
-			path.Join(os.Getenv("HOME"), ".cheat/conf.yml"),
-		}
-	case "windows":
-		paths = []string{
-			fmt.Sprintf("%s/cheat/conf.yml", os.Getenv("APPDATA")),
-			fmt.Sprintf("%s/cheat/conf.yml", os.Getenv("PROGRAMDATA")),
-		}
-	default:
-		return "", fmt.Errorf("unsupported os: %s", sys)
-	}
 
 	// check if the config file exists on any paths
 	for _, p := range paths {

internal/config/paths.go

@@ -0,0 +1,50 @@
+package config
+
+import (
+	"fmt"
+	"path"
+
+	"github.com/mitchellh/go-homedir"
+)
+
+// Paths returns config file paths that are appropriate for the operating
+// system
+func Paths(sys string, envvars map[string]string) ([]string, error) {
+
+	// if `CHEAT_CONFIG_PATH` is set, expand ~ and return it
+	if confpath, ok := envvars["CHEAT_CONFIG_PATH"]; ok {
+
+		// expand ~
+		expanded, err := homedir.Expand(confpath)
+		if err != nil {
+			return []string{}, fmt.Errorf("failed to expand ~: %v", err)
+		}
+
+		return []string{expanded}, nil
+	}
+
+	switch sys {
+	case "darwin", "linux", "freebsd":
+		paths := []string{}
+
+		// don't include the `XDG_CONFIG_HOME` path if that envvar is not set
+		if xdgpath, ok := envvars["XDG_CONFIG_HOME"]; ok {
+			paths = append(paths, path.Join(xdgpath, "/cheat/conf.yml"))
+		}
+
+		// `HOME` will always be set on a POSIX-compliant system, though
+		paths = append(paths, []string{
+			path.Join(envvars["HOME"], ".config/cheat/conf.yml"),
+			path.Join(envvars["HOME"], ".cheat/conf.yml"),
+		}...)
+
+		return paths, nil
+	case "windows":
+		return []string{
+			path.Join(envvars["APPDATA"], "/cheat/conf.yml"),
+			path.Join(envvars["PROGRAMDATA"], "/cheat/conf.yml"),
+		}, nil
+	default:
+		return []string{}, fmt.Errorf("unsupported os: %s", sys)
+	}
+}

internal/config/paths_test.go

@@ -0,0 +1,165 @@
+package config
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+// TestValidatePathsNix asserts that the proper config paths are returned on
+// *nix platforms
+func TestValidatePathsNix(t *testing.T) {
+
+	// mock some envvars
+	envvars := map[string]string{
+		"HOME":            "/home/foo",
+		"XDG_CONFIG_HOME": "/home/bar",
+	}
+
+	// specify the platforms to test
+	oses := []string{
+		"darwin",
+		"freebsd",
+		"linux",
+	}
+
+	// test each *nix os
+	for _, os := range oses {
+		// get the paths for the platform
+		paths, err := Paths(os, envvars)
+		if err != nil {
+			t.Errorf("paths returned an error: %v", err)
+		}
+
+		// specify the expected output
+		want := []string{
+			"/home/bar/cheat/conf.yml",
+			"/home/foo/.config/cheat/conf.yml",
+			"/home/foo/.cheat/conf.yml",
+		}
+
+		// assert that output matches expectations
+		if !reflect.DeepEqual(paths, want) {
+			t.Errorf(
+				"failed to return expected paths: want:\n%s, got:\n%s",
+				spew.Sdump(want),
+				spew.Sdump(paths),
+			)
+		}
+	}
+}
+
+// TestValidatePathsNixNoXDG asserts that the proper config paths are returned
+// on *nix platforms when `XDG_CONFIG_HOME is not set
+func TestValidatePathsNixNoXDG(t *testing.T) {
+
+	// mock some envvars
+	envvars := map[string]string{
+		"HOME": "/home/foo",
+	}
+
+	// specify the platforms to test
+	oses := []string{
+		"darwin",
+		"freebsd",
+		"linux",
+	}
+
+	// test each *nix os
+	for _, os := range oses {
+		// get the paths for the platform
+		paths, err := Paths(os, envvars)
+		if err != nil {
+			t.Errorf("paths returned an error: %v", err)
+		}
+
+		// specify the expected output
+		want := []string{
+			"/home/foo/.config/cheat/conf.yml",
+			"/home/foo/.cheat/conf.yml",
+		}
+
+		// assert that output matches expectations
+		if !reflect.DeepEqual(paths, want) {
+			t.Errorf(
+				"failed to return expected paths: want:\n%s, got:\n%s",
+				spew.Sdump(want),
+				spew.Sdump(paths),
+			)
+		}
+	}
+}
+
+// TestValidatePathsWindows asserts that the proper config paths are returned
+// on Windows platforms
+func TestValidatePathsWindows(t *testing.T) {
+
+	// mock some envvars
+	envvars := map[string]string{
+		"APPDATA":     "/apps",
+		"PROGRAMDATA": "/programs",
+	}
+
+	// get the paths for the platform
+	paths, err := Paths("windows", envvars)
+	if err != nil {
+		t.Errorf("paths returned an error: %v", err)
+	}
+
+	// specify the expected output
+	want := []string{
+		"/apps/cheat/conf.yml",
+		"/programs/cheat/conf.yml",
+	}
+
+	// assert that output matches expectations
+	if !reflect.DeepEqual(paths, want) {
+		t.Errorf(
+			"failed to return expected paths: want:\n%s, got:\n%s",
+			spew.Sdump(want),
+			spew.Sdump(paths),
+		)
+	}
+}
+
+// TestValidatePathsUnsupported asserts that an error is returned on
+// unsupported platforms
+func TestValidatePathsUnsupported(t *testing.T) {
+	_, err := Paths("unsupported", map[string]string{})
+	if err == nil {
+		t.Errorf("failed to return error on unsupported platform")
+	}
+}
+
+// TestValidatePathsCheatConfigPath asserts that the proper config path is
+// returned when `CHEAT_CONFIG_PATH` is explicitly specified.
+func TestValidatePathsCheatConfigPath(t *testing.T) {
+
+	// mock some envvars
+	envvars := map[string]string{
+		"HOME":              "/home/foo",
+		"XDG_CONFIG_HOME":   "/home/bar",
+		"CHEAT_CONFIG_PATH": "/home/baz/conf.yml",
+	}
+
+	// get the paths for the platform
+	paths, err := Paths("linux", envvars)
+	if err != nil {
+		t.Errorf("paths returned an error: %v", err)
+	}
+
+	// specify the expected output
+	want := []string{
+		"/home/baz/conf.yml",
+	}
+
+	// assert that output matches expectations
+	if !reflect.DeepEqual(paths, want) {
+		t.Errorf(
+			"failed to return expected paths: want:\n%s, got:\n%s",
+			spew.Sdump(want),
+			spew.Sdump(paths),
+		)
+	}
+}