Merge pull request #514 from chrisallenlane/master

fix: colorization errors

bin/build_devel.sh

@@ -4,6 +4,9 @@
 BINDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 APPDIR=$(readlink -f "$BINDIR/..")
 
+# update the vendored dependencies
+go mod vendor && go mod tidy
+
 # compile the executable
 cd "$APPDIR/cmd/cheat"
 go clean && go generate && go build -mod vendor

bin/build_release.sh

@@ -4,6 +4,9 @@
 BINDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 APPDIR=$(readlink -f "$BINDIR/..")
 
+# update the vendored dependencies
+go mod vendor && go mod tidy
+
 # build embeds
 cd "$APPDIR/cmd/cheat"
 go clean && go generate

cmd/cheat/cmd_list.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"regexp"
 	"sort"
 	"strings"
 	"text/tabwriter"
@@ -45,6 +46,39 @@ func cmdList(opts map[string]interface{}, conf config.Config) {
 		return flattened[i].Title < flattened[j].Title
 	})
 
+	// filter if <cheatsheet> was specified
+	// NB: our docopt specification is misleading here. When used in conjunction
+	// with `-l`, `<cheatsheet>` is really a pattern against which to filter
+	// sheet titles.
+	if opts["<cheatsheet>"] != nil {
+
+		// initialize a slice of filtered sheets
+		filtered := []sheet.Sheet{}
+
+		// initialize our filter pattern
+		pattern := "(?i)" + opts["<cheatsheet>"].(string)
+
+		// compile the regex
+		reg, err := regexp.Compile(pattern)
+		if err != nil {
+			fmt.Fprintln(
+				os.Stderr,
+				fmt.Sprintf("failed to compile regexp: %s, %v", pattern, err),
+			)
+			os.Exit(1)
+		}
+
+		// iterate over each cheatsheet, and pass-through those which match the
+		// filter pattern
+		for _, s := range flattened {
+			if reg.MatchString(s.Title) {
+				filtered = append(filtered, s)
+			}
+		}
+
+		flattened = filtered
+	}
+
 	// exit early if no cheatsheets are available
 	if len(flattened) == 0 {
 		os.Exit(0)

cmd/cheat/cmd_remove.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/cheat/cheat/internal/config"
+	"github.com/cheat/cheat/internal/sheets"
+)
+
+// cmdRemove opens a cheatsheet for editing (or creates it if it doesn't exist).
+func cmdRemove(opts map[string]interface{}, conf config.Config) {
+
+	cheatsheet := opts["--rm"].(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.Fprintln(os.Stderr, fmt.Sprintf("no cheatsheet found for '%s'.\n", cheatsheet))
+		os.Exit(1)
+	}
+
+	// fail early if the sheet is read-only
+	if sheet.ReadOnly {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("cheatsheet '%s' is read-only.", cheatsheet))
+		os.Exit(1)
+	}
+
+	// otherwise, attempt to delete the sheet
+	if err := os.Remove(sheet.Path); err != nil {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to delete sheet: %s, %v", sheet.Title, err))
+		os.Exit(1)
+	}
+}

cmd/cheat/cmd_search.go

@@ -38,12 +38,6 @@ func cmdSearch(opts map[string]interface{}, conf config.Config) {
 	// 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
 
@@ -55,12 +49,12 @@ func cmdSearch(opts map[string]interface{}, conf config.Config) {
 		// compile the regex
 		reg, err := regexp.Compile(pattern)
 		if err != nil {
-			fmt.Errorf("failed to compile regexp: %s, %v", pattern, err)
+			fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to compile regexp: %s, %v", pattern, err))
 			os.Exit(1)
 		}
 
 		// search the sheet
-		matches := sheet.Search(reg, colorize)
+		matches := sheet.Search(reg, conf.Color(opts))
 
 		// display the results
 		if len(matches) > 0 {

cmd/cheat/cmd_tags.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/cheat/cheat/internal/config"
+	"github.com/cheat/cheat/internal/sheets"
+)
+
+// cmdTags lists all tags in use.
+func cmdTags(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)
+	}
+
+	// write sheet tags to stdout
+	for _, tag := range sheets.Tags(cheatsheets) {
+		fmt.Println(tag)
+	}
+}

cmd/cheat/cmd_view.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	"github.com/alecthomas/chroma/quick"
-	"github.com/mattn/go-isatty"
 
 	"github.com/cheat/cheat/internal/config"
 	"github.com/cheat/cheat/internal/sheets"
@@ -44,20 +43,7 @@ func cmdView(opts map[string]interface{}, conf config.Config) {
 		os.Exit(0)
 	}
 
-	// apply colorization if so configured ...
+	if !conf.Color(opts) {
-	colorize := conf.Colorize
-
-	// ... or if --colorized were passed ...
-	if opts["--colorize"] == true {
-		colorize = true
-	}
-
-	// ... unless we're outputting to a non-TTY
-	if !isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()) {
-		colorize = false
-	}
-
-	if !colorize {
 		fmt.Print(sheet.Text)
 		os.Exit(0)
 	}

cmd/cheat/docopt.txt

@@ -5,13 +5,15 @@ Options:
   --init                Write a default config file to stdout
   -c --colorize         Colorize output
   -d --directories      List cheatsheet directories
-  -e --edit=<sheet>     Edit cheatsheet
+  -e --edit=<sheet>     Edit <sheet>
   -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>
+  -T --tags             List all tags in use
   -v --version          Print the version number
+  --rm=<sheet>          Remove (delete) <sheet>
 
 Examples:
 
@@ -33,6 +35,12 @@ Examples:
   To list all available cheatsheets:
     cheat -l
 
+  To list all cheatsheets whose titles match "apt":
+    cheat -l apt
+
+  To list all tags in use:
+    cheat -T
+
   To list available cheatsheets that are tagged as "personal":
     cheat -l -t personal
 
@@ -41,3 +49,6 @@ Examples:
 
   To search (by regex) for cheatsheets that contain an IP address:
     cheat -c -r -s '(?:[0-9]{1,3}\.){3}[0-9]{1,3}'
+
+  To remove (delete) the foo/bar cheatsheet:
+    cheat --rm foo/bar

cmd/cheat/main.go

@@ -13,7 +13,7 @@ import (
 	"github.com/cheat/cheat/internal/config"
 )
 
-const version = "3.0.4"
+const version = "3.2.1"
 
 func main() {
 
@@ -39,7 +39,7 @@ func main() {
 	}
 
 	// initialize the configs
-	conf, err := config.New(opts, confpath)
+	conf, err := config.New(opts, confpath, true)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "failed to load config: %v\n", err)
 		os.Exit(1)
@@ -76,9 +76,15 @@ func main() {
 	case opts["--list"].(bool):
 		cmd = cmdList
 
+	case opts["--tags"].(bool):
+		cmd = cmdTags
+
 	case opts["--search"] != nil:
 		cmd = cmdSearch
 
+	case opts["--rm"] != nil:
+		cmd = cmdRemove
+
 	case opts["<cheatsheet>"] != nil:
 		cmd = cmdView
 

cmd/cheat/str_usage.go

@@ -14,13 +14,15 @@ Options:
   --init                Write a default config file to stdout
   -c --colorize         Colorize output
   -d --directories      List cheatsheet directories
-  -e --edit=<sheet>     Edit cheatsheet
+  -e --edit=<sheet>     Edit <sheet>
   -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>
+  -T --tags             List all tags in use
   -v --version          Print the version number
+  --rm=<sheet>          Remove (delete) <sheet>
 
 Examples:
 
@@ -42,6 +44,12 @@ Examples:
   To list all available cheatsheets:
     cheat -l
 
+  To list all cheatsheets whose titles match "apt":
+    cheat -l apt
+
+  To list all tags in use:
+    cheat -T
+
   To list available cheatsheets that are tagged as "personal":
     cheat -l -t personal
 
@@ -50,5 +58,8 @@ Examples:
 
   To search (by regex) for cheatsheets that contain an IP address:
     cheat -c -r -s '(?:[0-9]{1,3}\.){3}[0-9]{1,3}'
+
+  To remove (delete) the foo/bar cheatsheet:
+    cheat --rm foo/bar
 `)
 }

go.mod

@@ -3,13 +3,12 @@ module github.com/cheat/cheat
 go 1.13
 
 require (
-	github.com/alecthomas/chroma v0.6.7
+	github.com/alecthomas/chroma v0.6.9
 	github.com/davecgh/go-spew v1.1.1
 	github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815
 	github.com/mattn/go-isatty v0.0.10
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/tj/front v0.0.0-20170212063142-739be213b0a1
+	gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0
-	gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0 // indirect
+	gopkg.in/yaml.v2 v2.2.7
-	gopkg.in/yaml.v2 v2.2.4
 )

go.sum

@@ -3,8 +3,8 @@ github.com/GeertJohan/go.rice v1.0.0/go.mod h1:eH6gbSOAUv07dQuZVnBmoDP8mgsM1rtix
 github.com/akavel/rsrc v0.8.0/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
 github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38 h1:smF2tmSOzy2Mm+0dGI2AIUHY+w0BUc+4tn40djz7+6U=
 github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38/go.mod h1:r7bzyVFMNntcxPZXK3/+KdruV1H5KSlyVY0gc+NgInI=
-github.com/alecthomas/chroma v0.6.7 h1:1hKci+AyKOxJrugR9veaocu9DQGR2/GecI72BpaO0Rg=
+github.com/alecthomas/chroma v0.6.9 h1:afiCdwnNPo6fcyvoqqsXs78t7NbR9TuW4wDB7NJkcag=
-github.com/alecthomas/chroma v0.6.7/go.mod h1:zVlgtbRS7BJDrDY9SB238RmpoCBCYFlLmcfZ3durxTk=
+github.com/alecthomas/chroma v0.6.9/go.mod h1:1U/PfCsTALWWYHDnsIQkxEBM0+6LLe0v8+RSVMOwxeY=
 github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721 h1:JHZL0hZKJ1VENNfmXvHbgYlbUOvpzYzvy2aZU5gXVeo=
 github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721/go.mod h1:QO9JBoKquHd+jz9nshCh40fOfO+JzsoXy8qTHF68zU0=
 github.com/alecthomas/kong v0.1.17-0.20190424132513-439c674f7ae0/go.mod h1:+inYUSluD+p4L8KdviBSgzcqEjUQOfC5fQDRFuc36lI=
@@ -50,8 +50,6 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/tj/front v0.0.0-20170212063142-739be213b0a1 h1:lA+aPRvltlx2fwv/BnxyYSDQo3pIeqzHgMO5GvK0T9E=
-github.com/tj/front v0.0.0-20170212063142-739be213b0a1/go.mod h1:deJrtusCTptAW4EUn5vBLpl3dhNqPqUwEjWJz5UNxpQ=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
 golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 h1:YAFjXN64LMvktoUZH9zgY4lGc/msGN7HQfoSuKCgaDU=
@@ -62,5 +60,5 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0 h1:POO/ycCATvegFmVuPpQzZFJ+pGZeX22Ufu6fibxDVjU=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
-gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
+gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

internal/config/color.go

@@ -0,0 +1,26 @@
+package config
+
+import (
+	"os"
+
+	"github.com/mattn/go-isatty"
+)
+
+// Color indicates whether colorization should be applied to the output
+func (c *Config) Color(opts map[string]interface{}) bool {
+
+	// default to the colorization specified in the configs...
+	colorize := c.Colorize
+
+	// ... however, only apply colorization if we're writing to a tty...
+	if !isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()) {
+		colorize = false
+	}
+
+	// ... *unless* the --colorize flag was passed
+	if opts["--colorize"] == true {
+		colorize = true
+	}
+
+	return colorize
+}

internal/config/config.go

@@ -22,7 +22,7 @@ type Config struct {
 }
 
 // New returns a new Config struct
-func New(opts map[string]interface{}, confPath string) (Config, error) {
+func New(opts map[string]interface{}, confPath string, resolve bool) (Config, error) {
 
 	// read the config file
 	buf, err := ioutil.ReadFile(confPath)
@@ -49,6 +49,14 @@ func New(opts map[string]interface{}, confPath string) (Config, error) {
 		}
 
 		// follow symlinks
+		//
+		// NB: `resolve` is an ugly kludge that exists for the sake of unit-tests.
+		// It's necessary because `EvalSymlinks` will error if the symlink points
+		// to a non-existent location on the filesystem. When unit-testing,
+		// however, we don't want to have dependencies on the filesystem. As such,
+		// `resolve` is a switch that allows us to turn off symlink resolution when
+		// running the config tests.
+		if resolve {
 			expanded, err = filepath.EvalSymlinks(expanded)
 			if err != nil {
 				return Config{}, fmt.Errorf(
@@ -57,6 +65,7 @@ func New(opts map[string]interface{}, confPath string) (Config, error) {
 					err,
 				)
 			}
+		}
 
 		conf.Cheatpaths[i].Path = expanded
 	}

internal/config/config_test.go

@@ -17,7 +17,7 @@ import (
 func TestConfigSuccessful(t *testing.T) {
 
 	// initialize a config
-	conf, err := New(map[string]interface{}{}, mock.Path("conf/conf.yml"))
+	conf, err := New(map[string]interface{}{}, mock.Path("conf/conf.yml"), false)
 	if err != nil {
 		t.Errorf("failed to parse config file: %v", err)
 	}
@@ -69,7 +69,7 @@ func TestConfigSuccessful(t *testing.T) {
 func TestConfigFailure(t *testing.T) {
 
 	// attempt to read a non-existent config file
-	_, err := New(map[string]interface{}{}, "/does-not-exit")
+	_, err := New(map[string]interface{}{}, "/does-not-exit", false)
 	if err == nil {
 		t.Errorf("failed to error on unreadable config")
 	}
@@ -84,14 +84,14 @@ func TestEmptyEditor(t *testing.T) {
 	os.Setenv("EDITOR", "")
 
 	// initialize a config
-	conf, err := New(map[string]interface{}{}, mock.Path("conf/empty.yml"))
+	conf, err := New(map[string]interface{}{}, mock.Path("conf/empty.yml"), false)
 	if err == nil {
 		t.Errorf("failed to return an error on empty editor")
 	}
 
 	// set editor, and assert that it is respected
 	os.Setenv("EDITOR", "foo")
-	conf, err = New(map[string]interface{}{}, mock.Path("conf/empty.yml"))
+	conf, err = New(map[string]interface{}{}, mock.Path("conf/empty.yml"), false)
 	if err != nil {
 		t.Errorf("failed to init configs: %v", err)
 	}
@@ -101,7 +101,7 @@ func TestEmptyEditor(t *testing.T) {
 
 	// set visual, and assert that it overrides editor
 	os.Setenv("VISUAL", "bar")
-	conf, err = New(map[string]interface{}{}, mock.Path("conf/empty.yml"))
+	conf, err = New(map[string]interface{}{}, mock.Path("conf/empty.yml"), false)
 	if err != nil {
 		t.Errorf("failed to init configs: %v", err)
 	}

internal/frontmatter/frontmatter.go

@@ -0,0 +1,34 @@
+package frontmatter
+
+import (
+	"strings"
+
+	"gopkg.in/yaml.v1"
+)
+
+// Frontmatter encapsulates cheatsheet frontmatter data
+type Frontmatter struct {
+	Tags   []string
+	Syntax string
+}
+
+// Parse parses cheatsheet frontmatter
+func Parse(markdown string) (string, Frontmatter, error) {
+
+	// specify the frontmatter delimiter
+	delim := "---"
+
+	// initialize a frontmatter struct
+	var fm Frontmatter
+
+	// if the markdown does not contain frontmatter, pass it through unmodified
+	if !strings.HasPrefix(markdown, delim) {
+		return strings.TrimSpace(markdown), fm, nil
+	}
+
+	// otherwise, split the frontmatter and cheatsheet text
+	parts := strings.SplitN(markdown, delim, 3)
+	err := yaml.Unmarshal([]byte(parts[1]), &fm)
+
+	return strings.TrimSpace(parts[2]), fm, err
+}

internal/frontmatter/frontmatter_test.go

@@ -0,0 +1,71 @@
+package frontmatter
+
+import (
+	"testing"
+)
+
+// TestHasFrontmatter asserts that markdown is properly parsed when it contains
+// frontmatter
+func TestHasFrontmatter(t *testing.T) {
+
+	// stub our cheatsheet content
+	markdown := `---
+syntax: go
+tags: [ test ]
+---
+To foo the bar: baz`
+
+	// parse the frontmatter
+	text, fm, err := Parse(markdown)
+
+	// assert expectations
+	if err != nil {
+		t.Errorf("failed to parse markdown: %v", err)
+	}
+
+	want := "To foo the bar: baz"
+	if text != want {
+		t.Errorf("failed to parse text: want: %s, got: %s", want, text)
+	}
+
+	want = "go"
+	if fm.Syntax != want {
+		t.Errorf("failed to parse syntax: want: %s, got: %s", want, fm.Syntax)
+	}
+
+	want = "test"
+	if fm.Tags[0] != want {
+		t.Errorf("failed to parse tags: want: %s, got: %s", want, fm.Tags[0])
+	}
+	if len(fm.Tags) != 1 {
+		t.Errorf("failed to parse tags: want: len 0, got: len %d", len(fm.Tags))
+	}
+}
+
+// TestHasFrontmatter asserts that markdown is properly parsed when it does not
+// contain frontmatter
+func TestHasNoFrontmatter(t *testing.T) {
+
+	// stub our cheatsheet content
+	markdown := "To foo the bar: baz"
+
+	// parse the frontmatter
+	text, fm, err := Parse(markdown)
+
+	// assert expectations
+	if err != nil {
+		t.Errorf("failed to parse markdown: %v", err)
+	}
+
+	if text != markdown {
+		t.Errorf("failed to parse text: want: %s, got: %s", markdown, text)
+	}
+
+	if fm.Syntax != "" {
+		t.Errorf("failed to parse syntax: want: '', got: %s", fm.Syntax)
+	}
+
+	if len(fm.Tags) != 0 {
+		t.Errorf("failed to parse tags: want: len 0, got: len %d", len(fm.Tags))
+	}
+}

internal/sheet/sheet.go

@@ -4,17 +4,10 @@ import (
 	"fmt"
 	"io/ioutil"
 	"sort"
-	"strings"
 
-	"github.com/tj/front"
+	"github.com/cheat/cheat/internal/frontmatter"
 )
 
-// frontmatter is an un-exported helper struct used in parsing cheatsheets
-type frontmatter struct {
-	Tags   []string
-	Syntax string
-}
-
 // Sheet encapsulates sheet information
 type Sheet struct {
 	Title    string
@@ -39,9 +32,8 @@ func New(
 		return Sheet{}, fmt.Errorf("failed to read file: %s, %v", path, err)
 	}
 
-	// parse the front-matter
+	// parse the cheatsheet frontmatter
-	var fm frontmatter
+	text, fm, err := frontmatter.Parse(string(markdown))
-	text, err := front.Unmarshal(markdown, &fm)
 	if err != nil {
 		return Sheet{}, fmt.Errorf("failed to parse front-matter: %v", err)
 	}
@@ -56,7 +48,7 @@ func New(
 	return Sheet{
 		Title:    title,
 		Path:     path,
-		Text:     strings.TrimSpace(string(text)) + "\n",
+		Text:     text + "\n",
 		Tags:     tags,
 		Syntax:   fm.Syntax,
 		ReadOnly: readOnly,

internal/sheets/load.go

@@ -45,7 +45,7 @@ func Load(cheatpaths []cp.Cheatpath) ([]map[string]sheet.Sheet, error) {
 				// accessed. Eg: `cheat tar` - `tar` is the title)
 				title := strings.TrimPrefix(
 					strings.TrimPrefix(path, cheatpath.Path),
-					"/",
+					string(os.PathSeparator),
 				)
 
 				// ignore hidden files and directories. Otherwise, we'll likely load

internal/sheets/tags.go

@@ -0,0 +1,36 @@
+package sheets
+
+import (
+	"sort"
+
+	"github.com/cheat/cheat/internal/sheet"
+)
+
+// Tags returns a slice of all tags in use in any sheet
+func Tags(cheatpaths []map[string]sheet.Sheet) []string {
+
+	// create a map of all tags in use in any sheet
+	tags := make(map[string]bool)
+
+	// iterate over all tags on all sheets on all cheatpaths
+	for _, path := range cheatpaths {
+		for _, sheet := range path {
+			for _, tag := range sheet.Tags {
+				tags[tag] = true
+			}
+		}
+	}
+
+	// restructure the map into a slice
+	sorted := []string{}
+	for tag := range tags {
+		sorted = append(sorted, tag)
+	}
+
+	// sort the slice
+	sort.Slice(sorted, func(i, j int) bool {
+		return sorted[i] < sorted[j]
+	})
+
+	return sorted
+}

internal/sheets/tags_test.go

@@ -0,0 +1,51 @@
+package sheets
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+
+	"github.com/cheat/cheat/internal/sheet"
+)
+
+// TestTags asserts that cheetsheet tags are properly returned
+func TestTags(t *testing.T) {
+
+	// mock cheatsheets available on multiple cheatpaths
+	cheatpaths := []map[string]sheet.Sheet{
+
+		// mock community cheatsheets
+		map[string]sheet.Sheet{
+			"foo": sheet.Sheet{Title: "foo", Tags: []string{"alpha"}},
+			"bar": sheet.Sheet{Title: "bar", Tags: []string{"alpha", "bravo"}},
+		},
+
+		// mock local cheatsheets
+		map[string]sheet.Sheet{
+			"bar": sheet.Sheet{Title: "bar", Tags: []string{"bravo", "charlie"}},
+			"baz": sheet.Sheet{Title: "baz", Tags: []string{"delta"}},
+		},
+	}
+
+	// consolidate the cheatsheets
+	tags := Tags(cheatpaths)
+
+	// specify the expected output
+	want := []string{
+		"alpha",
+		"bravo",
+		"charlie",
+		"delta",
+	}
+
+	// assert that the cheatsheets properly consolidated
+	if !reflect.DeepEqual(tags, want) {
+		t.Errorf(
+			"failed to return tags: want:\n%s, got:\n%s",
+			spew.Sdump(want),
+			spew.Sdump(tags),
+		)
+	}
+
+}

scripts/cheat-autocompletion.fish

@@ -7,5 +7,7 @@ complete -c cheat -s l -l list -d "List cheatsheets"
 complete -c cheat -s p -l path -x -a "(cheat -d | cut -d ':' -f 1)" -d "Return only sheets found on given path"
 complete -c cheat -s r -l regex -d "Treat search phrase as a regex"
 complete -c cheat -s s -l search -x -d "Search cheatsheets for given phrase"
-complete -c cheat -s t -l tag -x -a "(cheat -l | tail -n +2 | rev | cut -d ' ' -f 1 | rev | sed 's/,/\n/g;/^\$/d' | sort -u)" -d "Return only sheets matching the given tag"
+complete -c cheat -s t -l tag -x -a "(cheat -T)" -d "Return only sheets matching the given tag"
+complete -c cheat -s T -l tags -d "List all tags in use"
 complete -c cheat -s v -l version -d "Print the version number"
+complete -c cheat -l rm -x -a "(cheat -l | tail -n +2 | cut -d ' ' -f 1)" -d "Remove (delete) cheatsheet"

vendor/github.com/alecthomas/chroma/.golangci.yml

@@ -15,6 +15,9 @@ linters:
     - gocyclo
     - dupl
     - gochecknoglobals
+    - funlen
+    - godox
+    - wsl
 
 linters-settings:
   govet:
@@ -43,3 +46,6 @@ issues:
     - 'Potential file inclusion via variable'
     - 'should have comment or be unexported'
     - 'comment on exported var .* should be of the form'
+    - 'at least one file in a package should have a package comment'
+    - 'string literal contains the Unicode'
+    - 'methods on the same type should have the same receiver name'

vendor/github.com/alecthomas/chroma/.travis.yml

@@ -2,7 +2,7 @@ sudo: false
 language: go
 script:
   - go test -v ./...
-  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s v1.15.0
+  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s v1.20.0
   - ./bin/golangci-lint run
   - git clean -fdx .
 after_success:

vendor/github.com/alecthomas/chroma/README.md

@@ -44,7 +44,7 @@ F | Factor, Fish, Forth, Fortran, FSharp
 G | GAS, GDScript, Genshi, Genshi HTML, Genshi Text, GLSL, Gnuplot, Go, Go HTML Template, Go Text Template, GraphQL, Groovy
 H | Handlebars, Haskell, Haxe, HCL, Hexdump, HTML, HTTP, Hy
 I | Idris, INI, Io
-J | Java, JavaScript, JSON, Julia, Jungle
+J | J, Java, JavaScript, JSON, Julia, Jungle
 K | Kotlin
 L | Lighttpd configuration file, LLVM, Lua
 M | Mako, markdown, Mason, Mathematica, Matlab, MiniZinc, Modula-2, MonkeyC, MorrowindScript, Myghty, MySQL

vendor/github.com/alecthomas/chroma/delegate.go

@@ -34,7 +34,7 @@ type insertion struct {
 	tokens     []Token
 }
 
-func (d *delegatingLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error) {
+func (d *delegatingLexer) Tokenise(options *TokeniseOptions, text string) (Iterator, error) { // nolint: gocognit
 	tokens, err := Tokenise(Coalesce(d.language), options, text)
 	if err != nil {
 		return nil, err

vendor/github.com/alecthomas/chroma/formatters/api.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/alecthomas/chroma"
 	"github.com/alecthomas/chroma/formatters/html"
+	"github.com/alecthomas/chroma/formatters/svg"
 )
 
 var (
@@ -20,6 +21,7 @@ var (
 	}))
 	// Default HTML formatter outputs self-contained HTML.
 	htmlFull = Register("html", html.New(html.Standalone(), html.WithClasses())) // nolint
+	SVG      = Register("svg", svg.New(svg.EmbedFont("Liberation Mono", svg.FontLiberationMono, svg.WOFF)))
 )
 
 // Fallback formatter.

vendor/github.com/alecthomas/chroma/formatters/html/html.go

@@ -91,11 +91,6 @@ func (h highlightRanges) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
 func (h highlightRanges) Less(i, j int) bool { return h[i][0] < h[j][0] }
 
 func (f *Formatter) Format(w io.Writer, style *chroma.Style, iterator chroma.Iterator) (err error) {
-	defer func() {
-		if perr := recover(); perr != nil {
-			err = perr.(error)
-		}
-	}()
 	return f.writeHTML(w, style, iterator.Tokens())
 }
 

vendor/github.com/alecthomas/chroma/formatters/svg/svg.go

@@ -0,0 +1,222 @@
+// Package svg contains an SVG formatter.
+package svg
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path"
+	"strings"
+
+	"github.com/alecthomas/chroma"
+)
+
+// Option sets an option of the SVG formatter.
+type Option func(f *Formatter)
+
+// FontFamily sets the font-family.
+func FontFamily(fontFamily string) Option { return func(f *Formatter) { f.fontFamily = fontFamily } }
+
+// EmbedFontFile embeds given font file
+func EmbedFontFile(fontFamily string, fileName string) (option Option, err error) {
+	var format FontFormat
+	switch path.Ext(fileName) {
+	case ".woff":
+		format = WOFF
+	case ".woff2":
+		format = WOFF2
+	case ".ttf":
+		format = TRUETYPE
+	default:
+		return nil, errors.New("unexpected font file suffix")
+	}
+
+	var content []byte
+	if content, err = ioutil.ReadFile(fileName); err == nil {
+		option = EmbedFont(fontFamily, base64.StdEncoding.EncodeToString(content), format)
+	}
+	return
+}
+
+// EmbedFont embeds given base64 encoded font
+func EmbedFont(fontFamily string, font string, format FontFormat) Option {
+	return func(f *Formatter) { f.fontFamily = fontFamily; f.embeddedFont = font; f.fontFormat = format }
+}
+
+// New SVG formatter.
+func New(options ...Option) *Formatter {
+	f := &Formatter{fontFamily: "Consolas, Monaco, Lucida Console, Liberation Mono, DejaVu Sans Mono, Bitstream Vera Sans Mono, Courier New, monospace"}
+	for _, option := range options {
+		option(f)
+	}
+	return f
+}
+
+// Formatter that generates SVG.
+type Formatter struct {
+	fontFamily   string
+	embeddedFont string
+	fontFormat   FontFormat
+}
+
+func (f *Formatter) Format(w io.Writer, style *chroma.Style, iterator chroma.Iterator) (err error) {
+	f.writeSVG(w, style, iterator.Tokens())
+	return err
+}
+
+var svgEscaper = strings.NewReplacer(
+	`&`, "&",
+	`<`, "&lt;",
+	`>`, "&gt;",
+	`"`, "&quot;",
+	` `, "&#160;",
+	`	`, "&#160;&#160;&#160;&#160;",
+)
+
+// EscapeString escapes special characters.
+func escapeString(s string) string {
+	return svgEscaper.Replace(s)
+}
+
+func (f *Formatter) writeSVG(w io.Writer, style *chroma.Style, tokens []chroma.Token) { // nolint: gocyclo
+	svgStyles := f.styleToSVG(style)
+	lines := chroma.SplitTokensIntoLines(tokens)
+
+	fmt.Fprint(w, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+	fmt.Fprint(w, "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n")
+	fmt.Fprintf(w, "<svg width=\"%dpx\" height=\"%dpx\" xmlns=\"http://www.w3.org/2000/svg\">\n", 8*maxLineWidth(lines), 10+int(16.8*float64(len(lines)+1)))
+
+	if f.embeddedFont != "" {
+		f.writeFontStyle(w)
+	}
+
+	fmt.Fprintf(w, "<rect width=\"100%%\" height=\"100%%\" fill=\"%s\"/>\n", style.Get(chroma.Background).Background.String())
+	fmt.Fprintf(w, "<g font-family=\"%s\" font-size=\"14px\" fill=\"%s\">\n", f.fontFamily, style.Get(chroma.Text).Colour.String())
+
+	f.writeTokenBackgrounds(w, lines, style)
+
+	for index, tokens := range lines {
+		fmt.Fprintf(w, "<text x=\"0\" y=\"%fem\" xml:space=\"preserve\">", 1.2*float64(index+1))
+
+		for _, token := range tokens {
+			text := escapeString(token.String())
+			attr := f.styleAttr(svgStyles, token.Type)
+			if attr != "" {
+				text = fmt.Sprintf("<tspan %s>%s</tspan>", attr, text)
+			}
+			fmt.Fprint(w, text)
+		}
+		fmt.Fprint(w, "</text>")
+	}
+
+	fmt.Fprint(w, "\n</g>\n")
+	fmt.Fprint(w, "</svg>\n")
+}
+
+func maxLineWidth(lines [][]chroma.Token) int {
+	maxWidth := 0
+	for _, tokens := range lines {
+		length := 0
+		for _, token := range tokens {
+			length += len(strings.Replace(token.String(), `	`, "    ", -1))
+		}
+		if length > maxWidth {
+			maxWidth = length
+		}
+	}
+	return maxWidth
+}
+
+// There is no background attribute for text in SVG so simply calculate the position and text
+// of tokens with a background color that differs from the default and add a rectangle for each before
+// adding the token.
+func (f *Formatter) writeTokenBackgrounds(w io.Writer, lines [][]chroma.Token, style *chroma.Style) {
+	for index, tokens := range lines {
+		lineLength := 0
+		for _, token := range tokens {
+			length := len(strings.Replace(token.String(), `	`, "    ", -1))
+			tokenBackground := style.Get(token.Type).Background
+			if tokenBackground.IsSet() && tokenBackground != style.Get(chroma.Background).Background {
+				fmt.Fprintf(w, "<rect id=\"%s\" x=\"%dch\" y=\"%fem\" width=\"%dch\" height=\"1.2em\" fill=\"%s\" />\n", escapeString(token.String()), lineLength, 1.2*float64(index)+0.25, length, style.Get(token.Type).Background.String())
+			}
+			lineLength += length
+		}
+	}
+}
+
+type FontFormat int
+
+// https://transfonter.org/formats
+const (
+	WOFF FontFormat = iota
+	WOFF2
+	TRUETYPE
+)
+
+var fontFormats = [...]string{
+	"woff",
+	"woff2",
+	"truetype",
+}
+
+func (f *Formatter) writeFontStyle(w io.Writer) {
+	fmt.Fprintf(w, `<style>
+@font-face {
+	font-family: '%s';
+	src: url(data:application/x-font-%s;charset=utf-8;base64,%s) format('%s');'
+	font-weight: normal;
+	font-style: normal;
+}
+</style>`, f.fontFamily, fontFormats[f.fontFormat], f.embeddedFont, fontFormats[f.fontFormat])
+}
+
+func (f *Formatter) styleAttr(styles map[chroma.TokenType]string, tt chroma.TokenType) string {
+	if _, ok := styles[tt]; !ok {
+		tt = tt.SubCategory()
+		if _, ok := styles[tt]; !ok {
+			tt = tt.Category()
+			if _, ok := styles[tt]; !ok {
+				return ""
+			}
+		}
+	}
+	return styles[tt]
+}
+
+func (f *Formatter) styleToSVG(style *chroma.Style) map[chroma.TokenType]string {
+	converted := map[chroma.TokenType]string{}
+	bg := style.Get(chroma.Background)
+	// Convert the style.
+	for t := range chroma.StandardTypes {
+		entry := style.Get(t)
+		if t != chroma.Background {
+			entry = entry.Sub(bg)
+		}
+		if entry.IsZero() {
+			continue
+		}
+		converted[t] = StyleEntryToSVG(entry)
+	}
+	return converted
+}
+
+// StyleEntryToSVG converts a chroma.StyleEntry to SVG attributes.
+func StyleEntryToSVG(e chroma.StyleEntry) string {
+	var styles []string
+
+	if e.Colour.IsSet() {
+		styles = append(styles, "fill=\""+e.Colour.String()+"\"")
+	}
+	if e.Bold == chroma.Yes {
+		styles = append(styles, "font-weight=\"bold\"")
+	}
+	if e.Italic == chroma.Yes {
+		styles = append(styles, "font-style=\"italic\"")
+	}
+	if e.Underline == chroma.Yes {
+		styles = append(styles, "text-decoration=\"underline\"")
+	}
+	return strings.Join(styles, " ")
+}

vendor/github.com/alecthomas/chroma/formatters/tty_indexed.go

@@ -200,6 +200,7 @@ func findClosest(table *ttyTable, seeking chroma.Colour) chroma.Colour {
 }
 
 func styleToEscapeSequence(table *ttyTable, style *chroma.Style) map[chroma.TokenType]string {
+	style = clearBackground(style)
 	out := map[chroma.TokenType]string{}
 	for _, ttype := range style.Types() {
 		entry := style.Get(ttype)
@@ -208,16 +209,22 @@ func styleToEscapeSequence(table *ttyTable, style *chroma.Style) map[chroma.Toke
 	return out
 }
 
+// Clear the background colour.
+func clearBackground(style *chroma.Style) *chroma.Style {
+	builder := style.Builder()
+	bg := builder.Get(chroma.Background)
+	bg.Background = 0
+	bg.NoInherit = true
+	builder.AddEntry(chroma.Background, bg)
+	style, _ = builder.Build()
+	return style
+}
+
 type indexedTTYFormatter struct {
 	table *ttyTable
 }
 
 func (c *indexedTTYFormatter) Format(w io.Writer, style *chroma.Style, it chroma.Iterator) (err error) {
-	defer func() {
-		if perr := recover(); perr != nil {
-			err = perr.(error)
-		}
-	}()
 	theme := styleToEscapeSequence(c.table, style)
 	for token := it(); token != chroma.EOF; token = it() {
 		// TODO: Cache token lookups?

vendor/github.com/alecthomas/chroma/formatters/tty_truecolour.go

@@ -11,6 +11,7 @@ import (
 var TTY16m = Register("terminal16m", chroma.FormatterFunc(trueColourFormatter))
 
 func trueColourFormatter(w io.Writer, style *chroma.Style, it chroma.Iterator) error {
+	style = clearBackground(style)
 	for token := it(); token != chroma.EOF; token = it() {
 		entry := style.Get(token.Type)
 		if !entry.IsZero() {

vendor/github.com/alecthomas/chroma/go.mod

@@ -15,8 +15,10 @@ require (
 	github.com/mattn/go-colorable v0.0.9
 	github.com/mattn/go-isatty v0.0.4
 	github.com/sergi/go-diff v1.0.0 // indirect
-	github.com/stretchr/testify v1.3.0
+	github.com/stretchr/testify v1.3.0 // indirect
 	golang.org/x/sys v0.0.0-20181128092732-4ed8d59d0b35 // indirect
 )
 
 replace github.com/GeertJohan/go.rice => github.com/alecthomas/go.rice v1.0.1-0.20190719113735-961b99d742e7
+
+go 1.13

vendor/github.com/alecthomas/chroma/lexers/README.md

@@ -10,10 +10,28 @@ Run the tests as normal:
 go test ./lexers
 ```
 
-## Updating the existing tests
+## Update existing tests
+When you add a new test data file (`*.actual`), you need to regenerate all tests. That's how Chroma creates the `*.expected` test file based on the corresponding lexer.
 
-You can regenerate all the test outputs
+To regenerate all tests, type in your terminal:
 
 ```go
 RECORD=true go test ./lexers
 ```
+
+This first sets the `RECORD` environment variable to `true`. Then it runs `go test` on the `./lexers` directory of the Chroma project.
+
+(That environment variable tells Chroma it needs to output test data. After running `go test ./lexers` you can remove or reset that variable.)
+
+### Windows users
+Windows users will find that the `RECORD=true go test ./lexers` command fails in both the standard command prompt terminal and in PowerShell.
+
+Instead we have to perform both steps separately:
+
+- Set the `RECORD` environment variable to `true`.
+	+ In the regular command prompt window, the `set` command sets an environment variable for the current session: `set RECORD=true`. See [this page](https://superuser.com/questions/212150/how-to-set-env-variable-in-windows-cmd-line) for more.
+	+ In PowerShell, you can use the `$env:RECORD = 'true'` command for that. See [this article](https://mcpmag.com/articles/2019/03/28/environment-variables-in-powershell.aspx) for more.
+	+ You can also make a persistent environment variable by hand in the Windows computer settings. See [this article](https://www.computerhope.com/issues/ch000549.htm) for how.
+- When the environment variable is set, run `go tests ./lexers`.
+
+Chroma will now regenerate the test files and print its results to the console window.

vendor/github.com/alecthomas/chroma/lexers/a/applescript.go

@@ -31,7 +31,7 @@ var Applescript = internal.Register(MustNewLexer(
 			{`\b(as )(alias |application |boolean |class |constant |date |file |integer |list |number |POSIX file |real |record |reference |RGB color |script |text |unit types|(?:Unicode )?text|string)\b`, ByGroups(Keyword, NameClass), nil},
 			{`\b(AppleScript|current application|false|linefeed|missing value|pi|quote|result|return|space|tab|text item delimiters|true|version)\b`, NameConstant, nil},
 			{`\b(ASCII (character|number)|activate|beep|choose URL|choose application|choose color|choose file( name)?|choose folder|choose from list|choose remote application|clipboard info|close( access)?|copy|count|current date|delay|delete|display (alert|dialog)|do shell script|duplicate|exists|get eof|get volume settings|info for|launch|list (disks|folder)|load script|log|make|mount volume|new|offset|open( (for access|location))?|path to|print|quit|random number|read|round|run( script)?|say|scripting components|set (eof|the clipboard to|volume)|store script|summarize|system attribute|system info|the clipboard|time to GMT|write|quoted form)\b`, NameBuiltin, nil},
-			{`\b(considering|else|error|exit|from|if|ignoring|in|repeat|tell|then|times|to|try|until|using terms from|while|whith|with timeout( of)?|with transaction|by|continue|end|its?|me|my|return|of|as)\b`, Keyword, nil},
+			{`\b(considering|else|error|exit|from|if|ignoring|in|repeat|tell|then|times|to|try|until|using terms from|while|with|with timeout( of)?|with transaction|by|continue|end|its?|me|my|return|of|as)\b`, Keyword, nil},
 			{`\b(global|local|prop(erty)?|set|get)\b`, Keyword, nil},
 			{`\b(but|put|returning|the)\b`, NameBuiltin, nil},
 			{`\b(attachment|attribute run|character|day|month|paragraph|word|year)s?\b`, NameBuiltin, nil},

vendor/github.com/alecthomas/chroma/lexers/b/ballerina.go

@@ -25,7 +25,7 @@ var Ballerina = internal.Register(MustNewLexer(
 			{`(annotation|bind|but|endpoint|error|function|object|private|public|returns|service|type|var|with|worker)\b`, KeywordDeclaration, nil},
 			{`(boolean|byte|decimal|float|int|json|map|nil|record|string|table|xml)\b`, KeywordType, nil},
 			{`(true|false|null)\b`, KeywordConstant, nil},
-			{`import(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")},
+			{`(import)(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")},
 			{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
 			{`'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'`, LiteralStringChar, nil},
 			{`(\.)((?:[^\W\d]|\$)[\w$]*)`, ByGroups(Operator, NameAttribute), nil},

vendor/github.com/alecthomas/chroma/lexers/b/bibtex.go

@@ -0,0 +1,76 @@
+package b
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// Bibtex lexer.
+var Bibtex = internal.Register(MustNewLexer(
+	&Config{
+		Name:            "BibTeX",
+		Aliases:         []string{"bib", "bibtex"},
+		Filenames:       []string{"*.bib"},
+		MimeTypes:       []string{"text/x-bibtex"},
+		NotMultiline:    true,
+		CaseInsensitive: true,
+	},
+	Rules{
+		"root": {
+			Include("whitespace"),
+			{`@comment`, Comment, nil},
+			{`@preamble`, NameClass, Push("closing-brace", "value", "opening-brace")},
+			{`@string`, NameClass, Push("closing-brace", "field", "opening-brace")},
+			{"@[a-z_@!$&*+\\-./:;<>?\\[\\\\\\]^`|~][\\w@!$&*+\\-./:;<>?\\[\\\\\\]^`|~]*", NameClass, Push("closing-brace", "command-body", "opening-brace")},
+			{`.+`, Comment, nil},
+		},
+		"opening-brace": {
+			Include("whitespace"),
+			{`[{(]`, Punctuation, Pop(1)},
+		},
+		"closing-brace": {
+			Include("whitespace"),
+			{`[})]`, Punctuation, Pop(1)},
+		},
+		"command-body": {
+			Include("whitespace"),
+			{`[^\s\,\}]+`, NameLabel, Push("#pop", "fields")},
+		},
+		"fields": {
+			Include("whitespace"),
+			{`,`, Punctuation, Push("field")},
+			Default(Pop(1)),
+		},
+		"field": {
+			Include("whitespace"),
+			{"[a-z_@!$&*+\\-./:;<>?\\[\\\\\\]^`|~][\\w@!$&*+\\-./:;<>?\\[\\\\\\]^`|~]*", NameAttribute, Push("value", "=")},
+			Default(Pop(1)),
+		},
+		"=": {
+			Include("whitespace"),
+			{`=`, Punctuation, Pop(1)},
+		},
+		"value": {
+			Include("whitespace"),
+			{"[a-z_@!$&*+\\-./:;<>?\\[\\\\\\]^`|~][\\w@!$&*+\\-./:;<>?\\[\\\\\\]^`|~]*", NameVariable, nil},
+			{`"`, LiteralString, Push("quoted-string")},
+			{`\{`, LiteralString, Push("braced-string")},
+			{`[\d]+`, LiteralNumber, nil},
+			{`#`, Punctuation, nil},
+			Default(Pop(1)),
+		},
+		"quoted-string": {
+			{`\{`, LiteralString, Push("braced-string")},
+			{`"`, LiteralString, Pop(1)},
+			{`[^\{\"]+`, LiteralString, nil},
+		},
+		"braced-string": {
+			{`\{`, LiteralString, Push()},
+			{`\}`, LiteralString, Pop(1)},
+			{`[^\{\}]+`, LiteralString, nil},
+		},
+		"whitespace": {
+			{`\s+`, Text, nil},
+		},
+	},
+))

vendor/github.com/alecthomas/chroma/lexers/c/cpp.go

@@ -24,7 +24,8 @@ var CPP = internal.Register(MustNewLexer(
 			{`(u8|u|U)(")`, ByGroups(LiteralStringAffix, LiteralString), Push("string")},
 			{`(L?)(")`, ByGroups(LiteralStringAffix, LiteralString), Push("string")},
 			{`(L?)(')(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])(')`, ByGroups(LiteralStringAffix, LiteralStringChar, LiteralStringChar, LiteralStringChar), nil},
-			{`(\.([0-9](?:'?[0-9]+)*)([eE][+-]?([0-9]('?[0-9]+)*))?|([0-9]('?[0-9]+)*)(([eE][+-]?([0-9]('?[0-9]+)*))|\.([0-9]('?[0-9]+)*)?([eE][+-]?([0-9]('?[0-9]+)*))?)|0[xX](\.([0-9A-Fa-f]('?[0-9A-Fa-f]+)*)([pP][-+]?([0-9]('?[0-9]+)*))?|([0-9A-Fa-f]('?[0-9A-Fa-f]+)*)(([pP][-+]?([0-9]('?[0-9]+)*))|\.([0-9A-Fa-f]('?[0-9A-Fa-f]+)*)?([pP][-+]?([0-9]('?[0-9]+)*))?)))[fFLlUu]*`, LiteralNumberFloat, nil},
+			{`(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*`, LiteralNumberFloat, nil},
+			{`(\d+\.\d*|\.\d+|\d+[fF])[fF]?`, LiteralNumberFloat, nil},
 			{`0[xX]([0-9A-Fa-f]('?[0-9A-Fa-f]+)*)[LlUu]*`, LiteralNumberHex, nil},
 			{`0('?[0-7]+)+[LlUu]*`, LiteralNumberOct, nil},
 			{`0[Bb][01]('?[01]+)*[LlUu]*`, LiteralNumberBin, nil},

vendor/github.com/alecthomas/chroma/lexers/d/docker.go

@@ -22,7 +22,7 @@ var Docker = internal.Register(MustNewLexer(
 			{`(ONBUILD)((?:\s*\\?\s*))`, ByGroups(Keyword, Using(b.Bash)), nil},
 			{`(HEALTHCHECK)(((?:\s*\\?\s*)--\w+=\w+(?:\s*\\?\s*))*)`, ByGroups(Keyword, Using(b.Bash)), nil},
 			{`(VOLUME|ENTRYPOINT|CMD|SHELL)((?:\s*\\?\s*))(\[.*?\])`, ByGroups(Keyword, Using(b.Bash), Using(j.JSON)), nil},
-			{`(LABEL|ENV|ARG)(((?:\s*\\?\s*)\w+=\w+(?:\s*\\?\s*))*)`, ByGroups(Keyword, Using(b.Bash)), nil},
+			{`(LABEL|ENV|ARG)((?:(?:\s*\\?\s*)\w+=\w+(?:\s*\\?\s*))*)`, ByGroups(Keyword, Using(b.Bash)), nil},
 			{`((?:FROM|MAINTAINER|EXPOSE|WORKDIR|USER|STOPSIGNAL)|VOLUME)\b(.*)`, ByGroups(Keyword, LiteralString), nil},
 			{`((?:RUN|CMD|ENTRYPOINT|ENV|ARG|LABEL|ADD|COPY))`, Keyword, nil},
 			{`(.*\\\n)*.+`, Using(b.Bash), nil},

vendor/github.com/alecthomas/chroma/lexers/h/http.go

@@ -38,7 +38,6 @@ func httpContentBlock(groups []string, lexer Lexer) Iterator {
 		{Generic, groups[0]},
 	}
 	return Literator(tokens...)
-
 }
 
 func httpHeaderBlock(groups []string, lexer Lexer) Iterator {
@@ -66,7 +65,7 @@ func httpBodyContentTypeLexer(lexer Lexer) Lexer { return &httpBodyContentTyper{
 
 type httpBodyContentTyper struct{ Lexer }
 
-func (d *httpBodyContentTyper) Tokenise(options *TokeniseOptions, text string) (Iterator, error) {
+func (d *httpBodyContentTyper) Tokenise(options *TokeniseOptions, text string) (Iterator, error) { // nolint: gocognit
 	var contentType string
 	var isContentType bool
 	var subIterator Iterator
@@ -123,9 +122,7 @@ func (d *httpBodyContentTyper) Tokenise(options *TokeniseOptions, text string) (
 					return EOF
 				}
 			}
-
 		}
 		return token
-
 	}, nil
 }

vendor/github.com/alecthomas/chroma/lexers/internal/api.go

@@ -1,3 +1,4 @@
+// Package internal contains common API functions and structures shared between lexer packages.
 package internal
 
 import (

vendor/github.com/alecthomas/chroma/lexers/j/j.go

@@ -0,0 +1,73 @@
+package j
+
+import (
+	. "github.com/alecthomas/chroma" // nolint
+	"github.com/alecthomas/chroma/lexers/internal"
+)
+
+// J lexer.
+var J = internal.Register(MustNewLexer(
+	&Config{
+		Name:      "J",
+		Aliases:   []string{"j"},
+		Filenames: []string{"*.ijs"},
+		MimeTypes: []string{"text/x-j"},
+	},
+	Rules{
+		"root": {
+			{`#!.*$`, CommentPreproc, nil},
+			{`NB\..*`, CommentSingle, nil},
+			{`\n+\s*Note`, CommentMultiline, Push("comment")},
+			{`\s*Note.*`, CommentSingle, nil},
+			{`\s+`, Text, nil},
+			{`'`, LiteralString, Push("singlequote")},
+			{`0\s+:\s*0|noun\s+define\s*$`, NameEntity, Push("nounDefinition")},
+			{`(([1-4]|13)\s+:\s*0|(adverb|conjunction|dyad|monad|verb)\s+define)\b`, NameFunction, Push("explicitDefinition")},
+			{Words(``, `\b[a-zA-Z]\w*\.`, `for_`, `goto_`, `label_`), NameLabel, nil},
+			{Words(``, `\.`, `assert`, `break`, `case`, `catch`, `catchd`, `catcht`, `continue`, `do`, `else`, `elseif`, `end`, `fcase`, `for`, `if`, `return`, `select`, `throw`, `try`, `while`, `whilst`), NameLabel, nil},
+			{`\b[a-zA-Z]\w*`, NameVariable, nil},
+			{Words(``, ``, `ARGV`, `CR`, `CRLF`, `DEL`, `Debug`, `EAV`, `EMPTY`, `FF`, `JVERSION`, `LF`, `LF2`, `Note`, `TAB`, `alpha17`, `alpha27`, `apply`, `bind`, `boxopen`, `boxxopen`, `bx`, `clear`, `cutLF`, `cutopen`, `datatype`, `def`, `dfh`, `drop`, `each`, `echo`, `empty`, `erase`, `every`, `evtloop`, `exit`, `expand`, `fetch`, `file2url`, `fixdotdot`, `fliprgb`, `getargs`, `getenv`, `hfd`, `inv`, `inverse`, `iospath`, `isatty`, `isutf8`, `items`, `leaf`, `list`, `nameclass`, `namelist`, `names`, `nc`, `nl`, `on`, `pick`, `rows`, `script`, `scriptd`, `sign`, `sminfo`, `smoutput`, `sort`, `split`, `stderr`, `stdin`, `stdout`, `table`, `take`, `timespacex`, `timex`, `tmoutput`, `toCRLF`, `toHOST`, `toJ`, `tolower`, `toupper`, `type`, `ucp`, `ucpcount`, `usleep`, `utf8`, `uucp`), NameFunction, nil},
+			{`=[.:]`, Operator, nil},
+			{"[-=+*#$%@!~`^&\";:.,<>{}\\[\\]\\\\|/]", Operator, nil},
+			{`[abCdDeEfHiIjLMoprtT]\.`, KeywordReserved, nil},
+			{`[aDiLpqsStux]\:`, KeywordReserved, nil},
+			{`(_[0-9])\:`, KeywordConstant, nil},
+			{`\(`, Punctuation, Push("parentheses")},
+			Include("numbers"),
+		},
+		"comment": {
+			{`[^)]`, CommentMultiline, nil},
+			{`^\)`, CommentMultiline, Pop(1)},
+			{`[)]`, CommentMultiline, nil},
+		},
+		"explicitDefinition": {
+			{`\b[nmuvxy]\b`, NameDecorator, nil},
+			Include("root"),
+			{`[^)]`, Name, nil},
+			{`^\)`, NameLabel, Pop(1)},
+			{`[)]`, Name, nil},
+		},
+		"numbers": {
+			{`\b_{1,2}\b`, LiteralNumber, nil},
+			{`_?\d+(\.\d+)?(\s*[ejr]\s*)_?\d+(\.?=\d+)?`, LiteralNumber, nil},
+			{`_?\d+\.(?=\d+)`, LiteralNumberFloat, nil},
+			{`_?\d+x`, LiteralNumberIntegerLong, nil},
+			{`_?\d+`, LiteralNumberInteger, nil},
+		},
+		"nounDefinition": {
+			{`[^)]`, LiteralString, nil},
+			{`^\)`, NameLabel, Pop(1)},
+			{`[)]`, LiteralString, nil},
+		},
+		"parentheses": {
+			{`\)`, Punctuation, Pop(1)},
+			Include("explicitDefinition"),
+			Include("root"),
+		},
+		"singlequote": {
+			{`[^']`, LiteralString, nil},
+			{`''`, LiteralString, nil},
+			{`'`, LiteralString, Pop(1)},
+		},
+	},
+))

vendor/github.com/alecthomas/chroma/lexers/j/java.go

@@ -20,7 +20,7 @@ var Java = internal.Register(MustNewLexer(
 			{`//.*?\n`, CommentSingle, nil},
 			{`/\*.*?\*/`, CommentMultiline, nil},
 			{`(assert|break|case|catch|continue|default|do|else|finally|for|if|goto|instanceof|new|return|switch|this|throw|try|while)\b`, Keyword, nil},
-			{`((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\s+)+?)((?:[^\W\d]|\$)[\w$]*)(\s*)`, ByGroups(UsingSelf("root"), NameFunction, Text, Operator), nil},
+			{`((?:(?:[^\W\d]|\$)[\w.\[\]$<>]*\s+)+?)((?:[^\W\d]|\$)[\w$]*)(\s*)(\()`, ByGroups(UsingSelf("root"), NameFunction, Text, Operator), nil},
 			{`@[^\W\d][\w.]*`, NameDecorator, nil},
 			{`(abstract|const|enum|extends|final|implements|native|private|protected|public|static|strictfp|super|synchronized|throws|transient|volatile)\b`, KeywordDeclaration, nil},
 			{`(boolean|byte|char|double|float|int|long|short|void)\b`, KeywordType, nil},
@@ -30,7 +30,7 @@ var Java = internal.Register(MustNewLexer(
 			{`(import(?:\s+static)?)(\s+)`, ByGroups(KeywordNamespace, Text), Push("import")},
 			{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
 			{`'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'`, LiteralStringChar, nil},
-			{`(\.)((?:[^\W\d]|\$)[\w$]*)`, ByGroups(Punctuation, NameAttribute), nil},
+			{`(\.)((?:[^\W\d]|\$)[\w$]*)`, ByGroups(Operator, NameAttribute), nil},
 			{`^\s*([^\W\d]|\$)[\w$]*:`, NameLabel, nil},
 			{`([^\W\d]|\$)[\w$]*`, Name, nil},
 			{`([0-9][0-9_]*\.([0-9][0-9_]*)?|\.[0-9][0-9_]*)([eE][+\-]?[0-9][0-9_]*)?[fFdD]?|[0-9][eE][+\-]?[0-9][0-9_]*[fFdD]?|[0-9]([eE][+\-]?[0-9][0-9_]*)?[fFdD]|0[xX]([0-9a-fA-F][0-9a-fA-F_]*\.?|([0-9a-fA-F][0-9a-fA-F_]*)?\.[0-9a-fA-F][0-9a-fA-F_]*)[pP][+\-]?[0-9][0-9_]*[fFdD]?`, LiteralNumberFloat, nil},
@@ -38,8 +38,7 @@ var Java = internal.Register(MustNewLexer(
 			{`0[bB][01][01_]*[lL]?`, LiteralNumberBin, nil},
 			{`0[0-7_]+[lL]?`, LiteralNumberOct, nil},
 			{`0|[1-9][0-9_]*[lL]?`, LiteralNumberInteger, nil},
-			{`[~^*!%&<>|+=:/?-]`, Operator, nil},
+			{`[~^*!%&\[\](){}<>|+=:;,./?-]`, Operator, nil},
-			{`[\[\](){};,.]`, Punctuation, nil},
 			{`\n`, Text, nil},
 		},
 		"class": {

vendor/github.com/alecthomas/chroma/lexers/n/nim.go

@@ -16,6 +16,7 @@ var Nim = internal.Register(MustNewLexer(
 	},
 	Rules{
 		"root": {
+			{`#\[[\s\S]*?\]#`, CommentMultiline, nil},
 			{`##.*$`, LiteralStringDoc, nil},
 			{`#.*$`, Comment, nil},
 			{`[*=><+\-/@$~&%!?|\\\[\]]`, Operator, nil},

vendor/github.com/alecthomas/chroma/regexp.go

@@ -35,9 +35,14 @@ func ByGroups(emitters ...Emitter) Emitter {
 	return EmitterFunc(func(groups []string, lexer Lexer) Iterator {
 		iterators := make([]Iterator, 0, len(groups)-1)
 		// NOTE: If this panics, there is a mismatch with groups
+		if len(emitters) != len(groups)-1 {
+			iterators = append(iterators, Error.Emit(groups, lexer))
+			// panic(errors.Errorf("number of groups %q does not match number of emitters %v", groups, emitters))
+		} else {
 			for i, group := range groups[1:] {
 				iterators = append(iterators, emitters[i].Emit([]string{group}, lexer))
 			}
+		}
 		return Concaterator(iterators...)
 	})
 }
@@ -255,7 +260,7 @@ func (l *LexerState) Get(key interface{}) interface{} {
 }
 
 // Iterator returns the next Token from the lexer.
-func (l *LexerState) Iterator() Token {
+func (l *LexerState) Iterator() Token { // nolint: gocognit
 	for l.Pos < len(l.Text) && len(l.Stack) > 0 {
 		// Exhaust the iterator stack, if any.
 		for len(l.iteratorStack) > 0 {

vendor/github.com/alecthomas/chroma/remap.go

@@ -66,7 +66,6 @@ func TypeRemappingLexer(lexer Lexer, mapping TypeMapping) Lexer {
 				km[k] = rt.To
 			}
 		}
-
 	}
 	return RemappingLexer(lexer, func(t Token) []Token {
 		if k, ok := lut[t.Type]; ok {

vendor/github.com/tj/front/Readme.md

@@ -1,16 +0,0 @@
-# Front
-
-Frontmatter unmarshaller, couldn't find one without a weird API.
-
-## Badges
-
-[![GoDoc](https://godoc.org/github.com/tj/front?status.svg)](https://godoc.org/github.com/tj/front)
-![](https://img.shields.io/badge/license-MIT-blue.svg)
-![](https://img.shields.io/badge/status-stable-green.svg)
-[![](http://apex.sh/images/badge.svg)](https://apex.sh/ping/)
-
----
-
-> [tjholowaychuk.com](http://tjholowaychuk.com)  · 
-> GitHub [@tj](https://github.com/tj)  · 
-> Twitter [@tjholowaychuk](https://twitter.com/tjholowaychuk)

vendor/github.com/tj/front/front.go

@@ -1,24 +0,0 @@
-// Package front provides YAML frontmatter unmarshalling.
-package front
-
-import (
-	"bytes"
-
-	"gopkg.in/yaml.v1"
-)
-
-// Delimiter.
-var delim = []byte("---")
-
-// Unmarshal parses YAML frontmatter and returns the content. When no
-// frontmatter delimiters are present the original content is returned.
-func Unmarshal(b []byte, v interface{}) (content []byte, err error) {
-	if !bytes.HasPrefix(b, delim) {
-		return b, nil
-	}
-
-	parts := bytes.SplitN(b, delim, 3)
-	content = parts[2]
-	err = yaml.Unmarshal(parts[1], v)
-	return
-}

vendor/gopkg.in/yaml.v2/.travis.yml

@@ -1,12 +1,16 @@
 language: go
 
 go:
-    - 1.4
+    - "1.4.x"
-    - 1.5
+    - "1.5.x"
-    - 1.6
+    - "1.6.x"
-    - 1.7
+    - "1.7.x"
-    - 1.8
+    - "1.8.x"
-    - 1.9
+    - "1.9.x"
-    - tip
+    - "1.10.x"
+    - "1.11.x"
+    - "1.12.x"
+    - "1.13.x"
+    - "tip"
 
 go_import_path: gopkg.in/yaml.v2

vendor/gopkg.in/yaml.v2/decode.go

@@ -319,10 +319,14 @@ func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unm
 }
 
 const (
-	// 400,000 decode operations is ~500kb of dense object declarations, or ~5kb of dense object declarations with 10000% alias expansion
+	// 400,000 decode operations is ~500kb of dense object declarations, or
+	// ~5kb of dense object declarations with 10000% alias expansion
 	alias_ratio_range_low = 400000
-	// 4,000,000 decode operations is ~5MB of dense object declarations, or ~4.5MB of dense object declarations with 10% alias expansion
+
+	// 4,000,000 decode operations is ~5MB of dense object declarations, or
+	// ~4.5MB of dense object declarations with 10% alias expansion
 	alias_ratio_range_high = 4000000
+
 	// alias_ratio_range is the range over which we scale allowed alias ratios
 	alias_ratio_range = float64(alias_ratio_range_high - alias_ratio_range_low)
 )
@@ -784,8 +788,7 @@ func (d *decoder) merge(n *node, out reflect.Value) {
 	case mappingNode:
 		d.unmarshal(n, out)
 	case aliasNode:
-		an, ok := d.doc.anchors[n.value]
+		if n.alias != nil && n.alias.kind != mappingNode {
-		if ok && an.kind != mappingNode {
 			failWantMap()
 		}
 		d.unmarshal(n, out)
@@ -794,8 +797,7 @@ func (d *decoder) merge(n *node, out reflect.Value) {
 		for i := len(n.children) - 1; i >= 0; i-- {
 			ni := n.children[i]
 			if ni.kind == aliasNode {
-				an, ok := d.doc.anchors[ni.value]
+				if ni.alias != nil && ni.alias.kind != mappingNode {
-				if ok && an.kind != mappingNode {
 					failWantMap()
 				}
 			} else if ni.kind != mappingNode {

vendor/gopkg.in/yaml.v2/scannerc.go

@@ -634,13 +634,14 @@ func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
 			need_more_tokens = true
 		} else {
 			// Check if any potential simple key may occupy the head position.
-			if !yaml_parser_stale_simple_keys(parser) {
+			for i := len(parser.simple_keys) - 1; i >= 0; i-- {
-				return false
-			}
-
-			for i := range parser.simple_keys {
 				simple_key := &parser.simple_keys[i]
-				if simple_key.possible && simple_key.token_number == parser.tokens_parsed {
+				if simple_key.token_number < parser.tokens_parsed {
+					break
+				}
+				if valid, ok := yaml_simple_key_is_valid(parser, simple_key); !ok {
+					return false
+				} else if valid && simple_key.token_number == parser.tokens_parsed {
 					need_more_tokens = true
 					break
 				}
@@ -678,11 +679,6 @@ func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
 		return false
 	}
 
-	// Remove obsolete potential simple keys.
-	if !yaml_parser_stale_simple_keys(parser) {
-		return false
-	}
-
 	// Check the indentation level against the current column.
 	if !yaml_parser_unroll_indent(parser, parser.mark.column) {
 		return false
@@ -837,29 +833,30 @@ func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool {
 		"found character that cannot start any token")
 }
 
-// Check the list of potential simple keys and remove the positions that
+func yaml_simple_key_is_valid(parser *yaml_parser_t, simple_key *yaml_simple_key_t) (valid, ok bool) {
-// cannot contain simple keys anymore.
+	if !simple_key.possible {
-func yaml_parser_stale_simple_keys(parser *yaml_parser_t) bool {
+		return false, true
-	// Check for a potential simple key for each flow level.
+	}
-	for i := range parser.simple_keys {
-		simple_key := &parser.simple_keys[i]
 
-		// The specification requires that a simple key
+	// The 1.2 specification says:
 	//
-		//  - is limited to a single line,
+	//     "If the ? indicator is omitted, parsing needs to see past the
-		//  - is shorter than 1024 characters.
+	//     implicit key to recognize it as such. To limit the amount of
-		if simple_key.possible && (simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index) {
+	//     lookahead required, the “:” indicator must appear at most 1024
-
+	//     Unicode characters beyond the start of the key. In addition, the key
+	//     is restricted to a single line."
+	//
+	if simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index {
 		// Check if the potential simple key to be removed is required.
 		if simple_key.required {
-				return yaml_parser_set_scanner_error(parser,
+			return false, yaml_parser_set_scanner_error(parser,
 				"while scanning a simple key", simple_key.mark,
 				"could not find expected ':'")
 		}
 		simple_key.possible = false
+		return false, true
 	}
-	}
+	return true, true
-	return true
 }
 
 // Check if a simple key may start at the current position and add it if
@@ -879,8 +876,8 @@ func yaml_parser_save_simple_key(parser *yaml_parser_t) bool {
 			possible:     true,
 			required:     required,
 			token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
+			mark:         parser.mark,
 		}
-		simple_key.mark = parser.mark
 
 		if !yaml_parser_remove_simple_key(parser) {
 			return false
@@ -912,7 +909,12 @@ const max_flow_level = 10000
 // Increase the flow level and resize the simple key list if needed.
 func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool {
 	// Reset the simple key on the next level.
-	parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{})
+	parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{
+		possible:     false,
+		required:     false,
+		token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
+		mark:         parser.mark,
+	})
 
 	// Increase the flow level.
 	parser.flow_level++
@@ -1286,7 +1288,11 @@ func yaml_parser_fetch_value(parser *yaml_parser_t) bool {
 	simple_key := &parser.simple_keys[len(parser.simple_keys)-1]
 
 	// Have we found a simple key?
-	if simple_key.possible {
+	if valid, ok := yaml_simple_key_is_valid(parser, simple_key); !ok {
+		return false
+
+	} else if valid {
+
 		// Create the KEY token and insert it into the queue.
 		token := yaml_token_t{
 			typ:        yaml_KEY_TOKEN,

vendor/gopkg.in/yaml.v2/yaml.go

@@ -89,7 +89,7 @@ func UnmarshalStrict(in []byte, out interface{}) (err error) {
 	return unmarshal(in, out, true)
 }
 
-// A Decorder reads and decodes YAML values from an input stream.
+// A Decoder reads and decodes YAML values from an input stream.
 type Decoder struct {
 	strict bool
 	parser *parser

vendor/modules.txt

@@ -1,7 +1,8 @@
-# github.com/alecthomas/chroma v0.6.7
+# github.com/alecthomas/chroma v0.6.9
 github.com/alecthomas/chroma
 github.com/alecthomas/chroma/formatters
 github.com/alecthomas/chroma/formatters/html
+github.com/alecthomas/chroma/formatters/svg
 github.com/alecthomas/chroma/lexers
 github.com/alecthomas/chroma/lexers/a
 github.com/alecthomas/chroma/lexers/b
@@ -48,11 +49,9 @@ github.com/mattn/go-isatty
 github.com/mgutz/ansi
 # github.com/mitchellh/go-homedir v1.1.0
 github.com/mitchellh/go-homedir
-# github.com/tj/front v0.0.0-20170212063142-739be213b0a1
-github.com/tj/front
 # golang.org/x/sys v0.0.0-20191008105621-543471e840be
 golang.org/x/sys/unix
 # gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0
 gopkg.in/yaml.v1
-# gopkg.in/yaml.v2 v2.2.4
+# gopkg.in/yaml.v2 v2.2.7
 gopkg.in/yaml.v2