chore: bump version to 4.0.4

Create release containing typo fixes (#580).

.gitattributes

@@ -1,3 +0,0 @@
-# Force LF line endings for mock/test data files to ensure consistent
-# behavior across platforms (Windows git autocrlf converts to CRLF otherwise)
-mocks/** text eol=lf

.github/dependabot.yml

@@ -1,7 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: gomod
-  directory: "/"
-  schedule:
-    interval: weekly
-  open-pull-requests-limit: 10

.github/workflows/build.yml

@@ -1,38 +0,0 @@
----
-name: CI
-
-on:
-  push:
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version: stable
-      - name: Install revive
-        run: go install github.com/mgechev/revive@latest
-      - name: Lint
-        run: revive -exclude vendor/... ./...
-      - name: Vet
-        run: go vet ./...
-      - name: Check formatting
-        run: test -z "$(gofmt -l . | grep -v vendor/)"
-
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
-        with:
-          go-version: stable
-      - name: Build
-        run: go build -mod vendor ./cmd/cheat
-      - name: Test
-        run: go test ./...

.github/workflows/codeql-analysis.yml

@@ -1,30 +0,0 @@
----
-name: CodeQL
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-  schedule:
-    - cron: '45 23 * * 0'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [go]
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-        with:
-          languages: ${{ matrix.language }}
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3

.github/workflows/homebrew.yml

@@ -0,0 +1,17 @@
+name: homebrew
+
+on:
+  push:
+    tags: '*'
+
+jobs:
+  homebrew:
+    name: Bump Homebrew formula
+    runs-on: ubuntu-latest
+    steps:
+      - uses: mislav/bump-homebrew-formula-action@v1
+        with:
+          # A PR will be sent to github.com/Homebrew/homebrew-core to update this formula:
+          formula-name: cheat
+        env:
+          COMMITTER_TOKEN: ${{ secrets.COMMITTER_TOKEN }}

.gitignore

@@ -1,5 +1,2 @@
 dist
 tags
-.tmp
-*.test
-.claude

.travis.yml

@@ -0,0 +1,15 @@
+language: go
+
+go:
+  - 1.14.x
+
+os:
+  - linux
+  - osx
+
+env:
+  - GO111MODULE=on
+
+install: true
+
+script: make ci

CLAUDE.md

@@ -1,122 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Common Development Commands
-
-### Building
-```bash
-# Build for your architecture
-make build
-
-# Build release binaries for all platforms
-make build-release
-
-# Install cheat to your PATH
-make install
-```
-
-### Testing and Quality Checks
-```bash
-# Run all tests
-make test
-go test ./...
-
-# Run a single test
-go test -run TestFunctionName ./internal/package_name
-
-# Generate test coverage report
-make coverage
-
-# Run linter (revive)
-make lint
-
-# Run go vet
-make vet
-
-# Format code
-make fmt
-
-# Run all checks (vendor, fmt, lint, vet, test)
-make check
-```
-
-### Development Setup
-```bash
-# Install development dependencies (revive linter, scc)
-make setup
-
-# Update and verify vendored dependencies
-make vendor-update
-```
-
-## Architecture Overview
-
-The `cheat` command-line tool is organized into several key packages:
-
-### Command Layer (`cmd/cheat/`)
-- `main.go`: Entry point, argument parsing, command routing
-- `cmd_*.go`: Individual command implementations (view, edit, list, search, etc.)
-- Commands are selected based on docopt parsed arguments
-
-### Core Internal Packages
-
-1. **`internal/config`**: Configuration management
-   - Loads YAML config from platform-specific paths
-   - Manages editor, pager, colorization settings
-   - Validates and expands cheatpath configurations
-
-2. **`internal/cheatpath`**: Cheatsheet path management
-   - Represents collections of cheatsheets on filesystem
-   - Handles read-only vs writable paths
-   - Supports filtering and validation
-
-3. **`internal/sheet`**: Individual cheatsheet handling
-   - Parses YAML frontmatter for tags and syntax
-   - Implements syntax highlighting via Chroma
-   - Provides search functionality within sheets
-
-4. **`internal/sheets`**: Collection operations
-   - Loads sheets from multiple cheatpaths
-   - Consolidates duplicates (local overrides global)
-   - Filters by tags and sorts results
-
-5. **`internal/display`**: Output formatting
-   - Writes to stdout or pager
-   - Handles text formatting and indentation
-
-6. **`internal/installer`**: First-run installer
-   - Prompts user for initial configuration choices
-   - Generates default `conf.yml` and downloads community cheatsheets
-
-7. **`internal/repo`**: Git repository management
-   - Clones community cheatsheet repositories
-   - Updates existing repositories
-
-### Key Design Patterns
-
-- **Filesystem-based storage**: Cheatsheets are plain text files
-- **Override mechanism**: Local sheets override community sheets with same name
-- **Tag system**: Sheets can be categorized with tags in frontmatter
-- **Multiple cheatpaths**: Supports personal, community, and directory-scoped sheets
-- **Directory-scoped discovery**: Walks up from cwd to find the nearest `.cheat` directory (like `.git` discovery)
-
-### Sheet Format
-
-Cheatsheets are plain text files optionally prefixed with YAML frontmatter:
-```
----
-syntax: bash
-tags: [ networking, ssh ]
----
-# SSH tunneling example
-ssh -L 8080:localhost:80 user@remote
-```
-
-### Working with the Codebase
-
-- Always check for `.git` directories and skip them during filesystem walks
-- Use `go-git` for repository operations, not exec'ing git commands
-- Platform-specific paths are handled in `internal/config/paths.go`
-- Color output uses ANSI codes via the Chroma library
-- Test files use the `mocks` package for test data

CONTRIBUTING.md

@@ -1,17 +1,43 @@
-# Contributing
+CONTRIBUTING
+============
+Do you want to contribute to `cheat`? There are a few ways to help:
 
-Thank you for your interest in `cheat`.
+#### Submit a cheatsheet ####
+Do you have a witty bash one-liner to share? [Open a pull-request][pr] against
+the [cheatsheets][] repository. (The `cheat` executable source code lives in
+[cheat/cheat][cheat]. Cheatsheet content lives in
+[cheat/cheatsheets][cheatsheets].)
 
-Pull requests are no longer being accepted, and have been disabled on this
-repository. The maintainer is not currently reviewing or merging external code
-contributions.
+#### Report a bug ####
+Did you find a bug? Report it in the [issue tracker][issues]. (But before you
+do, please look through the open issues to make sure that it hasn't already
+ been reported.)
 
-Bug reports are still welcome. If you've found a bug, please open an issue in
-the [issue tracker][issues]. Before doing so, please search through the
-existing open issues to make sure it hasn't already been reported.
+#### Add a feature ####
+Do you have a feature that you'd like to contribute? Propose it in the [issue
+tracker][issues] to discuss with the maintainer whether it would be considered
+for merging.
 
-Feature requests may be filed, but are unlikely to be implemented. The project
-is now mature and the maintainer considers its feature set to be essentially
-complete.
+`cheat` is mostly mature and feature-complete, but may still have some room for
+new features.
 
+#### Add documentation ####
+Did you encounter features, bugs, edge-cases, use-cases, or environment
+considerations that were undocumented or under-documented? Add them to the
+[wiki][]. (You may also open a pull-request against the `README`, if
+appropriate.)
+
+Do you enjoy technical writing or proofreading? Help keep the documentation
+error-free and well-organized.
+
+#### Spread the word ####
+Are you unable to do the above, but still want to contribute? You can help
+`cheat` simply by telling others about it. Share it with friends and coworkers
+that might benefit from using it.
+
+
+[cheat]: https://github.com/cheat/cheat
+[cheatsheets]: https://github.com/cheat/cheatsheets
 [issues]: https://github.com/cheat/cheat/issues 
+[pr]: https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request-from-a-fork
+[wiki]: https://github.com/cheat/cheat/wiki

Dockerfile

@@ -1,8 +0,0 @@
-# NB: this image isn't used anywhere in the build pipeline. It exists to
-# conveniently facilitate ad-hoc experimentation in a sandboxed environment
-# during development.
-FROM golang:1.26-alpine
-
-RUN apk add git less make
-
-WORKDIR /app

HACKING.md

@@ -1,241 +0,0 @@
-# Hacking Guide
-
-This document provides a comprehensive guide for developing `cheat`, including setup, architecture overview, and code patterns.
-
-## Quick Start
-
-### 1. Install system dependencies
-
-The following are required and must be available on your `PATH`:
-- `git`
-- `go` (>= 1.19 is recommended)
-- `make`
-
-Optional dependencies:
-- `docker`
-- `pandoc` (necessary to generate a `man` page)
-
-### 2. Install utility applications
-Run `make setup` to install `scc` and `revive`, which are used by various `make` targets.
-
-### 3. Development workflow
-
-1. Make changes to the `cheat` source code
-2. Run `make test` to run unit-tests
-3. Fix compiler errors and failing tests as necessary
-4. Run `make build`. A `cheat` executable will be written to the `dist` directory
-5. Use the new executable by running `dist/cheat <command>`
-6. Run `make install` to install `cheat` to your `PATH`
-7. Run `make build-release` to build cross-platform binaries in `dist`
-8. Run `make clean` to clean the `dist` directory when desired
-
-You may run `make help` to see a list of available `make` commands.
-
-### 4. Testing
-
-#### Unit Tests
-Run unit tests with:
-```bash
-make test
-```
-
-#### Integration Tests
-Integration tests that require network access are separated using build tags. Run them with:
-```bash
-make test-integration
-```
-
-To run all tests (unit and integration):
-```bash
-make test-all
-```
-
-#### Test Coverage
-Generate a coverage report with:
-```bash
-make coverage        # HTML report
-make coverage-text   # Terminal output
-```
-
-## Architecture Overview
-
-### Package Structure
-
-The `cheat` application follows a clean architecture with well-separated concerns:
-
-- **`cmd/cheat/`**: Command layer with argument parsing and command routing
-- **`internal/config`**: Configuration management (YAML loading, validation, paths)
-- **`internal/cheatpath`**: Cheatsheet path management (collections, filtering)
-- **`internal/sheet`**: Individual cheatsheet handling (parsing, search, highlighting)  
-- **`internal/sheets`**: Collection operations (loading, consolidation, filtering)
-- **`internal/display`**: Output formatting (pager integration, colorization)
-- **`internal/repo`**: Git repository management for community sheets
-
-### Key Design Patterns
-
-- **Filesystem-based storage**: Cheatsheets are plain text files
-- **Override mechanism**: Local sheets override community sheets with same name
-- **Tag system**: Sheets can be categorized with tags in frontmatter
-- **Multiple cheatpaths**: Supports personal, community, and directory-scoped sheets
-
-## Core Types and Functions
-
-### Config (`internal/config`)
-
-The main configuration structure:
-
-```go
-type Config struct {
-    Colorize   bool           `yaml:"colorize"`
-    Editor     string         `yaml:"editor"`
-    Cheatpaths []cp.Path      `yaml:"cheatpaths"`
-    Style      string         `yaml:"style"`
-    Formatter  string         `yaml:"formatter"`
-    Pager      string         `yaml:"pager"`
-    Path       string
-}
-```
-
-Key functions:
-- `New(confPath, resolve)` - Load config from file
-- `Validate()` - Validate configuration values
-- `Editor()` - Get editor from environment or defaults (package-level function)
-- `Pager()` - Get pager from environment or defaults (package-level function)
-
-### Cheatpath (`internal/cheatpath`)
-
-Represents a directory containing cheatsheets:
-
-```go
-type Path struct {
-    Name     string   // Friendly name (e.g., "personal")
-    Path     string   // Filesystem path
-    Tags     []string // Tags applied to all sheets in this path
-    ReadOnly bool     // Whether sheets can be modified
-}
-```
-
-### Sheet (`internal/sheet`)
-
-Represents an individual cheatsheet:
-
-```go
-type Sheet struct {
-    Title     string   // Sheet name (from filename)
-    CheatPath string   // Name of the cheatpath this sheet belongs to
-    Path      string   // Full filesystem path
-    Text      string   // Content (without frontmatter)
-    Tags      []string // Combined tags (from frontmatter + cheatpath)
-    Syntax    string   // Syntax for highlighting
-    ReadOnly  bool     // Whether sheet can be edited
-}
-```
-
-Key methods:
-- `New(title, cheatpath, path, tags, readOnly)` - Load from file
-- `Search(reg)` - Search content with a compiled regexp
-- `Colorize(conf)` - Apply syntax highlighting (modifies sheet in place)
-- `Tagged(needle)` - Check if sheet has the given tag
-
-## Common Operations
-
-### Loading and Displaying a Sheet
-
-```go
-// Load sheet
-s, err := sheet.New("tar", "personal", "/path/to/tar", []string{"personal"}, false)
-if err != nil {
-    log.Fatal(err)
-}
-
-// Apply syntax highlighting (modifies sheet in place)
-s.Colorize(conf)
-
-// Display with pager
-display.Write(s.Text, conf)
-```
-
-### Working with Sheet Collections
-
-```go
-// Load all sheets from cheatpaths (returns a slice of maps, one per cheatpath)
-allSheets, err := sheets.Load(conf.Cheatpaths)
-if err != nil {
-    log.Fatal(err)
-}
-
-// Consolidate to handle duplicates (later cheatpaths take precedence)
-consolidated := sheets.Consolidate(allSheets)
-
-// Filter by tag (operates on the slice of maps)
-filtered := sheets.Filter(allSheets, []string{"networking"})
-
-// Sort alphabetically (returns a sorted slice)
-sorted := sheets.Sort(consolidated)
-```
-
-### Sheet Format
-
-Cheatsheets are plain text files that may begin with YAML frontmatter:
-
-```yaml
----
-syntax: bash
-tags: [networking, linux, ssh]
----
-# Connect to remote server
-ssh user@hostname
-
-# Copy files over SSH
-scp local_file user@hostname:/remote/path
-```
-
-## Testing
-
-Run tests with:
-```bash
-make test           # Run all tests
-make coverage       # Generate coverage report
-go test ./...       # Go test directly
-```
-
-Test files follow Go conventions:
-- `*_test.go` files in same package
-- Table-driven tests for multiple scenarios
-- Mock data in `mocks` package
-
-## Error Handling
-
-The codebase follows consistent error handling patterns:
-- Functions return explicit errors
-- Errors are wrapped with context using `fmt.Errorf`
-- User-facing errors are written to stderr
-
-Example:
-```go
-sheet, err := sheet.New(path, tags, false)
-if err != nil {
-    return fmt.Errorf("failed to load sheet: %w", err)
-}
-```
-
-## Developing with Docker
-
-It may be useful to test your changes within a pristine environment. An Alpine-based docker container has been provided for that purpose.
-
-Build the docker container:
-```bash
-make docker-setup
-```
-
-Shell into the container:
-```bash
-make docker-sh
-```
-
-The `cheat` source code will be mounted at `/app` within the container.
-
-To destroy the container:
-```bash
-make distclean
-```

INSTALLING.md

@@ -1,76 +0,0 @@
-# Installing
-`cheat` has no runtime dependencies. As such, installing it is generally
-straightforward. There are a few methods available:
-
-## Install manually
-### Unix-like
-On Unix-like systems, you may simply paste the following snippet into your terminal:
-
-```sh
-cd /tmp \
-  && wget https://github.com/cheat/cheat/releases/download/4.7.0/cheat-linux-amd64.gz \
-  && gunzip cheat-linux-amd64.gz \
-  && chmod +x cheat-linux-amd64 \
-  && sudo mv cheat-linux-amd64 /usr/local/bin/cheat
-```
-
-You may need to need to change the version number (`4.7.0`) and the archive
-(`cheat-linux-amd64.gz`) depending on your platform.
-
-See the [releases page][releases] for a list of supported platforms.
-
-### Windows
-On Windows, download the appropriate binary from the [releases page][releases],
-unzip the archive, and place the `cheat.exe` executable on your `PATH`.
-
-## Install via `go install`
-If you have `go` version `>=1.17` available on your `PATH`, you can install
-`cheat` via `go install`:
-
-```sh
-go install github.com/cheat/cheat/cmd/cheat@latest
-```
-
-## Install via package manager
-Several community-maintained packages are also available:
-
-Package manager  | Package(s)
----------------- | -----------
-aur              | [cheat][pkg-aur-cheat], [cheat-bin][pkg-aur-cheat-bin]
-brew             | [cheat][pkg-brew]
-docker           | [docker-cheat][pkg-docker]
-nix              | [nixos.cheat][pkg-nix]
-snap             | [cheat][pkg-snap]
-
-## Configuring
-Three things must be done before you can use `cheat`:
-1. A config file must be generated
-2. [`cheatpaths`][cheatpaths] must be configured
-3. [Community cheatsheets][community] must be downloaded
-
-On first run, `cheat` will run an installer that will do all of the above
-automatically. After the installer is complete, it is strongly advised that you
-view the configuration file that was generated, as you may want to change some
-of its default values (to enable colorization, change the paginator, etc).
-
-### conf.yml
-`cheat` is configured by a YAML file that will be auto-generated on first run.
-
-By default, the config file is assumed to exist on an XDG-compliant
-configuration path like `~/.config/cheat/conf.yml`. If you would like to store
-it elsewhere, you may export a `CHEAT_CONFIG_PATH` environment variable that
-specifies its path:
-
-```sh
-export CHEAT_CONFIG_PATH="~/.dotfiles/cheat/conf.yml"
-```
-
-[cheatpaths]:        README.md#cheatpaths
-[community]:         https://github.com/cheat/cheatsheets/
-[pkg-aur-cheat-bin]: https://aur.archlinux.org/packages/cheat-bin
-[pkg-aur-cheat]:     https://aur.archlinux.org/packages/cheat
-[pkg-brew]:          https://formulae.brew.sh/formula/cheat
-[pkg-docker]:        https://github.com/bannmann/docker-cheat
-[pkg-nix]:           https://search.nixos.org/packages?channel=unstable&show=cheat&from=0&size=50&sort=relevance&type=packages&query=cheat
-[pkg-snap]:          https://snapcraft.io/cheat
-[releases]:          https://github.com/cheat/cheat/releases

Makefile

@@ -3,14 +3,10 @@ makefile := $(realpath $(lastword $(MAKEFILE_LIST)))
 cmd_dir  := ./cmd/cheat
 dist_dir := ./dist
 
-# parallel jobs for build-release (can be overridden)
-JOBS ?= 8
-
 # executables
 CAT    := cat
 COLUMN := column
 CTAGS  := ctags
-DOCKER := docker
 GO     := go
 GREP   := grep
 GZIP   := gzip --best
@@ -24,10 +20,7 @@ SED    := sed
 SORT   := sort
 ZIP    := zip -m
 
-docker_image := cheat-devel:latest
-
 # build flags
-export CGO_ENABLED := 0
 BUILD_FLAGS  := -ldflags="-s -w" -mod vendor -trimpath
 GOBIN        :=
 TMPDIR       := /tmp
@@ -35,103 +28,68 @@ TMPDIR       := /tmp
 # release binaries
 releases :=                        \
 	$(dist_dir)/cheat-darwin-amd64 \
-	$(dist_dir)/cheat-darwin-arm64 \
 	$(dist_dir)/cheat-linux-386    \
 	$(dist_dir)/cheat-linux-amd64  \
 	$(dist_dir)/cheat-linux-arm5   \
 	$(dist_dir)/cheat-linux-arm6   \
-	$(dist_dir)/cheat-linux-arm64  \
 	$(dist_dir)/cheat-linux-arm7   \
-	$(dist_dir)/cheat-netbsd-amd64  \
-	$(dist_dir)/cheat-openbsd-amd64  \
-	$(dist_dir)/cheat-plan9-amd64   \
-	$(dist_dir)/cheat-solaris-amd64  \
 	$(dist_dir)/cheat-windows-amd64.exe
 
 ## build: build an executable for your architecture
 .PHONY: build
-build: | clean $(dist_dir) fmt lint vet vendor man
+build: $(dist_dir) clean vendor generate man
 	$(GO) build $(BUILD_FLAGS) -o $(dist_dir)/cheat $(cmd_dir)
 
 ## build-release: build release executables
-# Runs prepare once, then builds all binaries in parallel
-# Override jobs with: make build-release JOBS=16
 .PHONY: build-release
-build-release: prepare
-	$(MAKE) -j$(JOBS) $(releases)
+build-release: $(releases)
+
+## ci: build a "release" executable for the current architecture (used in ci)
+.PHONY: ci
+ci: | setup prepare build
 
 # cheat-darwin-amd64
-$(dist_dir)/cheat-darwin-amd64:
+$(dist_dir)/cheat-darwin-amd64: prepare
 	GOARCH=amd64 GOOS=darwin \
 	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
-# cheat-darwin-arm64
-$(dist_dir)/cheat-darwin-arm64:
-	GOARCH=arm64 GOOS=darwin \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
-
 # cheat-linux-386
-$(dist_dir)/cheat-linux-386:
+$(dist_dir)/cheat-linux-386: prepare
 	GOARCH=386 GOOS=linux \
 	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-amd64
-$(dist_dir)/cheat-linux-amd64:
+$(dist_dir)/cheat-linux-amd64: prepare
 	GOARCH=amd64 GOOS=linux \
 	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-arm5
-$(dist_dir)/cheat-linux-arm5:
+$(dist_dir)/cheat-linux-arm5: prepare
 	GOARCH=arm GOOS=linux GOARM=5 \
 	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-arm6
-$(dist_dir)/cheat-linux-arm6:
+$(dist_dir)/cheat-linux-arm6: prepare
 	GOARCH=arm GOOS=linux GOARM=6 \
 	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
 # cheat-linux-arm7
-$(dist_dir)/cheat-linux-arm7:
+$(dist_dir)/cheat-linux-arm7: prepare
 	GOARCH=arm GOOS=linux GOARM=7 \
 	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
 
-# cheat-linux-arm64
-$(dist_dir)/cheat-linux-arm64:
-	GOARCH=arm64 GOOS=linux \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
-
-# cheat-netbsd-amd64
-$(dist_dir)/cheat-netbsd-amd64:
-	GOARCH=amd64 GOOS=netbsd \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
-
-# cheat-openbsd-amd64
-$(dist_dir)/cheat-openbsd-amd64:
-	GOARCH=amd64 GOOS=openbsd \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
-
-# cheat-plan9-amd64
-$(dist_dir)/cheat-plan9-amd64:
-	GOARCH=amd64 GOOS=plan9 \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
-
-# cheat-solaris-amd64
-$(dist_dir)/cheat-solaris-amd64:
-	GOARCH=amd64 GOOS=solaris \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(GZIP) $@ && chmod -x $@.gz
-
 # cheat-windows-amd64
-$(dist_dir)/cheat-windows-amd64.exe:
+$(dist_dir)/cheat-windows-amd64.exe: prepare
 	GOARCH=amd64 GOOS=windows \
-	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(ZIP) $@.zip $@ -j
+	$(GO) build $(BUILD_FLAGS) -o $@ $(cmd_dir) && $(ZIP) $@.zip $@
 
 # ./dist
 $(dist_dir):
 	$(MKDIR) $(dist_dir)
 
-# .tmp
-.tmp:
-	$(MKDIR) .tmp
+.PHONY: generate
+generate:
+	$(GO) generate $(cmd_dir)
 
 ## install: build and install cheat on your PATH
 .PHONY: install
@@ -140,21 +98,18 @@ install: build
 
 ## clean: remove compiled executables
 .PHONY: clean
-clean:
+clean: $(dist_dir)
 	$(RM) -f $(dist_dir)/*
-	$(RM) -rf .tmp
 
 ## distclean: remove the tags file
 .PHONY: distclean
 distclean:
 	$(RM) -f tags
-	@$(DOCKER) image rm -f $(docker_image)
 
 ## setup: install revive (linter) and scc (sloc tool)
 .PHONY: setup
 setup:
-	$(GO) install github.com/boyter/scc@latest
-	$(GO) install github.com/mgechev/revive@latest
+	GO111MODULE=off $(GO) get -u github.com/boyter/scc github.com/mgechev/revive
 
 ## sloc: count "semantic lines of code"
 .PHONY: sloc
@@ -177,11 +132,6 @@ man:
 vendor:
 	$(GO) mod vendor && $(GO) mod tidy && $(GO) mod verify
 
-## vendor-update: update vendored dependencies
-.PHONY: vendor-update
-vendor-update:
-	$(GO) get -t -u ./... && $(GO) mod vendor && $(GO) mod tidy && $(GO) mod verify
-
 ## fmt: run go fmt
 .PHONY: fmt
 fmt:
@@ -202,80 +152,18 @@ vet:
 test: 
 	$(GO) test ./...
 
-## test-integration: run integration tests (requires network)
-.PHONY: test-integration
-test-integration:
-	$(GO) test -tags=integration -count=1 ./...
-
-## test-all: run all tests (unit and integration)
-.PHONY: test-all
-test-all: test test-integration
-
-## test-fuzz: run quick fuzz tests for security-critical functions
-.PHONY: test-fuzz
-test-fuzz:
-	@./test/fuzz.sh 15s
-
-## test-fuzz-long: run extended fuzz tests (10 minutes each)
-.PHONY: test-fuzz-long
-test-fuzz-long:
-	@./test/fuzz.sh 10m
-
 ## coverage: generate a test coverage report
 .PHONY: coverage
-coverage: .tmp
-	$(GO) test ./... -coverprofile=.tmp/cheat-coverage.out && \
-	$(GO) tool cover -html=.tmp/cheat-coverage.out -o .tmp/cheat-coverage.html && \
-	echo "Coverage report generated: .tmp/cheat-coverage.html" && \
-	(sensible-browser .tmp/cheat-coverage.html 2>/dev/null || \
-	 xdg-open .tmp/cheat-coverage.html 2>/dev/null || \
-	 open .tmp/cheat-coverage.html 2>/dev/null || \
-	 echo "Please open .tmp/cheat-coverage.html in your browser")
-
-## coverage-text: show test coverage by function in terminal
-.PHONY: coverage-text
-coverage-text: .tmp
-	$(GO) test ./... -coverprofile=.tmp/cheat-coverage.out && \
-	$(GO) tool cover -func=.tmp/cheat-coverage.out | $(SORT) -k3 -n
-
-## benchmark: run performance benchmarks
-.PHONY: benchmark
-benchmark: .tmp
-	$(GO) test -tags=integration -bench=. -benchtime=10s -benchmem ./test/integration | tee .tmp/benchmark-latest.txt && \
-	$(RM) -f integration.test
-
-## benchmark-cpu: run benchmarks with CPU profiling
-.PHONY: benchmark-cpu
-benchmark-cpu: .tmp
-	$(GO) test -tags=integration -bench=. -benchtime=10s -cpuprofile=.tmp/cpu.prof ./test/integration && \
-	$(RM) -f integration.test && \
-	echo "CPU profile saved to .tmp/cpu.prof" && \
-	echo "View with: go tool pprof -http=:8080 .tmp/cpu.prof"
-
-## benchmark-mem: run benchmarks with memory profiling
-.PHONY: benchmark-mem
-benchmark-mem: .tmp
-	$(GO) test -tags=integration -bench=. -benchtime=10s -benchmem -memprofile=.tmp/mem.prof ./test/integration && \
-	$(RM) -f integration.test && \
-	echo "Memory profile saved to .tmp/mem.prof" && \
-	echo "View with: go tool pprof -http=:8080 .tmp/mem.prof"
+coverage:
+	$(GO) test ./... -coverprofile=$(TMPDIR)/cheat-coverage.out && \
+	$(GO) tool cover -html=$(TMPDIR)/cheat-coverage.out
 
 ## check: format, lint, vet, vendor, and run unit-tests
 .PHONY: check
 check: | vendor fmt lint vet test
 
 .PHONY: prepare
-prepare: | clean $(dist_dir) vendor fmt lint vet test
-
-## docker-setup: create a docker image for use during development
-.PHONY: docker-setup
-docker-setup:
-	$(DOCKER) build  -t $(docker_image) -f Dockerfile .
-
-## docker-sh: shell into the docker development container
-.PHONY: docker-sh
-docker-sh:
-	$(DOCKER) run -v $(shell pwd):/app -ti $(docker_image) /bin/ash
+prepare: | $(dist_dir) clean generate vendor fmt lint vet test
 
 ## help: display this help text
 .PHONY: help

README.md

@@ -1,6 +1,7 @@
-![Workflow status](https://github.com/cheat/cheat/actions/workflows/build.yml/badge.svg)
+cheat
+=====
 
-# cheat
+[![Build Status](https://travis-ci.com/cheat/cheat.svg?branch=master)](https://travis-ci.com/cheat/cheat)
 
 `cheat` allows you to create and view interactive cheatsheets on the
 command-line. It was designed to help remind \*nix system administrators of
@@ -11,7 +12,9 @@ remember.
 
 Use `cheat` with [cheatsheets][].
 
-## Example
+
+Example
+-------
 The next time you're forced to disarm a nuclear weapon without consulting
 Google, you may run:
 
@@ -38,10 +41,101 @@ tar -xjvf '/path/to/foo.tgz'
 tar -cjvf '/path/to/foo.tgz' '/path/to/foo/'
 ```
 
-## Installing
-For installation and configuration instructions, see [INSTALLING.md][].
 
-## Usage
+Installing
+----------
+`cheat` has no dependencies. To install it, download the executable from the
+[releases][] page and place it on your `PATH`.
+
+
+Configuring
+-----------
+### conf.yml ###
+`cheat` is configured by a YAML file that will be auto-generated on first run.
+Should you need to create a config file manually, you can do
+so via:
+
+```sh
+mkdir -p ~/.config/cheat && cheat --init > ~/.config/cheat/conf.yml
+```
+
+By default, the config file is assumed to exist on an XDG-compliant
+configuration path like `~/.config/cheat/conf.yml`. If you would like to store
+it elsewhere, you may export a `CHEAT_CONFIG_PATH` environment variable that
+specifies its path:
+
+```sh
+export CHEAT_CONFIG_PATH="~/.dotfiles/cheat/conf.yml"
+```
+
+Cheatsheets
+-----------
+Cheatsheets are plain-text files with no file extension, and are named
+according to the command used to view them:
+
+```sh
+cheat tar     # file is named "tar"
+cheat foo/bar # file is named "bar", in a "foo" subdirectory
+```
+
+Cheatsheet text may optionally be preceeded by a YAML frontmatter header that
+assigns tags and specifies syntax:
+
+```
+---
+syntax: javascript
+tags: [ array, map ]
+---
+// To map over an array:
+const squares = [1, 2, 3, 4].map(x => x * x);
+```
+
+The `cheat` executable includes no cheatsheets, but [community-sourced
+cheatsheets are available][cheatsheets]. You will be asked if you would like to
+install the community-sourced cheatsheets the first time you run `cheat`.
+
+
+Cheatpaths
+----------
+Cheatsheets are stored on "cheatpaths", which are directories that contain
+cheatsheets. Cheatpaths are specified in the `conf.yml` file.
+
+It can be useful to configure `cheat` against multiple cheatpaths. A common
+pattern is to store cheatsheets from multiple repositories on individual
+cheatpaths:
+
+```yaml
+# conf.yml:
+# ...
+cheatpaths:
+  - name: community                   # a name for the cheatpath
+    path: ~/documents/cheat/community # the path's location on the filesystem
+    tags: [ community ]               # these tags will be applied to all sheets on the path
+    readonly: true                    # if true, `cheat` will not create new cheatsheets here
+
+  - name: personal
+    path: ~/documents/cheat/personal  # this is a separate directory and repository than above
+    tags: [ personal ]
+    readonly: false                   # new sheets may be written here
+# ...
+```
+
+The `readonly` option instructs `cheat` not to edit (or create) any cheatsheets
+on the path. This is useful to prevent merge-conflicts from arising on upstream
+cheatsheet repositories.
+
+If a user attempts to edit a cheatsheet on a read-only cheatpath, `cheat` will
+transparently copy that sheet to a writeable directory before opening it for
+editing.
+
+### Directory-scoped Cheatpaths ###
+At times, it can be useful to closely associate cheatsheets with a directory on
+your filesystem. `cheat` facilitates this by searching for a `.cheat` folder in
+the current working directory. If found, the `.cheat` directory will
+(temporarily) be added to the cheatpaths.
+
+Usage
+-----
 To view a cheatsheet:
 
 ```sh
@@ -68,12 +162,6 @@ To list all available cheatsheets:
 cheat -l
 ```
 
-To briefly list all cheatsheets (names and tags only):
-
-```sh
-cheat -b
-```
-
 To list all cheatsheets that are tagged with "networking":
 
 ```sh
@@ -105,76 +193,9 @@ Flags may be combined in intuitive ways. Example: to search sheets on the
 cheat -p personal -t networking --regex -s '(?:[0-9]{1,3}\.){3}[0-9]{1,3}'
 ```
 
-## Cheatsheets
-Cheatsheets are plain-text files with no file extension, and are named
-according to the command used to view them:
 
-```sh
-cheat tar     # file is named "tar"
-cheat foo/bar # file is named "bar", in a "foo" subdirectory
-```
-
-Cheatsheet text may optionally be preceded by a YAML frontmatter header that
-assigns tags and specifies syntax:
-
-```
----
-syntax: javascript
-tags: [ array, map ]
----
-// To map over an array:
-const squares = [1, 2, 3, 4].map(x => x * x);
-```
-
-Syntax highlighting is provided by [Chroma][], and the `syntax` value may be
-set to any lexer name that Chroma supports. See Chroma's [supported
-languages][] for a complete list.
-
-The `cheat` executable includes no cheatsheets, but [community-sourced
-cheatsheets are available][cheatsheets]. You will be asked if you would like to
-install the community-sourced cheatsheets the first time you run `cheat`.
-
-## Cheatpaths
-Cheatsheets are stored on "cheatpaths", which are directories that contain
-cheatsheets. Cheatpaths are specified in the `conf.yml` file.
-
-It can be useful to configure `cheat` against multiple cheatpaths. A common
-pattern is to store cheatsheets from multiple repositories on individual
-cheatpaths:
-
-```yaml
-# conf.yml:
-# ...
-cheatpaths:
-  - name: community                   # a name for the cheatpath
-    path: ~/documents/cheat/community # the path's location on the filesystem
-    tags: [ community ]               # these tags will be applied to all sheets on the path
-    readonly: true                    # if true, `cheat` will not create new cheatsheets here
-
-  - name: personal
-    path: ~/documents/cheat/personal  # this is a separate directory and repository than above
-    tags: [ personal ]
-    readonly: false                   # new sheets may be written here
-# ...
-```
-
-The `readonly` option instructs `cheat` not to edit (or create) any cheatsheets
-on the path. This is useful to prevent merge-conflicts from arising on upstream
-cheatsheet repositories.
-
-If a user attempts to edit a cheatsheet on a read-only cheatpath, `cheat` will
-transparently copy that sheet to a writeable directory before opening it for
-editing.
-
-### Directory-scoped Cheatpaths
-At times, it can be useful to closely associate cheatsheets with a directory on
-your filesystem. `cheat` facilitates this by searching for a `.cheat` directory
-in the current working directory and its ancestors (similar to how `git` locates
-`.git` directories). The nearest `.cheat` directory found will (temporarily) be
-added to the cheatpaths. This means you can place a `.cheat` directory at your
-project root and it will be available from any subdirectory within that project.
-
-## Autocompletion
+Advanced Usage
+--------------
 Shell autocompletion is currently available for `bash`, `fish`, and `zsh`. Copy
 the relevant [completion script][completions] into the appropriate directory on
 your filesystem to enable autocompletion. (This directory will vary depending
@@ -186,10 +207,7 @@ Additionally, `cheat` supports enhanced autocompletion via integration with
 1. Ensure that `fzf` is available on your `$PATH`
 2. Set an envvar: `export CHEAT_USE_FZF=true`
 
-[INSTALLING.md]: INSTALLING.md
 [Releases]:    https://github.com/cheat/cheat/releases
 [cheatsheets]: https://github.com/cheat/cheatsheets
 [completions]: https://github.com/cheat/cheat/tree/master/scripts
-[Chroma]:                https://github.com/alecthomas/chroma
-[supported languages]:   https://github.com/alecthomas/chroma#supported-languages
 [fzf]:         https://github.com/junegunn/fzf

adr/001-path-traversal-protection.md

@@ -1,169 +0,0 @@
-# ADR-001: Path Traversal Protection for Cheatsheet Names
-
-Date: 2025-01-21
-
-## Status
-
-Accepted
-
-## Context
-
-The `cheat` tool allows users to create, edit, and remove cheatsheets using commands like:
-- `cheat --edit <name>`
-- `cheat --rm <name>`
-
-Without validation, a user could potentially provide malicious names like:
-- `../../../etc/passwd` (directory traversal)
-- `/etc/passwd` (absolute path)
-- `~/.ssh/authorized_keys` (home directory expansion)
-
-While `cheat` is a local tool run by the user themselves (not a network service), path traversal could still lead to:
-1. Accidental file overwrites outside cheatsheet directories
-2. Confusion about where files are being created
-3. Potential security issues in shared environments
-
-## Decision
-
-We implemented input validation for cheatsheet names to prevent directory traversal attacks. The validation rejects names that:
-
-1. Contain `..` (parent directory references)
-2. Are absolute paths (start with `/` on Unix)
-3. Start with `~` (home directory expansion)
-4. Are empty
-5. Start with `.` (hidden files - these are not displayed by cheat)
-
-The validation is performed at the application layer before any file operations occur.
-
-## Implementation Details
-
-### Validation Function
-
-The validation is implemented in `internal/sheet/validate.go`:
-
-```go
-func Validate(name string) error {
-    // Reject empty names
-    if name == "" {
-        return fmt.Errorf("cheatsheet name cannot be empty")
-    }
-
-    // Reject names containing directory traversal
-    if strings.Contains(name, "..") {
-        return fmt.Errorf("cheatsheet name cannot contain '..'")
-    }
-
-    // Reject absolute paths
-    if filepath.IsAbs(name) {
-        return fmt.Errorf("cheatsheet name cannot be an absolute path")
-    }
-
-    // Reject names that start with ~ (home directory expansion)
-    if strings.HasPrefix(name, "~") {
-        return fmt.Errorf("cheatsheet name cannot start with '~'")
-    }
-
-    // Reject hidden files (files that start with a dot)
-    filename := filepath.Base(name)
-    if strings.HasPrefix(filename, ".") {
-        return fmt.Errorf("cheatsheet name cannot start with '.' (hidden files are not supported)")
-    }
-
-    return nil
-}
-```
-
-### Integration Points
-
-The validation is called in:
-- `cmd/cheat/cmd_edit.go` - before creating or editing a cheatsheet
-- `cmd/cheat/cmd_remove.go` - before removing a cheatsheet
-
-### Allowed Patterns
-
-The following patterns are explicitly allowed:
-- Simple names: `docker`, `git`
-- Nested paths: `docker/compose`, `lang/go/slice`
-- Current directory references: `./mysheet`
-
-## Consequences
-
-### Positive
-
-1. **Safety**: Prevents accidental or intentional file operations outside cheatsheet directories
-2. **Simplicity**: Validation happens early, before any file operations
-3. **User-friendly**: Clear error messages explain why a name was rejected
-4. **Performance**: Minimal overhead - simple string checks
-5. **Compatibility**: Doesn't break existing valid cheatsheet names
-
-### Negative
-
-1. **Limitation**: Users cannot use `..` in cheatsheet names even if legitimate
-2. **No symlink support**: Cannot create cheatsheets through symlinks outside the cheatpath
-
-### Neutral
-
-1. Uses Go's `filepath.IsAbs()` which handles platform differences (Windows vs Unix)
-2. No attempt to resolve or canonicalize paths - validation is purely syntactic
-
-## Security Considerations
-
-### Threat Model
-
-`cheat` is a local command-line tool, not a network service. The primary threats are:
-- User error (accidentally overwriting important files)
-- Malicious scripts that invoke `cheat` with crafted arguments
-- Shared system scenarios where cheatsheets might be shared
-
-### What This Protects Against
-
-- Directory traversal using `../`
-- Absolute path access to system files
-- Shell expansion of `~` to home directory
-- Empty names that might cause unexpected behavior
-- Hidden files that wouldn't be displayed anyway
-
-### What This Does NOT Protect Against
-
-- Users with filesystem permissions can still directly edit any file
-- Symbolic links within the cheatpath pointing outside
-- Race conditions (TOCTOU) - though minimal risk for a local tool
-- Malicious content within cheatsheets themselves
-
-## Testing
-
-Comprehensive tests ensure the validation works correctly:
-
-1. **Unit tests** (`internal/sheet/validate_test.go`) verify the validation logic
-2. **Integration tests** verify the actual binary blocks malicious inputs
-3. **No system files are accessed** during testing - all tests use isolated directories
-
-Example test cases:
-```bash
-# These are blocked:
-cheat --edit "../../../etc/passwd"
-cheat --edit "/etc/passwd"
-cheat --edit "~/.ssh/config"
-cheat --rm ".."
-
-# These are allowed:
-cheat --edit "docker"
-cheat --edit "docker/compose"
-cheat --edit "./local"
-```
-
-## Alternative Approaches Considered
-
-1. **Path resolution and verification**: Resolve the final path and check if it's within the cheatpath
-   - Rejected: More complex, potential race conditions, platform-specific edge cases
-
-2. **Chroot/sandbox**: Run file operations in a restricted environment
-   - Rejected: Overkill for a local tool, platform compatibility issues
-
-3. **Filename allowlist**: Only allow alphanumeric characters and specific symbols
-   - Rejected: Too restrictive, would break existing cheatsheets with valid special characters
-
-## References
-
-- OWASP Path Traversal: https://owasp.org/www-community/attacks/Path_Traversal
-- CWE-22: Improper Limitation of a Pathname to a Restricted Directory
-- Go filepath package documentation: https://pkg.go.dev/path/filepath

adr/002-environment-variable-parsing.md

@@ -1,100 +0,0 @@
-# ADR-002: No Defensive Checks for Environment Variable Parsing
-
-Date: 2025-01-21
-
-## Status
-
-Accepted
-
-## Context
-
-In `cmd/cheat/main.go` lines 47-52, the code parses environment variables assuming they all contain an equals sign:
-
-```go
-for _, e := range os.Environ() {
-    pair := strings.SplitN(e, "=", 2)
-    if runtime.GOOS == "windows" {
-        pair[0] = strings.ToUpper(pair[0])
-    }
-    envvars[pair[0]] = pair[1]  // Could panic if pair has < 2 elements
-}
-```
-
-If `os.Environ()` returned a string without an equals sign, `strings.SplitN` would return a slice with only one element, causing a panic when accessing `pair[1]`.
-
-## Decision
-
-We will **not** add defensive checks for this condition. The current code that assumes all environment strings contain "=" will remain unchanged.
-
-## Rationale
-
-### Go Runtime Guarantees
-
-Go's official documentation guarantees that `os.Environ()` returns environment variables in the form "key=value". This is a documented contract of the Go runtime that has been stable since Go 1.0.
-
-### Empirical Evidence
-
-Testing across platforms confirms:
-- All environment variables returned by `os.Environ()` contain at least one "="
-- Empty environment variables appear as "KEY=" (with an empty value)
-- Even Windows special variables like "=C:=C:\path" maintain the format
-
-### Cost-Benefit Analysis
-
-Adding defensive code would:
-- **Cost**: Add complexity and cognitive overhead
-- **Cost**: Suggest uncertainty about Go's documented behavior
-- **Cost**: Create dead code that can never execute under normal conditions
-- **Benefit**: Protect against a theoretical scenario that violates Go's guarantees
-
-The only scenarios where this could panic are:
-1. A bug in Go's runtime (extremely unlikely, would affect all Go programs)
-2. Corrupted OS-level environment (would cause broader system issues)
-3. Breaking change in future Go version (would break many programs, unlikely)
-
-## Consequences
-
-### Positive
-- Simpler, more readable code
-- Trust in platform guarantees reduces unnecessary defensive programming
-- No performance overhead from unnecessary checks
-
-### Negative
-- Theoretical panic if Go's guarantees are violated
-
-### Neutral
-- Follows Go community standards of trusting standard library contracts
-
-## Alternatives Considered
-
-### 1. Add Defensive Check
-```go
-if len(pair) < 2 {
-    continue  // or pair[1] = ""
-}
-```
-**Rejected**: Adds complexity for a condition that should never occur.
-
-### 2. Add Panic with Clear Message
-```go
-if len(pair) < 2 {
-    panic("os.Environ() contract violation: " + e)
-}
-```
-**Rejected**: Would crash the program for the same theoretical issue.
-
-### 3. Add Comment Documenting Assumption
-```go
-// os.Environ() guarantees "key=value" format, so pair[1] is safe
-envvars[pair[0]] = pair[1]
-```
-**Rejected**: While documentation is good, this particular guarantee is fundamental to Go.
-
-## Notes
-
-If Go ever changes this behavior (extremely unlikely as it would break compatibility), it would be caught immediately in testing as the program would panic on startup. This would be a clear signal to revisit this decision.
-
-## References
-
-- Go os.Environ() documentation: https://pkg.go.dev/os#Environ
-- Go os.Environ() source code and tests

adr/003-search-parallelization.md

@@ -1,104 +0,0 @@
-# ADR-003: No Parallelization for Search Operations
-
-Date: 2025-01-22
-
-## Status
-
-Accepted
-
-## Context
-
-We investigated optimizing cheat's search performance through parallelization. Initial assumptions suggested that I/O operations (reading multiple cheatsheet files) would be the primary bottleneck, making parallel processing beneficial.
-
-Performance benchmarks were implemented to measure search operations, and a parallel search implementation using goroutines was created and tested.
-
-## Decision
-
-We will **not** implement parallel search. The sequential implementation will remain unchanged.
-
-## Rationale
-
-### Performance Profile Analysis
-
-CPU profiling revealed that search performance is dominated by:
-- **Process creation overhead** (~30% in `os/exec.(*Cmd).Run`)
-- **System calls** (~30% in `syscall.Syscall6`)
-- **Process management** (fork, exec, pipe setup)
-
-The actual search logic (regex matching, file reading) was negligible in the profile, indicating our optimization efforts were targeting the wrong bottleneck.
-
-### Benchmark Results
-
-Parallel implementation showed minimal improvements:
-- Simple search: 17ms → 15.3ms (10% improvement)
-- Regex search: 15ms → 14.9ms (minimal improvement)  
-- Colorized search: 19.5ms → 16.8ms (14% improvement)
-- Complex regex: 20ms → 15.3ms (24% improvement)
-
-The best case saved only ~5ms in absolute terms.
-
-### Cost-Benefit Analysis
-
-**Costs of parallelization:**
-- Added complexity with goroutines, channels, and synchronization
-- Increased maintenance burden
-- More difficult debugging and testing
-- Potential race conditions
-
-**Benefits:**
-- 5-15% performance improvement (5ms in real terms)
-- Imperceptible to users in interactive use
-
-### User Experience Perspective
-
-For a command-line tool:
-- Current 15-20ms response time is excellent
-- Users cannot perceive 5ms differences
-- Sub-50ms is considered "instant" in HCI research
-
-## Consequences
-
-### Positive
-- Simpler, more maintainable codebase
-- Easier to debug and reason about
-- No synchronization bugs or race conditions
-- Focus remains on code clarity
-
-### Negative
-- Missed opportunity for ~5ms performance gain
-- Search remains single-threaded
-
-### Neutral
-- Performance remains excellent for intended use case
-- Follows Go philosophy of preferring simplicity
-
-## Alternatives Considered
-
-### 1. Keep Parallel Implementation
-**Rejected**: Complexity outweighs negligible performance gains.
-
-### 2. Optimize Process Startup
-**Rejected**: Process creation overhead is inherent to CLI tools and cannot be avoided without fundamental architecture changes.
-
-### 3. Future Optimizations
-If performance becomes critical, consider:
-- **Long-running daemon**: Eliminate process startup overhead entirely
-- **Shell function**: Reduce fork/exec overhead
-- **Compiled-in cheatsheets**: Eliminate file I/O
-
-However, these would fundamentally change the tool's architecture and usage model.
-
-## Notes
-
-This decision reinforces important principles:
-1. Always profile before optimizing
-2. Consider the full execution context
-3. Measure what matters to users
-4. Complexity has a real cost
-
-The parallelization attempt was valuable as a learning exercise and definitively answered whether this optimization path was worthwhile.
-
-## References
-
-- Benchmark implementation: cmd/cheat/search_bench_test.go
-- Reverted parallel implementation: see git history (commit 82eb918)

adr/004-recursive-cheat-directory-search.md

@@ -1,80 +0,0 @@
-# ADR-004: Recursive `.cheat` Directory Search
-
-Date: 2026-02-15
-
-## Status
-
-Accepted
-
-## Context
-
-Previously, `cheat` only checked the current working directory for a `.cheat`
-subdirectory to use as a directory-scoped cheatpath. If a user was in
-`~/projects/myapp/src/handlers/` but the `.cheat` directory lived at
-`~/projects/myapp/.cheat`, it would not be found. Users requested (#602) that
-`cheat` walk up the directory hierarchy to find the nearest `.cheat`
-directory, mirroring the discovery pattern used by `git` for `.git`
-directories.
-
-## Decision
-
-Walk upward from the current working directory to the filesystem root, and
-stop at the first `.cheat` directory found. Only directories are matched (a
-file named `.cheat` is ignored).
-
-### Stop at first `.cheat` found
-
-Rather than collecting multiple `.cheat` directories from ancestor directories:
-
-- Matches `.git` discovery semantics, which users already understand
-- Fits the existing single-cheatpath-named-`"cwd"` code without structural
-  changes
-- Avoids precedence and naming complexity when multiple `.cheat` directories
-  exist in the ancestor chain
-- `cheat` already supports multiple cheatpaths via `conf.yml` for users who
-  want that; directory-scoped `.cheat` serves the project-context use case
-
-### Walk to filesystem root (not `$HOME`)
-
-Rather than stopping the search at `$HOME`:
-
-- Simpler implementation with no platform-specific home-directory detection
-- Supports sysadmins working in `/etc`, `/srv`, `/var`, or other paths
-  outside `$HOME`
-- The boundary only matters on the failure path (no `.cheat` found anywhere),
-  where the cost is a few extra `stat` calls
-- Security is not a concern since cheatsheets are display-only text, not
-  executable code
-
-## Consequences
-
-### Positive
-- Users can place `.cheat` at their project root and it works from any
-  subdirectory, matching their mental model
-- No configuration changes needed; existing `.cheat` directories continue to
-  work identically
-- Minimal code change (one small helper function)
-
-### Negative
-- A `.cheat` directory in an unexpected ancestor could be picked up
-  unintentionally, though this is unlikely in practice and matches how `.git`
-  works
-
-### Neutral
-- The cheatpath name remains `"cwd"` regardless of which ancestor the `.cheat`
-  was found in
-
-## Alternatives Considered
-
-### 1. Stop at `$HOME`
-**Rejected**: Adds platform-specific complexity for minimal benefit. The only
-downside of walking to root is a few extra `stat` calls on the failure path.
-
-### 2. Collect multiple `.cheat` directories
-**Rejected**: Introduces precedence and naming complexity. Users who want
-multiple cheatpaths can configure them in `conf.yml`.
-
-## References
-
-- GitHub issue: #602
-- Implementation: `findLocalCheatpath()` in `internal/config/config.go`

build/embed.go

@@ -0,0 +1,93 @@
+// +build ignore
+
+// This script embeds `docopt.txt and `conf.yml` into the binary during at
+// build time.
+
+package main
+
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+func main() {
+
+	// get the cwd
+	cwd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// get the project root
+	root, err := filepath.Abs(cwd + "../../../")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// specify template file information
+	type file struct {
+		In     string
+		Out    string
+		Method string
+	}
+
+	// enumerate the template files to process
+	files := []file{
+		file{
+			In:     "cmd/cheat/docopt.txt",
+			Out:    "cmd/cheat/str_usage.go",
+			Method: "usage"},
+		file{
+			In:     "configs/conf.yml",
+			Out:    "cmd/cheat/str_config.go",
+			Method: "configs"},
+	}
+
+	// iterate over each static file
+	for _, file := range files {
+
+		// delete the outfile
+		os.Remove(path.Join(root, file.Out))
+
+		// read the static template
+		bytes, err := ioutil.ReadFile(path.Join(root, file.In))
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// render the template
+		data := template(file.Method, string(bytes))
+
+		// write the file to the specified outpath
+		spath := path.Join(root, file.Out)
+		err = ioutil.WriteFile(spath, []byte(data), 0644)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+}
+
+// template packages the
+func template(method string, body string) string {
+
+	// specify the template string
+	t := `package main
+
+// Code generated .* DO NOT EDIT.
+
+import (
+	"strings"
+)
+
+func %s() string {
+	return strings.TrimSpace(%s)
+}
+`
+
+	return fmt.Sprintf(t, method, "`"+body+"`")
+}

cmd/cheat/cmd_conf.go

@@ -1,11 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"github.com/cheat/cheat/internal/config"
-)
-
-func cmdConf(_ map[string]interface{}, conf config.Config) {
-	fmt.Println(conf.Path)
-}

cmd/cheat/cmd_directories.go

@@ -10,7 +10,7 @@ import (
 )
 
 // cmdDirectories lists the configured cheatpaths.
-func cmdDirectories(_ map[string]interface{}, conf config.Config) {
+func cmdDirectories(opts map[string]interface{}, conf config.Config) {
 
 	// initialize a tabwriter to produce cleanly columnized output
 	var out bytes.Buffer
@@ -18,10 +18,14 @@ func cmdDirectories(_ map[string]interface{}, conf config.Config) {
 
 	// generate sorted, columnized output
 	for _, path := range conf.Cheatpaths {
-		fmt.Fprintf(w, "%s:\t%s\n", path.Name, path.Path)
+		fmt.Fprintln(w, fmt.Sprintf(
+			"%s:\t%s",
+			path.Name,
+			path.Path,
+		))
 	}
 
 	// write columnized output to stdout
 	w.Flush()
-	display.Write(out.String(), conf)
+	display.Display(out.String(), conf)
 }

cmd/cheat/cmd_edit.go

@@ -4,12 +4,11 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path/filepath"
+	"path"
 	"strings"
 
 	"github.com/cheat/cheat/internal/cheatpath"
 	"github.com/cheat/cheat/internal/config"
-	"github.com/cheat/cheat/internal/sheet"
 	"github.com/cheat/cheat/internal/sheets"
 )
 
@@ -18,18 +17,14 @@ func cmdEdit(opts map[string]interface{}, conf config.Config) {
 
 	cheatsheet := opts["--edit"].(string)
 
-	// validate the cheatsheet name
-	if err := sheet.Validate(cheatsheet); err != nil {
-		fmt.Fprintf(os.Stderr, "invalid cheatsheet name: %v\n", err)
-		os.Exit(1)
-	}
-
 	// load the cheatsheets
 	cheatsheets, err := sheets.Load(conf.Cheatpaths)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to list cheatsheets: %v\n", err)
+		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,
@@ -51,37 +46,56 @@ func cmdEdit(opts map[string]interface{}, conf config.Config) {
 	// if the sheet exists and is not read-only, edit it in place
 	if ok && !sheet.ReadOnly {
 		editpath = sheet.Path
-	} else {
-		// for read-only or non-existent sheets, resolve a writeable 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)
 		}
 
-		// use the existing title for read-only copies, the requested name otherwise
-		title := cheatsheet
-		if ok {
-			title = sheet.Title
-		}
-		editpath = filepath.Join(writepath.Path, title)
+		// compute the new edit path
+		editpath = path.Join(writepath.Path, sheet.Title)
 
-		if ok {
-			// copy the read-only sheet to the writeable path
-			// (Copy handles MkdirAll internally)
-			if err := sheet.Copy(editpath); err != nil {
-				fmt.Fprintf(os.Stderr, "failed to copy cheatsheet: %v\n", err)
-				os.Exit(1)
-			}
-		} else {
-			// create any necessary subdirectories for the new sheet
-			dirs := filepath.Dir(editpath)
+		// 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)
+			}
 		}
 	}
 

cmd/cheat/cmd_init.go

@@ -3,27 +3,54 @@ package main
 import (
 	"fmt"
 	"os"
+	"path"
 	"runtime"
+	"strings"
+
+	"github.com/mitchellh/go-homedir"
 
 	"github.com/cheat/cheat/internal/config"
-	"github.com/cheat/cheat/internal/installer"
 )
 
 // cmdInit displays an example config file.
-func cmdInit(home string, envvars map[string]string) {
+func cmdInit() {
 
-	// identify the os-specific paths at which configs may be located
+	// get the user's home directory
+	home, err := homedir.Dir()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to get user home directory: %v\n", err)
+		os.Exit(1)
+	}
+
+	// read the envvars into a map of strings
+	envvars := map[string]string{}
+	for _, e := range os.Environ() {
+		pair := strings.SplitN(e, "=", 2)
+		envvars[pair[0]] = pair[1]
+	}
+
+	// load the config template
+	configs := configs()
+
+	// identify the os-specifc paths at which configs may be located
 	confpaths, err := config.Paths(runtime.GOOS, home, envvars)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "failed to read config paths: %v\n", err)
 		os.Exit(1)
 	}
 
+	// determine the appropriate paths for config data and (optional) community
+	// cheatsheets based on the user's platform
 	confpath := confpaths[0]
+	confdir := path.Dir(confpath)
 
-	// expand template placeholders and comment out community cheatpath
-	configs := installer.ExpandTemplate(configs(), confpath)
-	configs = installer.CommentCommunity(configs, confpath)
+	// create paths for community and personal cheatsheets
+	community := path.Join(confdir, "/cheatsheets/community")
+	personal := path.Join(confdir, "/cheatsheets/personal")
+
+	// template the above paths into the default configs
+	configs = strings.Replace(configs, "COMMUNITY_PATH", community, -1)
+	configs = strings.Replace(configs, "PERSONAL_PATH", personal, -1)
 
 	// output the templated configs
 	fmt.Println(configs)

cmd/cheat/cmd_list.go

@@ -21,9 +21,11 @@ func cmdList(opts map[string]interface{}, conf config.Config) {
 	// load the cheatsheets
 	cheatsheets, err := sheets.Load(conf.Cheatpaths)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to list cheatsheets: %v\n", err)
+		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,
@@ -35,8 +37,8 @@ func cmdList(opts map[string]interface{}, conf config.Config) {
 	// 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 {
+	for _, pathSheets := range cheatsheets {
+		for _, s := range pathSheets {
 			flattened = append(flattened, s)
 		}
 	}
@@ -61,7 +63,10 @@ func cmdList(opts map[string]interface{}, conf config.Config) {
 		// compile the regex
 		reg, err := regexp.Compile(pattern)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "failed to compile regexp: %s, %v\n", pattern, err)
+			fmt.Fprintln(
+				os.Stderr,
+				fmt.Sprintf("failed to compile regexp: %s, %v", pattern, err),
+			)
 			os.Exit(1)
 		}
 
@@ -85,20 +90,20 @@ func cmdList(opts map[string]interface{}, conf config.Config) {
 	var out bytes.Buffer
 	w := tabwriter.NewWriter(&out, 0, 0, 1, ' ', 0)
 
-	// generate sorted, columnized output
-	if opts["--brief"].(bool) {
-		fmt.Fprintln(w, "title:\ttags:")
-		for _, sheet := range flattened {
-			fmt.Fprintf(w, "%s\t%s\n", sheet.Title, strings.Join(sheet.Tags, ","))
-		}
-	} else {
+	// write a header row
 	fmt.Fprintln(w, "title:\tfile:\ttags:")
+
+	// generate sorted, columnized output
 	for _, sheet := range flattened {
-			fmt.Fprintf(w, "%s\t%s\t%s\n", sheet.Title, sheet.Path, strings.Join(sheet.Tags, ","))
-		}
+		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()
-	display.Write(out.String(), conf)
+	display.Display(out.String(), conf)
 }

cmd/cheat/cmd_remove.go

@@ -6,27 +6,22 @@ import (
 	"strings"
 
 	"github.com/cheat/cheat/internal/config"
-	"github.com/cheat/cheat/internal/sheet"
 	"github.com/cheat/cheat/internal/sheets"
 )
 
-// cmdRemove removes (deletes) a cheatsheet.
+// 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)
 
-	// validate the cheatsheet name
-	if err := sheet.Validate(cheatsheet); err != nil {
-		fmt.Fprintf(os.Stderr, "invalid cheatsheet name: %v\n", err)
-		os.Exit(1)
-	}
-
 	// load the cheatsheets
 	cheatsheets, err := sheets.Load(conf.Cheatpaths)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to list cheatsheets: %v\n", err)
+		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,
@@ -42,19 +37,19 @@ func cmdRemove(opts map[string]interface{}, conf config.Config) {
 	// fail early if the requested cheatsheet does not exist
 	sheet, ok := consolidated[cheatsheet]
 	if !ok {
-		fmt.Fprintf(os.Stderr, "No cheatsheet found for '%s'.\n", cheatsheet)
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("No cheatsheet found for '%s'.\n", cheatsheet))
 		os.Exit(2)
 	}
 
 	// fail early if the sheet is read-only
 	if sheet.ReadOnly {
-		fmt.Fprintf(os.Stderr, "cheatsheet '%s' is read-only.\n", cheatsheet)
+		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.Fprintf(os.Stderr, "failed to delete sheet: %s, %v\n", sheet.Title, err)
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to delete sheet: %s, %v", sheet.Title, err))
 		os.Exit(1)
 	}
 }

cmd/cheat/cmd_search.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/cheat/cheat/internal/config"
 	"github.com/cheat/cheat/internal/display"
+	"github.com/cheat/cheat/internal/sheet"
 	"github.com/cheat/cheat/internal/sheets"
 )
 
@@ -19,9 +20,11 @@ func cmdSearch(opts map[string]interface{}, conf config.Config) {
 	// load the cheatsheets
 	cheatsheets, err := sheets.Load(conf.Cheatpaths)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to list cheatsheets: %v\n", err)
+		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,
@@ -29,7 +32,33 @@ func cmdSearch(opts map[string]interface{}, conf config.Config) {
 		)
 	}
 
-	// prepare the search pattern
+	// 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)
+
+	// if <cheatsheet> was provided, search that single sheet only
+	if opts["<cheatsheet>"] != nil {
+
+		cheatsheet := opts["<cheatsheet>"].(string)
+
+		// assert that the cheatsheet exists
+		s, ok := consolidated[cheatsheet]
+		if !ok {
+			fmt.Printf("No cheatsheet found for '%s'.\n", cheatsheet)
+			os.Exit(2)
+		}
+
+		consolidated = map[string]sheet.Sheet{
+			cheatsheet: s,
+		}
+	}
+
+	// sort the cheatsheets alphabetically, and search for matches
+	out := ""
+	for _, sheet := range sheets.Sort(consolidated) {
+
+		// 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
@@ -37,29 +66,16 @@ func cmdSearch(opts map[string]interface{}, conf config.Config) {
 			pattern = phrase
 		}
 
-	// compile the regex once, outside the loop
+		// compile the regex
 		reg, err := regexp.Compile(pattern)
 		if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to compile regexp: %s, %v\n", pattern, err)
+			fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to compile regexp: %s, %v", pattern, err))
 			os.Exit(1)
 		}
 
-	// iterate over each cheatpath
-	out := ""
-	for _, pathcheats := range cheatsheets {
-
-		// sort the cheatsheets alphabetically, and search for matches
-		for _, sheet := range sheets.Sort(pathcheats) {
-
-			// if <cheatsheet> was provided, constrain the search only to
-			// matching cheatsheets
-			if opts["<cheatsheet>"] != nil && sheet.Title != opts["<cheatsheet>"] {
-				continue
-			}
-
-			// `Search` will return text entries that match the search terms.
-			// We're using it here to overwrite the prior cheatsheet Text,
-			// filtering it to only what is relevant.
+		// `Search` will return text entries that match the search terms. We're
+		// using it here to overwrite the prior cheatsheet Text, filtering it to
+		// only what is relevant
 		sheet.Text = sheet.Search(reg)
 
 		// if the sheet did not match the search, ignore it and move on
@@ -72,24 +88,15 @@ func cmdSearch(opts map[string]interface{}, conf config.Config) {
 			sheet.Colorize(conf)
 		}
 
-			// display the cheatsheet body
-			out += fmt.Sprintf(
-				"%s %s\n%s\n",
-				// append the cheatsheet title
-				sheet.Title,
-				// append the cheatsheet path
-				display.Faint(fmt.Sprintf("(%s)", sheet.CheatPath), conf.Color(opts)),
-				// indent each line of content
-				display.Indent(sheet.Text),
-			)
-		}
-	}
+		// output the cheatsheet title
+		out += fmt.Sprintf("%s:\n", sheet.Title)
 
-	// trim superfluous newlines
-	out = strings.TrimSpace(out)
+		// indent each line of content with two spaces
+		for _, line := range strings.Split(sheet.Text, "\n") {
+			out += fmt.Sprintf("  %s\n", line)
+		}
+	}
 
 	// display the output
-	// NB: resist the temptation to call `display.Write` multiple times in the
-	// loop above. That will not play nicely with the paginator.
-	display.Write(out, conf)
+	display.Display(out, conf)
 }

cmd/cheat/cmd_tags.go

@@ -10,12 +10,12 @@ import (
 )
 
 // cmdTags lists all tags in use.
-func cmdTags(_ map[string]interface{}, conf config.Config) {
+func cmdTags(opts map[string]interface{}, conf config.Config) {
 
 	// load the cheatsheets
 	cheatsheets, err := sheets.Load(conf.Cheatpaths)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to list cheatsheets: %v\n", err)
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to list cheatsheets: %v", err))
 		os.Exit(1)
 	}
 
@@ -26,5 +26,5 @@ func cmdTags(_ map[string]interface{}, conf config.Config) {
 	}
 
 	// display the output
-	display.Write(out, conf)
+	display.Display(out, conf)
 }

cmd/cheat/cmd_view.go

@@ -18,9 +18,11 @@ func cmdView(opts map[string]interface{}, conf config.Config) {
 	// load the cheatsheets
 	cheatsheets, err := sheets.Load(conf.Cheatpaths)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to list cheatsheets: %v\n", err)
+		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,
@@ -28,39 +30,9 @@ func cmdView(opts map[string]interface{}, conf config.Config) {
 		)
 	}
 
-	// if --all was passed, display cheatsheets from all cheatpaths
-	if opts["--all"].(bool) {
-		// iterate over the cheatpaths
-		out := ""
-		for _, cheatpath := range cheatsheets {
-
-			// if the cheatpath contains the specified cheatsheet, display it
-			if sheet, ok := cheatpath[cheatsheet]; ok {
-
-				// identify the matching cheatsheet
-				out += fmt.Sprintf("%s %s\n",
-					sheet.Title,
-					display.Faint(fmt.Sprintf("(%s)", sheet.CheatPath), conf.Color(opts)),
-				)
-
-				// apply colorization if requested
-				if conf.Color(opts) {
-					sheet.Colorize(conf)
-				}
-
-				// display the cheatsheet
-				out += display.Indent(sheet.Text) + "\n"
-			}
-		}
-
-		// display and exit
-		display.Write(strings.TrimSuffix(out, "\n"), conf)
-		os.Exit(0)
-	}
-
-	// otherwise, consolidate the cheatsheets found on all paths into a single
-	// map of `title` => `sheet` (ie, allow more local cheatsheets to override
-	// less local cheatsheets)
+	// 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
@@ -76,5 +48,5 @@ func cmdView(opts map[string]interface{}, conf config.Config) {
 	}
 
 	// display the cheatsheet
-	display.Write(sheet.Text, conf)
+	display.Display(sheet.Text, conf)
 }

cmd/cheat/config.go

@@ -1,74 +0,0 @@
-package main
-
-// configs returns the default configuration template
-func configs() string {
-	return `---
-# The editor to use with 'cheat -e <sheet>'. Overridden by $VISUAL or $EDITOR.
-editor: EDITOR_PATH
-
-# Should 'cheat' always colorize output?
-colorize: false
-
-# 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: terminal256
-
-# Through which pager should output be piped?
-# 'less -FRX' is recommended on Unix systems
-# 'more' is recommended on Windows
-pager: PAGER_PATH
-
-# 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 precedence 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 by 'tags' in combination with the '--tag' flag.
-# 
-# Example: 'cheat tar --tag=community' will display the 'tar' cheatsheet that
-# is tagged as 'community' rather than your own.
-#
-# Paths that come earlier are considered to be the most "global", and paths
-# that come later are considered to be the most "local". The most "local" paths
-# take precedence.
-#
-# See: https://github.com/cheat/cheat/blob/master/doc/cheat.1.md#cheatpaths
-cheatpaths:
-
-  # Cheatsheets that are tagged "personal" are stored here by default:
-  - name: personal
-    path: PERSONAL_PATH
-    tags: [ personal ]
-    readonly: false
-
-  # Cheatsheets that are tagged "work" are stored here by default:
-  - name: work
-    path: WORK_PATH
-    tags: [ work ]
-    readonly: false
-
-  # Community cheatsheets (https://github.com/cheat/cheatsheets):
-  # To install: git clone https://github.com/cheat/cheatsheets COMMUNITY_PATH
-  - name: community
-    path: COMMUNITY_PATH
-    tags: [ community ]
-    readonly: true
-
-  # You can also use glob patterns to automatically load cheatsheets from all
-  # directories that match.
-  #
-  # Example: overload cheatsheets for projects under ~/src/github.com/example/*/
-  #- name: example-projects
-  #  path: ~/src/github.com/example/**/.cheat
-  #  tags: [ example ]
-  #  readonly: true`
-}

cmd/cheat/docopt.txt

@@ -0,0 +1,54 @@
+Usage:
+  cheat [options] [<cheatsheet>]
+
+Options:
+  --init                  Write a default config file to stdout
+  -c --colorize           Colorize output
+  -d --directories        List cheatsheet directories
+  -e --edit=<cheatsheet>  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>
+  -T --tags               List all tags in use
+  -v --version            Print the version number
+  --rm=<cheatsheet>       Remove (delete) <cheatsheet>
+
+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 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
+
+  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}'
+
+  To remove (delete) the foo/bar cheatsheet:
+    cheat --rm foo/bar

cmd/cheat/main.go

@@ -1,9 +1,11 @@
-// Package main serves as the executable entrypoint.
 package main
 
+//go:generate go run ../../build/embed.go
+
 import (
 	"fmt"
 	"os"
+	"path"
 	"runtime"
 	"strings"
 
@@ -15,17 +17,24 @@ import (
 	"github.com/cheat/cheat/internal/installer"
 )
 
-const version = "4.7.1"
+const version = "4.0.4"
 
 func main() {
 
 	// initialize options
-	opts, err := docopt.ParseArgs(usage(), nil, version)
+	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)
+	}
+
 	// get the user's home directory
 	home, err := homedir.Dir()
 	if err != nil {
@@ -36,21 +45,10 @@ func main() {
 	// read the envvars into a map of strings
 	envvars := map[string]string{}
 	for _, e := range os.Environ() {
-		// os.Environ() guarantees "key=value" format (see ADR-002)
 		pair := strings.SplitN(e, "=", 2)
-		if runtime.GOOS == "windows" {
-			pair[0] = strings.ToUpper(pair[0])
-		}
 		envvars[pair[0]] = pair[1]
 	}
 
-	// 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"] == true {
-		cmdInit(home, envvars)
-		os.Exit(0)
-	}
-
 	// identify the os-specifc paths at which configs may be located
 	confpaths, err := config.Paths(runtime.GOOS, home, envvars)
 	if err != nil {
@@ -76,23 +74,69 @@ func main() {
 			os.Exit(0)
 		}
 
-		// choose a confpath
-		confpath = confpaths[0]
+		// read the config template
+		configs := configs()
 
-		// run the installer
-		if err := installer.Run(configs(), confpath); err != nil {
-			fmt.Fprintf(os.Stderr, "failed to run installer: %v\n", err)
+		// determine the appropriate paths for config data and (optional) community
+		// cheatsheets based on the user's platform
+		confpath = confpaths[0]
+		confdir := path.Dir(confpath)
+
+		// create paths for community and personal cheatsheets
+		community := path.Join(confdir, "/cheatsheets/community")
+		personal := path.Join(confdir, "/cheatsheets/personal")
+
+		// template the above paths into the default configs
+		configs = strings.Replace(configs, "COMMUNITY_PATH", community, -1)
+		configs = strings.Replace(configs, "PERSONAL_PATH", personal, -1)
+
+		// prompt the user to download the community cheatsheets
+		yes, err = installer.Prompt(
+			"Would you like to download the community cheatsheets? [Y/n]",
+			true,
+		)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to create config: %v\n", err)
+			os.Exit(1)
+		}
+
+		// clone the community cheatsheets if so instructed
+		if yes {
+			// clone the community cheatsheets
+			if err := installer.Clone(community); err != nil {
+				fmt.Fprintf(os.Stderr, "failed to create config: %v\n", err)
+				os.Exit(1)
+			}
+
+			// also create a directory for personal cheatsheets
+			if err := os.MkdirAll(personal, os.ModePerm); err != nil {
+				fmt.Fprintf(
+					os.Stderr,
+					"failed to create config: failed to create directory: %s: %v\n",
+					personal,
+					err)
+				os.Exit(1)
+			}
+		}
+
+		// the config file does not exist, so we'll try to create one
+		if err = config.Init(confpath, configs); err != nil {
+			fmt.Fprintf(
+				os.Stderr,
+				"failed to create config file: %s: %v\n",
+				confpath,
+				err,
+			)
 			os.Exit(1)
 		}
 
-		// notify the user and exit
 		fmt.Printf("Created config file: %s\n", confpath)
 		fmt.Println("Please read this file for advanced configuration information.")
 		os.Exit(0)
 	}
 
 	// initialize the configs
-	conf, err := config.New(confpath, true)
+	conf, err := config.New(opts, confpath, true)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "failed to load config: %v\n", err)
 		os.Exit(1)
@@ -120,16 +164,13 @@ func main() {
 	var cmd func(map[string]interface{}, config.Config)
 
 	switch {
-	case opts["--conf"].(bool):
-		cmd = cmdConf
-
 	case opts["--directories"].(bool):
 		cmd = cmdDirectories
 
 	case opts["--edit"] != nil:
 		cmd = cmdEdit
 
-	case opts["--list"].(bool), opts["--brief"].(bool):
+	case opts["--list"].(bool):
 		cmd = cmdList
 
 	case opts["--tags"].(bool):
@@ -144,9 +185,6 @@ func main() {
 	case opts["<cheatsheet>"] != nil:
 		cmd = cmdView
 
-	case opts["--tag"] != nil && opts["--tag"].(string) != "":
-		cmd = cmdList
-
 	default:
 		fmt.Println(usage())
 		os.Exit(0)

cmd/cheat/str_config.go

@@ -0,0 +1,80 @@
+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
+
+# Through which pager should output be piped? (Unset this key for no pager.)
+pager: less -FRX
+
+# 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 -t <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 -t 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 placeholders. You may freely
+  # change them to suit your needs.
+  #
+  # Community cheatsheets must be installed separately, though you may have
+  # downloaded them automatically when installing 'cheat'. If not, 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: COMMUNITY_PATH
+    tags: [ community ]
+    readonly: true
+
+  # If you have personalized cheatsheets, list them last. They will take
+  # precedence over the more global cheatsheets.
+  - name: personal
+    path: PERSONAL_PATH
+    tags: [ personal ]
+    readonly: false
+
+  # While it requires no configuration here, it's also worth noting that
+  # 'cheat' will automatically append directories named '.cheat' within the
+  # current working directory to the 'cheatpath'. This can be very useful if
+  # you'd like to closely associate cheatsheets with, for example, a directory
+  # containing source code.
+  #
+  # Such "directory-scoped" cheatsheets will be treated as the most "local"
+  # cheatsheets, and will override less "local" cheatsheets. Likewise,
+  # directory-scoped cheatsheets will always be editable ('readonly: false').
+`)
+}

cmd/cheat/str_usage.go

@@ -1,26 +1,28 @@
 package main
 
-// usage returns the usage text for the cheat command
+// Code generated .* DO NOT EDIT.
+
+import (
+	"strings"
+)
+
 func usage() string {
-	return `Usage:
+	return strings.TrimSpace(`Usage:
   cheat [options] [<cheatsheet>]
 
 Options:
   --init                  Write a default config file to stdout
-  -a --all                Search among all cheatpaths
-  -b --brief              List cheatsheets without file paths
   -c --colorize           Colorize output
   -d --directories        List cheatsheet directories
   -e --edit=<cheatsheet>  Edit <cheatsheet>
   -l --list               List cheatsheets
-  -p --path=<name>        Return only sheets found on cheatpath <name>
+  -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=<cheatsheet>       Remove (delete) <cheatsheet>
-  --conf                  Display the config file path
 
 Examples:
 
@@ -42,8 +44,8 @@ Examples:
   To list all available cheatsheets:
     cheat -l
 
-  To briefly list all cheatsheets whose titles match "apt":
-    cheat -b apt
+  To list all cheatsheets whose titles match "apt":
+    cheat -l apt
 
   To list all tags in use:
     cheat -T
@@ -59,7 +61,5 @@ Examples:
 
   To remove (delete) the foo/bar cheatsheet:
     cheat --rm foo/bar
-
-  To view the configuration file path:
-    cheat --conf`
+`)
 }

configs/conf.yml

@@ -0,0 +1,69 @@
+---
+# 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
+
+# Through which pager should output be piped? (Unset this key for no pager.)
+pager: less -FRX
+
+# 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 -t <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 -t 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 placeholders. You may freely
+  # change them to suit your needs.
+  #
+  # Community cheatsheets must be installed separately, though you may have
+  # downloaded them automatically when installing 'cheat'. If not, 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: COMMUNITY_PATH
+    tags: [ community ]
+    readonly: true
+
+  # If you have personalized cheatsheets, list them last. They will take
+  # precedence over the more global cheatsheets.
+  - name: personal
+    path: PERSONAL_PATH
+    tags: [ personal ]
+    readonly: false
+
+  # While it requires no configuration here, it's also worth noting that
+  # 'cheat' will automatically append directories named '.cheat' within the
+  # current working directory to the 'cheatpath'. This can be very useful if
+  # you'd like to closely associate cheatsheets with, for example, a directory
+  # containing source code.
+  #
+  # Such "directory-scoped" cheatsheets will be treated as the most "local"
+  # cheatsheets, and will override less "local" cheatsheets. Likewise,
+  # directory-scoped cheatsheets will always be editable ('readonly: false').

doc/cheat.1

@@ -1,171 +1,208 @@
-.\" Automatically generated by Pandoc 3.1.11.1
+.\" Automatically generated by Pandoc 1.17.2
 .\"
 .TH "CHEAT" "1" "" "" "General Commands Manual"
+.hy
 .SH NAME
-\f[B]cheat\f[R] \[em] create and view command\-line cheatsheets
+.PP
+\f[B]cheat\f[] \[em] create and view command\-line cheatsheets
 .SH SYNOPSIS
 .PP
-\f[B]cheat\f[R] [options] [\f[I]CHEATSHEET\f[R]]
+\f[B]cheat\f[] [options] [\f[I]CHEATSHEET\f[]]
 .SH DESCRIPTION
-\f[B]cheat\f[R] allows you to create and view interactive cheatsheets on
+.PP
+\f[B]cheat\f[] allows you to create and view interactive cheatsheets on
 the command\-line.
 It was designed to help remind *nix system administrators of options for
 commands that they use frequently, but not frequently enough to
 remember.
 .SH OPTIONS
 .TP
-\[en]init
+.B \-\-init
 Print a config file to stdout.
+.RS
+.RE
 .TP
-\[en]conf
-Display the config file path.
-.TP
-\-a, \[en]all
-Search among all cheatpaths.
-.TP
-\-b, \[en]brief
-List cheatsheets without file paths.
-.TP
-\-c, \[en]colorize
+.B \-c, \-\-colorize
 Colorize output.
+.RS
+.RE
 .TP
-\-d, \[en]directories
+.B \-d, \-\-directories
 List cheatsheet directories.
+.RS
+.RE
 .TP
-\-e, \[en]edit=\f[I]CHEATSHEET\f[R]
-Open \f[I]CHEATSHEET\f[R] for editing.
+.B \-e, \-\-edit=\f[I]CHEATSHEET\f[]
+Open \f[I]CHEATSHEET\f[] for editing.
+.RS
+.RE
 .TP
-\-l, \[en]list
+.B \-l, \-\-list
 List available cheatsheets.
+.RS
+.RE
 .TP
-\-p, \[en]path=\f[I]PATH\f[R]
-Filter only to sheets found on path \f[I]PATH\f[R].
+.B \-p, \-\-path=\f[I]PATH\f[]
+Filter only to sheets found on path \f[I]PATH\f[].
+.RS
+.RE
 .TP
-\-r, \[en]regex
-Treat search \f[I]PHRASE\f[R] as a regular expression.
+.B \-r, \-\-regex
+Treat search \f[I]PHRASE\f[] as a regular expression.
+.RS
+.RE
 .TP
-\-s, \[en]search=\f[I]PHRASE\f[R]
-Search cheatsheets for \f[I]PHRASE\f[R].
+.B \-s, \-\-search=\f[I]PHRASE\f[]
+Search cheatsheets for \f[I]PHRASE\f[].
+.RS
+.RE
 .TP
-\-t, \[en]tag=\f[I]TAG\f[R]
-Filter only to sheets tagged with \f[I]TAG\f[R].
+.B \-t, \-\-tag=\f[I]TAG\f[]
+Filter only to sheets tagged with \f[I]TAG\f[].
+.RS
+.RE
 .TP
-\-T, \[en]tags
+.B \-T, \-\-tags
 List all tags in use.
+.RS
+.RE
 .TP
-\-v, \[en]version
+.B \-v, \-\-version
 Print the version number.
+.RS
+.RE
 .TP
-\[en]rm=\f[I]CHEATSHEET\f[R]
-Remove (deletes) \f[I]CHEATSHEET\f[R].
+.B \-\-rm=\f[I]CHEATSHEET\f[]
+Remove (deletes) \f[I]CHEATSHEET\f[].
+.RS
+.RE
 .SH EXAMPLES
 .TP
-To view the foo cheatsheet:
-cheat \f[I]foo\f[R]
+.B To view the foo cheatsheet:
+cheat \f[I]foo\f[]
+.RS
+.RE
 .TP
-To edit (or create) the foo cheatsheet:
-cheat \-e \f[I]foo\f[R]
+.B To edit (or create) the foo cheatsheet:
+cheat \-e \f[I]foo\f[]
+.RS
+.RE
 .TP
-To edit (or create) the foo/bar cheatsheet on the `work' cheatpath:
-cheat \-p \f[I]work\f[R] \-e \f[I]foo/bar\f[R]
+.B To edit (or create) the foo/bar cheatsheet on the \[aq]work\[aq] cheatpath:
+cheat \-p \f[I]work\f[] \-e \f[I]foo/bar\f[]
+.RS
+.RE
 .TP
-To view all cheatsheet directories:
+.B To view all cheatsheet directories:
 cheat \-d
+.RS
+.RE
 .TP
-To list all available cheatsheets:
+.B To list all available cheatsheets:
 cheat \-l
+.RS
+.RE
 .TP
-To briefly list all cheatsheets whose titles match `apt':
-cheat \-b \f[I]apt\f[R]
+.B To list all cheatsheets whose titles match \[aq]apt\[aq]:
+cheat \-l \f[I]apt\f[]
+.RS
+.RE
 .TP
-To list all tags in use:
+.B To list all tags in use:
 cheat \-T
+.RS
+.RE
 .TP
-To list available cheatsheets that are tagged as `personal':
-cheat \-l \-t \f[I]personal\f[R]
+.B To list available cheatsheets that are tagged as \[aq]personal\[aq]:
+cheat \-l \-t \f[I]personal\f[]
+.RS
+.RE
 .TP
-To search for `ssh' among all cheatsheets, and colorize matches:
-cheat \-c \-s \f[I]ssh\f[R]
+.B To search for \[aq]ssh\[aq] among all cheatsheets, and colorize matches:
+cheat \-c \-s \f[I]ssh\f[]
+.RS
+.RE
 .TP
-To search (by regex) for cheatsheets that contain an IP address:
-cheat \-c \-r \-s \f[I]`(?:[0\-9]{1,3}.){3}[0\-9]{1,3}'\f[R]
+.B To search (by regex) for cheatsheets that contain an IP address:
+cheat \-c \-r \-s \f[I]\[aq](?:[0\-9]{1,3}.){3}[0\-9]{1,3}\[aq]\f[]
+.RS
+.RE
 .TP
-To remove (delete) the foo/bar cheatsheet:
-cheat \[en]rm \f[I]foo/bar\f[R]
-.TP
-To view the configuration file path:
-cheat \[en]conf
+.B To remove (delete) the foo/bar cheatsheet:
+cheat \-\-rm \f[I]foo/bar\f[]
+.RS
+.RE
 .SH FILES
 .SS Configuration
-\f[B]cheat\f[R] is configured via a YAML file that is conventionally
-named \f[I]conf.yaml\f[R].
-\f[B]cheat\f[R] will search for \f[I]conf.yaml\f[R] in varying
-locations, depending upon your platform:
+.PP
+\f[B]cheat\f[] is configured via a YAML file that is conventionally
+named \f[I]conf.yaml\f[].
+\f[B]cheat\f[] will search for \f[I]conf.yaml\f[] in varying locations,
+depending upon your platform:
 .SS Linux, OSX, and other Unixes
 .IP "1." 3
-\f[B]CHEAT_CONFIG_PATH\f[R]
+\f[B]CHEAT_CONFIG_PATH\f[]
 .IP "2." 3
-\f[B]XDG_CONFIG_HOME\f[R]/cheat/conf.yaml
+\f[B]XDG_CONFIG_HOME\f[]/cheat/conf.yaml
 .IP "3." 3
-\f[B]$HOME\f[R]/.config/cheat/conf.yml
+\f[B]$HOME\f[]/.config/cheat/conf.yml
 .IP "4." 3
-\f[B]$HOME\f[R]/.cheat/conf.yml
+\f[B]$HOME\f[]/.cheat/conf.yml
 .SS Windows
 .IP "1." 3
-\f[B]CHEAT_CONFIG_PATH\f[R]
+\f[B]CHEAT_CONFIG_PATH\f[]
 .IP "2." 3
-\f[B]APPDATA\f[R]/cheat/conf.yml
+\f[B]APPDATA\f[]/cheat/conf.yml
 .IP "3." 3
-\f[B]PROGRAMDATA\f[R]/cheat/conf.yml
+\f[B]PROGRAMDATA\f[]/cheat/conf.yml
 .PP
-\f[B]cheat\f[R] will search in the order specified above.
-The first \f[I]conf.yaml\f[R] encountered will be respected.
+\f[B]cheat\f[] will search in the order specified above.
+The first \f[I]conf.yaml\f[] encountered will be respected.
 .PP
-If \f[B]cheat\f[R] cannot locate a config file, it will ask if you\[cq]d
+If \f[B]cheat\f[] cannot locate a config file, it will ask if you\[aq]d
 like to generate one automatically.
 Alternatively, you may also generate a config file manually by running
-\f[B]cheat \[en]init\f[R] and saving its output to the appropriate
+\f[B]cheat \-\-init\f[] and saving its output to the appropriate
 location for your platform.
 .SS Cheatpaths
-\f[B]cheat\f[R] reads its cheatsheets from \[lq]cheatpaths\[rq], which
-are the directories in which cheatsheets are stored.
-Cheatpaths may be configured in \f[I]conf.yaml\f[R], and viewed via
-\f[B]cheat \-d\f[R].
+.PP
+\f[B]cheat\f[] reads its cheatsheets from "cheatpaths", which are the
+directories in which cheatsheets are stored.
+Cheatpaths may be configured in \f[I]conf.yaml\f[], and viewed via
+\f[B]cheat \-d\f[].
 .PP
 For detailed instructions on how to configure cheatpaths, please refer
 to the comments in conf.yml.
 .SS Autocompletion
-Autocompletion scripts for \f[B]bash\f[R], \f[B]zsh\f[R], and
-\f[B]fish\f[R] are available for download:
-.IP \[bu] 2
-\c
-.UR https://github.com/cheat/cheat/blob/master/scripts/cheat.bash
-.UE \c
-.IP \[bu] 2
-\c
-.UR https://github.com/cheat/cheat/blob/master/scripts/cheat.fish
-.UE \c
-.IP \[bu] 2
-\c
-.UR https://github.com/cheat/cheat/blob/master/scripts/cheat.zsh
-.UE \c
 .PP
-The \f[B]bash\f[R] and \f[B]zsh\f[R] scripts provide optional
-integration with \f[B]fzf\f[R], if the latter is available on your
-\f[B]PATH\f[R].
+Autocompletion scripts for \f[B]bash\f[], \f[B]zsh\f[], and
+\f[B]fish\f[] are available for download:
+.IP \[bu] 2
+<https://github.com/cheat/cheat/blob/master/scripts/cheat.bash>
+.IP \[bu] 2
+<https://github.com/cheat/cheat/blob/master/scripts/cheat.fish>
+.IP \[bu] 2
+<https://github.com/cheat/cheat/blob/master/scripts/cheat.zsh>
+.PP
+The \f[B]bash\f[] and \f[B]zsh\f[] scripts provide optional integration
+with \f[B]fzf\f[], if the latter is available on your \f[B]PATH\f[].
 .PP
 The installation process will vary per system and shell configuration,
 and thus will not be discussed here.
 .SH ENVIRONMENT
 .TP
-\f[B]CHEAT_CONFIG_PATH\f[R]
+.B \f[B]CHEAT_CONFIG_PATH\f[]
 The path at which the config file is available.
-If \f[B]CHEAT_CONFIG_PATH\f[R] is set, all other config paths will be
+If \f[B]CHEAT_CONFIG_PATH\f[] is set, all other config paths will be
 ignored.
+.RS
+.RE
 .TP
-\f[B]CHEAT_USE_FZF\f[R]
+.B \f[B]CHEAT_USE_FZF\f[]
 If set, autocompletion scripts will attempt to integrate with
-\f[B]fzf\f[R].
+\f[B]fzf\f[].
+.RS
+.RE
 .SH RETURN VALUES
 .IP "0." 3
 Successful termination
@@ -174,12 +211,11 @@ Application error
 .IP "2." 3
 Cheatsheet(s) not found
 .SH BUGS
-See GitHub issues: \c
-.UR https://github.com/cheat/cheat/issues
-.UE \c
+.PP
+See GitHub issues: <https://github.com/cheat/cheat/issues>
 .SH AUTHOR
-Christopher Allen Lane \c
-.MT chris@chris-allen-lane.com
-.ME \c
+.PP
+Christopher Allen Lane <chris@chris-allen-lane.com>
 .SH SEE ALSO
-\f[B]fzf(1)\f[R]
+.PP
+\f[B]fzf(1)\f[]

doc/cheat.1.md

@@ -23,15 +23,6 @@ OPTIONS
 --init
 : Print a config file to stdout.
 
---conf
-: Display the config file path.
-
--a, --all
-: Search among all cheatpaths.
-
--b, --brief
-: List cheatsheets without file paths.
-
 -c, --colorize
 : Colorize output.
 
@@ -84,8 +75,8 @@ To view all cheatsheet directories:
 To list all available cheatsheets:
 : cheat -l
 
-To briefly list all cheatsheets whose titles match 'apt':
-: cheat -b _apt_
+To list all cheatsheets whose titles match 'apt':
+: cheat -l _apt_
 
 To list all tags in use:
 : cheat -T
@@ -102,9 +93,6 @@ To search (by regex) for cheatsheets that contain an IP address:
 To remove (delete) the foo/bar cheatsheet:
 : cheat --rm _foo/bar_
 
-To view the configuration file path:
-: cheat --conf
-
 
 FILES
 =====

go.mod

@@ -1,37 +1,17 @@
 module github.com/cheat/cheat
 
-go 1.26
+go 1.14
 
 require (
-	github.com/alecthomas/chroma/v2 v2.23.1
+	github.com/alecthomas/chroma v0.8.0
 	github.com/davecgh/go-spew v1.1.1
 	github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815
-	github.com/go-git/go-git/v5 v5.16.5
-	github.com/mattn/go-isatty v0.0.20
+	github.com/kr/text v0.2.0 // indirect
+	github.com/mattn/go-isatty v0.0.12
 	github.com/mitchellh/go-homedir v1.1.0
-	gopkg.in/yaml.v3 v3.0.1
-)
-
-require (
-	dario.cat/mergo v1.0.2 // indirect
-	github.com/Microsoft/go-winio v0.6.2 // indirect
-	github.com/ProtonMail/go-crypto v1.3.0 // indirect
-	github.com/cloudflare/circl v1.6.3 // indirect
-	github.com/cyphar/filepath-securejoin v0.6.1 // indirect
-	github.com/dlclark/regexp2 v1.11.5 // indirect
-	github.com/emirpasic/gods v1.18.1 // indirect
-	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
-	github.com/go-git/go-billy/v5 v5.7.0 // indirect
-	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
-	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
-	github.com/kevinburke/ssh_config v1.5.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
-	github.com/pjbgf/sha1cd v0.5.0 // indirect
-	github.com/sergi/go-diff v1.4.0 // indirect
-	github.com/skeema/knownhosts v1.3.2 // indirect
-	github.com/xanzy/ssh-agent v0.3.3 // indirect
-	golang.org/x/crypto v0.48.0 // indirect
-	golang.org/x/net v0.50.0 // indirect
-	golang.org/x/sys v0.41.0 // indirect
-	gopkg.in/warnings.v0 v0.1.2 // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/sergi/go-diff v1.1.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+	gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0
+	gopkg.in/yaml.v2 v2.3.0
 )

go.sum

@@ -1,121 +1,64 @@
-dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
-dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
-github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
-github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
-github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
-github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBiRGFrw=
-github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE=
-github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
-github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
-github.com/alecthomas/chroma/v2 v2.23.1 h1:nv2AVZdTyClGbVQkIzlDm/rnhk1E9bU9nXwmZ/Vk/iY=
-github.com/alecthomas/chroma/v2 v2.23.1/go.mod h1:NqVhfBR0lte5Ouh3DcthuUCTUpDC9cxBOfyMbMQPs3o=
-github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
-github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
-github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
-github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
-github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
-github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8=
-github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4=
-github.com/cyphar/filepath-securejoin v0.6.1 h1:5CeZ1jPXEiYt3+Z6zqprSAgSWiggmpVyciv8syjIpVE=
-github.com/cyphar/filepath-securejoin v0.6.1/go.mod h1:A8hd4EnAeyujCJRrICiOWqjS1AX0a9kM5XL+NwKoYSc=
+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.8.0 h1:HS+HE97sgcqjQGu5uVr8jIE55Mmh5UeQ7kckAhHg2pY=
+github.com/alecthomas/chroma v0.8.0/go.mod h1:sko8vR34/90zvl5QdcUdvzL3J8NKjAUx9va9jPuFNoM=
+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.2.4/go.mod h1:kQOmtJgV+Lb4aj+I2LEn40cbtawdWJ9Y8QLq+lElKxE=
+github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897 h1:p9Sln00KOTlrYkxI1zYWl1QLnEqAqEARBEYa8FQnQcY=
+github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897/go.mod h1:xTS7Pm1pD1mvyM075QCDSRqH6qRLXylzS24ZTpRiSzQ=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964 h1:y5HC9v93H5EPKqaS1UYVg1uYah5Xf51mBfIoWehClUQ=
+github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964/go.mod h1:Xd9hchkHSWYkEqJwUGisez3G1QY8Ryz0sdWrLPMGjLk=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
-github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dlclark/regexp2 v1.2.0 h1:8sAhBGEM0dRWogWqWyQeIJnxjWO6oIjl8FKqREDsGfk=
+github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh6AyO7hdCn/PkvCZXii8TGj7sbtEbQ=
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
-github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
-github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
-github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
-github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
-github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
-github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
-github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
-github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
-github.com/go-git/go-billy/v5 v5.7.0 h1:83lBUJhGWhYp0ngzCMSgllhUSuoHP1iEWYjsPl9nwqM=
-github.com/go-git/go-billy/v5 v5.7.0/go.mod h1:/1IUejTKH8xipsAcdfcSAlUlo2J7lkYV8GTKxAT/L3E=
-github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
-github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
-github.com/go-git/go-git/v5 v5.16.5 h1:mdkuqblwr57kVfXri5TTH+nMFLNUxIj9Z7F5ykFbw5s=
-github.com/go-git/go-git/v5 v5.16.5/go.mod h1:QOMLpNf1qxuSY4StA/ArOdfFR2TrKEjJiye2kel2m+M=
-github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
-github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
-github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
-github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
-github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
-github.com/kevinburke/ssh_config v1.5.0 h1:3cPZmE54xb5j3G5xQCjSvokqNwU2uW+3ry1+PRLSPpA=
-github.com/kevinburke/ssh_config v1.5.0/go.mod h1:q2RIzfka+BXARoNexmF9gkxEX7DmvbW9P4hIVx2Kg4M=
-github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
-github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
-github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
-github.com/pjbgf/sha1cd v0.5.0 h1:a+UkboSi1znleCDUNT3M5YxjOnN1fz2FhN48FlwCxs0=
-github.com/pjbgf/sha1cd v0.5.0/go.mod h1:lhpGlyHLpQZoxMv8HcgXvZEhcGs0PG/vsZnEJ7H0iCM=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw=
-github.com/sergi/go-diff v1.4.0/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
-github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/skeema/knownhosts v1.3.2 h1:EDL9mgf4NzwMXCTfaxSD/o/a5fxDw/xL9nkU28JjdBg=
-github.com/skeema/knownhosts v1.3.2/go.mod h1:bEg3iQAuw+jyiw+484wwFJoKSLwcfd7fqRy+N0QTiow=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
+github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 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/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
-github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
-golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
-golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
-golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
-golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.40.0 h1:36e4zGLqU4yhjlmxEaagx2KuYbJq3EwY8K943ZsHcvg=
-golang.org/x/term v0.40.0/go.mod h1:w2P8uVp06p2iyKKuvXIm7N/y0UCRt3UfJTfZ7oOpglM=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
-golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200413165638-669c56c373c4 h1:opSr2sbRXk5X5/givKrrKj9HXxFpW2sdCiP8MJSKLQY=
+golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
-gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/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.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

internal/cheatpath/cheatpath.go

@@ -1,9 +1,7 @@
-// Package cheatpath implements functions pertaining to cheatsheet file path
-// management.
 package cheatpath
 
-// Path encapsulates cheatsheet path information
-type Path struct {
+// Cheatpath encapsulates cheatsheet path information
+type Cheatpath struct {
 	Name     string   `yaml:"name"`
 	Path     string   `yaml:"path"`
 	ReadOnly bool     `yaml:"readonly"`

internal/cheatpath/cheatpath_test.go

@@ -1,90 +0,0 @@
-package cheatpath
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestCheatpathValidate(t *testing.T) {
-	tests := []struct {
-		name      string
-		cheatpath Path
-		wantErr   bool
-		errMsg    string
-	}{
-		{
-			name: "valid cheatpath",
-			cheatpath: Path{
-				Name:     "personal",
-				Path:     "/home/user/.config/cheat/personal",
-				ReadOnly: false,
-				Tags:     []string{"personal"},
-			},
-			wantErr: false,
-		},
-		{
-			name: "empty name",
-			cheatpath: Path{
-				Name:     "",
-				Path:     "/home/user/.config/cheat/personal",
-				ReadOnly: false,
-				Tags:     []string{"personal"},
-			},
-			wantErr: true,
-			errMsg:  "cheatpath name cannot be empty",
-		},
-		{
-			name: "empty path",
-			cheatpath: Path{
-				Name:     "personal",
-				Path:     "",
-				ReadOnly: false,
-				Tags:     []string{"personal"},
-			},
-			wantErr: true,
-			errMsg:  "cheatpath path cannot be empty",
-		},
-		{
-			name: "both empty",
-			cheatpath: Path{
-				Name:     "",
-				Path:     "",
-				ReadOnly: true,
-				Tags:     nil,
-			},
-			wantErr: true,
-			errMsg:  "cheatpath name cannot be empty",
-		},
-		{
-			name: "minimal valid",
-			cheatpath: Path{
-				Name: "x",
-				Path: "/",
-			},
-			wantErr: false,
-		},
-		{
-			name: "with readonly and tags",
-			cheatpath: Path{
-				Name:     "community",
-				Path:     "/usr/share/cheat",
-				ReadOnly: true,
-				Tags:     []string{"community", "shared", "readonly"},
-			},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := tt.cheatpath.Validate()
-			if (err != nil) != tt.wantErr {
-				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if err != nil && tt.errMsg != "" && !strings.Contains(err.Error(), tt.errMsg) {
-				t.Errorf("Validate() error = %v, want error containing %q", err, tt.errMsg)
-			}
-		})
-	}
-}

internal/cheatpath/filter.go

@@ -5,15 +5,15 @@ import (
 )
 
 // Filter filters all cheatpaths that are not named `name`
-func Filter(paths []Path, name string) ([]Path, error) {
+func Filter(paths []Cheatpath, name string) ([]Cheatpath, error) {
 
 	// if a path of the given name exists, return it
 	for _, path := range paths {
 		if path.Name == name {
-			return []Path{path}, nil
+			return []Cheatpath{path}, nil
 		}
 	}
 
 	// otherwise, return an error
-	return []Path{}, fmt.Errorf("cheatpath does not exist: %s", name)
+	return []Cheatpath{}, fmt.Errorf("cheatpath does not exist: %s", name)
 }

internal/cheatpath/filter_test.go

@@ -9,10 +9,10 @@ import (
 func TestFilterSuccess(t *testing.T) {
 
 	// init cheatpaths
-	paths := []Path{
-		Path{Name: "foo"},
-		Path{Name: "bar"},
-		Path{Name: "baz"},
+	paths := []Cheatpath{
+		Cheatpath{Name: "foo"},
+		Cheatpath{Name: "bar"},
+		Cheatpath{Name: "baz"},
 	}
 
 	// filter the paths
@@ -39,14 +39,14 @@ func TestFilterSuccess(t *testing.T) {
 func TestFilterFailure(t *testing.T) {
 
 	// init cheatpaths
-	paths := []Path{
-		Path{Name: "foo"},
-		Path{Name: "bar"},
-		Path{Name: "baz"},
+	paths := []Cheatpath{
+		Cheatpath{Name: "foo"},
+		Cheatpath{Name: "bar"},
+		Cheatpath{Name: "baz"},
 	}
 
 	// filter the paths
-	_, err := Filter(paths, "qux")
+	paths, err := Filter(paths, "qux")
 	if err == nil {
 		t.Errorf("failed to return an error on non-existent cheatpath")
 	}

internal/cheatpath/validate.go

@@ -4,13 +4,15 @@ import (
 	"fmt"
 )
 
-// Validate ensures that the Path is valid
-func (c Path) Validate() error {
+// Validate returns an error if the cheatpath is invalid
+func (c *Cheatpath) Validate() error {
+
 	if c.Name == "" {
-		return fmt.Errorf("cheatpath name cannot be empty")
+		return fmt.Errorf("invalid cheatpath: name must be specified")
 	}
 	if c.Path == "" {
-		return fmt.Errorf("cheatpath path cannot be empty")
+		return fmt.Errorf("invalid cheatpath: path must be specified")
 	}
+
 	return nil
 }

internal/cheatpath/validate_test.go

@@ -0,0 +1,56 @@
+package cheatpath
+
+import (
+	"testing"
+)
+
+// TestValidateValid asserts that valid cheatpaths validate successfully
+func TestValidateValid(t *testing.T) {
+
+	// initialize a valid cheatpath
+	cheatpath := Cheatpath{
+		Name:     "foo",
+		Path:     "/foo",
+		ReadOnly: false,
+		Tags:     []string{},
+	}
+
+	// assert that no errors are returned
+	if err := cheatpath.Validate(); err != nil {
+		t.Errorf("failed to validate valid cheatpath: %v", err)
+	}
+}
+
+// TestValidateMissingName asserts that paths that are missing a name fail to
+// validate
+func TestValidateMissingName(t *testing.T) {
+
+	// initialize a valid cheatpath
+	cheatpath := Cheatpath{
+		Path:     "/foo",
+		ReadOnly: false,
+		Tags:     []string{},
+	}
+
+	// assert that no errors are returned
+	if err := cheatpath.Validate(); err == nil {
+		t.Errorf("failed to invalidate cheatpath without name")
+	}
+}
+
+// TestValidateMissingPath asserts that paths that are missing a path fail to
+// validate
+func TestValidateMissingPath(t *testing.T) {
+
+	// initialize a valid cheatpath
+	cheatpath := Cheatpath{
+		Name:     "foo",
+		ReadOnly: false,
+		Tags:     []string{},
+	}
+
+	// assert that no errors are returned
+	if err := cheatpath.Validate(); err == nil {
+		t.Errorf("failed to invalidate cheatpath without path")
+	}
+}

internal/cheatpath/writeable.go

@@ -4,19 +4,21 @@ import (
 	"fmt"
 )
 
-// Writeable returns a writeable Path
-func Writeable(cheatpaths []Path) (Path, error) {
+// Writeable returns a writeable Cheatpath
+func Writeable(cheatpaths []Cheatpath) (Cheatpath, error) {
 
 	// iterate backwards over the cheatpaths
 	// NB: we're going backwards because we assume that the most "local"
 	// cheatpath will be specified last in the configs
 	for i := len(cheatpaths) - 1; i >= 0; i-- {
+
 		// if the cheatpath is not read-only, it is writeable, and thus returned
-		if !cheatpaths[i].ReadOnly {
+		if cheatpaths[i].ReadOnly == false {
 			return cheatpaths[i], nil
 		}
+
 	}
 
 	// otherwise, return an error
-	return Path{}, fmt.Errorf("no writeable cheatpaths found")
+	return Cheatpath{}, fmt.Errorf("no writeable cheatpaths found")
 }

internal/cheatpath/writeable_test.go

@@ -9,10 +9,10 @@ import (
 func TestWriteableOK(t *testing.T) {
 
 	// initialize some cheatpaths
-	cheatpaths := []Path{
-		Path{Path: "/foo", ReadOnly: true},
-		Path{Path: "/bar", ReadOnly: false},
-		Path{Path: "/baz", ReadOnly: true},
+	cheatpaths := []Cheatpath{
+		Cheatpath{Path: "/foo", ReadOnly: true},
+		Cheatpath{Path: "/bar", ReadOnly: false},
+		Cheatpath{Path: "/baz", ReadOnly: true},
 	}
 
 	// get the writeable cheatpath
@@ -34,10 +34,10 @@ func TestWriteableOK(t *testing.T) {
 func TestWriteableNotOK(t *testing.T) {
 
 	// initialize some cheatpaths
-	cheatpaths := []Path{
-		Path{Path: "/foo", ReadOnly: true},
-		Path{Path: "/bar", ReadOnly: true},
-		Path{Path: "/baz", ReadOnly: true},
+	cheatpaths := []Cheatpath{
+		Cheatpath{Path: "/foo", ReadOnly: true},
+		Cheatpath{Path: "/bar", ReadOnly: true},
+		Cheatpath{Path: "/baz", ReadOnly: true},
 	}
 
 	// get the writeable cheatpath

internal/config/color_test.go

@@ -1,22 +0,0 @@
-package config
-
-import (
-	"testing"
-)
-
-// TestColor asserts that colorization rules are properly respected
-func TestColor(t *testing.T) {
-
-	// mock a config
-	conf := Config{}
-
-	opts := map[string]interface{}{"--colorize": false}
-	if conf.Color(opts) {
-		t.Errorf("failed to respect --colorize (false)")
-	}
-
-	opts = map[string]interface{}{"--colorize": true}
-	if !conf.Color(opts) {
-		t.Errorf("failed to respect --colorize (true)")
-	}
-}

internal/config/config.go

@@ -1,17 +1,122 @@
-// Package config implements functions pertaining to configuration management.
 package config
 
 import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
 	cp "github.com/cheat/cheat/internal/cheatpath"
+
+	"github.com/mitchellh/go-homedir"
+	"gopkg.in/yaml.v2"
 )
 
 // Config encapsulates configuration parameters
 type Config struct {
 	Colorize   bool           `yaml:"colorize"`
 	Editor     string         `yaml:"editor"`
-	Cheatpaths []cp.Path `yaml:"cheatpaths"`
+	Cheatpaths []cp.Cheatpath `yaml:"cheatpaths"`
 	Style      string         `yaml:"style"`
 	Formatter  string         `yaml:"formatter"`
 	Pager      string         `yaml:"pager"`
-	Path       string
+}
+
+// New returns a new Config struct
+func New(opts map[string]interface{}, confPath string, resolve bool) (Config, error) {
+
+	// read the config file
+	buf, err := ioutil.ReadFile(confPath)
+	if err != nil {
+		return Config{}, fmt.Errorf("could not read config file: %v", err)
+	}
+
+	// initialize a config object
+	conf := Config{}
+
+	// unmarshal the yaml
+	err = yaml.UnmarshalStrict(buf, &conf)
+	if err != nil {
+		return Config{}, fmt.Errorf("could not unmarshal yaml: %v", err)
+	}
+
+	// if a .cheat directory exists locally, append it to the cheatpaths
+	cwd, err := os.Getwd()
+	if err != nil {
+		return Config{}, fmt.Errorf("failed to get cwd: %v", err)
+	}
+
+	local := filepath.Join(cwd, ".cheat")
+	if _, err := os.Stat(local); err == nil {
+		path := cp.Cheatpath{
+			Name:     "cwd",
+			Path:     local,
+			ReadOnly: false,
+			Tags:     []string{},
+		}
+
+		conf.Cheatpaths = append(conf.Cheatpaths, path)
+	}
+
+	// process cheatpaths
+	for i, cheatpath := range conf.Cheatpaths {
+
+		// expand ~ in config paths
+		expanded, err := homedir.Expand(cheatpath.Path)
+		if err != nil {
+			return Config{}, fmt.Errorf("failed to expand ~: %v", err)
+		}
+
+		// 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 {
+			evaled, err := filepath.EvalSymlinks(expanded)
+			if err != nil {
+				return Config{}, fmt.Errorf(
+					"failed to resolve symlink: %s: %v",
+					expanded,
+					err,
+				)
+			}
+
+			expanded = evaled
+		}
+
+		conf.Cheatpaths[i].Path = expanded
+	}
+
+	// if an editor was not provided in the configs, look to envvars
+	if conf.Editor == "" {
+		if os.Getenv("VISUAL") != "" {
+			conf.Editor = os.Getenv("VISUAL")
+		} else if os.Getenv("EDITOR") != "" {
+			conf.Editor = os.Getenv("EDITOR")
+		} else {
+			return Config{}, fmt.Errorf("no editor set")
+		}
+	}
+
+	// if a chroma style was not provided, set a default
+	if conf.Style == "" {
+		conf.Style = "bw"
+	}
+
+	// if a chroma formatter was not provided, set a default
+	if conf.Formatter == "" {
+		conf.Formatter = "terminal16m"
+	}
+
+	// if a pager was not provided, set a default
+	if strings.TrimSpace(conf.Pager) == "" {
+		conf.Pager = ""
+	}
+
+	return conf, nil
 }

internal/config/config_extended_test.go

@@ -1,148 +0,0 @@
-package config
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/cheat/cheat/mocks"
-)
-
-// TestConfigYAMLErrors tests YAML parsing errors
-func TestConfigYAMLErrors(t *testing.T) {
-	// Create a temporary file with invalid YAML
-	tempDir, err := os.MkdirTemp("", "cheat-config-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	invalidYAML := filepath.Join(tempDir, "invalid.yml")
-	err = os.WriteFile(invalidYAML, []byte("cheatpaths: [{unclosed\n"), 0644)
-	if err != nil {
-		t.Fatalf("failed to write invalid yaml: %v", err)
-	}
-
-	// Attempt to load invalid YAML
-	_, err = New(invalidYAML, false)
-	if err == nil {
-		t.Error("expected error for invalid YAML, got nil")
-	}
-}
-
-// TestConfigDefaults tests default values
-func TestConfigDefaults(t *testing.T) {
-	// Load empty config
-	conf, err := New(mocks.Path("conf/empty.yml"), false)
-	if err != nil {
-		t.Errorf("failed to load config: %v", err)
-	}
-
-	// Check defaults
-	if conf.Style != "bw" {
-		t.Errorf("expected default style 'bw', got %s", conf.Style)
-	}
-
-	if conf.Formatter != "terminal" {
-		t.Errorf("expected default formatter 'terminal', got %s", conf.Formatter)
-	}
-}
-
-// TestConfigSymlinkResolution tests symlink resolution
-func TestConfigSymlinkResolution(t *testing.T) {
-	// Create temp directory structure
-	tempDir, err := os.MkdirTemp("", "cheat-config-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Resolve symlinks in temp dir path (macOS /var -> /private/var)
-	tempDir, err = filepath.EvalSymlinks(tempDir)
-	if err != nil {
-		t.Fatalf("failed to resolve temp dir symlinks: %v", err)
-	}
-
-	// Create target directory
-	targetDir := filepath.Join(tempDir, "target")
-	err = os.Mkdir(targetDir, 0755)
-	if err != nil {
-		t.Fatalf("failed to create target dir: %v", err)
-	}
-
-	// Create symlink
-	linkPath := filepath.Join(tempDir, "link")
-	err = os.Symlink(targetDir, linkPath)
-	if err != nil {
-		t.Fatalf("failed to create symlink: %v", err)
-	}
-
-	// Create config with symlink path
-	configContent := `---
-editor: vim
-cheatpaths:
-  - name: test
-    path: ` + linkPath + `
-    readonly: true
-`
-	configFile := filepath.Join(tempDir, "config.yml")
-	err = os.WriteFile(configFile, []byte(configContent), 0644)
-	if err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	// Load config with symlink resolution
-	conf, err := New(configFile, true)
-	if err != nil {
-		t.Errorf("failed to load config: %v", err)
-	}
-
-	// Verify symlink was resolved
-	if len(conf.Cheatpaths) == 0 {
-		t.Fatal("expected at least one cheatpath, got none")
-	}
-	if conf.Cheatpaths[0].Path != targetDir {
-		t.Errorf("expected symlink to be resolved to %s, got %s", targetDir, conf.Cheatpaths[0].Path)
-	}
-}
-
-// TestConfigBrokenSymlink tests broken symlink handling
-func TestConfigBrokenSymlink(t *testing.T) {
-	// Create temp directory
-	tempDir, err := os.MkdirTemp("", "cheat-config-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Create broken symlink
-	linkPath := filepath.Join(tempDir, "broken-link")
-	err = os.Symlink("/nonexistent/path", linkPath)
-	if err != nil {
-		t.Fatalf("failed to create symlink: %v", err)
-	}
-
-	// Create config with broken symlink
-	configContent := `---
-editor: vim
-cheatpaths:
-  - name: test
-    path: ` + linkPath + `
-    readonly: true
-`
-	configFile := filepath.Join(tempDir, "config.yml")
-	err = os.WriteFile(configFile, []byte(configContent), 0644)
-	if err != nil {
-		t.Fatalf("failed to write config: %v", err)
-	}
-
-	// Load config with symlink resolution should skip the broken cheatpath
-	// (warn to stderr) rather than hard-error
-	conf, err := New(configFile, true)
-	if err != nil {
-		t.Errorf("expected no error for broken symlink (should skip), got: %v", err)
-	}
-	if len(conf.Cheatpaths) != 0 {
-		t.Errorf("expected broken cheatpath to be filtered out, got %d cheatpaths", len(conf.Cheatpaths))
-	}
-}

internal/config/config_fuzz_test.go

@@ -1,67 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// FuzzFindLocalCheatpath exercises findLocalCheatpath with randomised
-// directory depths and .cheat placements.  For each fuzz input it builds a
-// temporary directory hierarchy, places a single .cheat directory at a
-// computed level, and asserts that the function always returns it.
-func FuzzFindLocalCheatpath(f *testing.F) {
-	// Seed corpus: (totalDepth, cheatPlacement)
-	f.Add(uint8(1), uint8(0))  // depth 1, .cheat at root
-	f.Add(uint8(3), uint8(0))  // depth 3, .cheat at root
-	f.Add(uint8(5), uint8(3))  // depth 5, .cheat at level 3
-	f.Add(uint8(1), uint8(1))  // depth 1, .cheat at same level as search dir
-	f.Add(uint8(10), uint8(5)) // deep hierarchy
-
-	f.Fuzz(func(t *testing.T, totalDepth uint8, cheatPlacement uint8) {
-		// Clamp to reasonable values to keep I/O bounded
-		depth := int(totalDepth%15) + 1              // 1..15
-		cheatAt := int(cheatPlacement) % (depth + 1) // 0..depth (0 = tempDir itself)
-
-		tempDir := t.TempDir()
-
-		// Build chain: tempDir/d0/d1/…/d{depth-1}
-		dirs := make([]string, 0, depth+1)
-		dirs = append(dirs, tempDir)
-		current := tempDir
-		for i := 0; i < depth; i++ {
-			current = filepath.Join(current, fmt.Sprintf("d%d", i))
-			if err := os.Mkdir(current, 0755); err != nil {
-				t.Fatalf("mkdir: %v", err)
-			}
-			dirs = append(dirs, current)
-		}
-
-		// Place .cheat at dirs[cheatAt]
-		cheatDir := filepath.Join(dirs[cheatAt], ".cheat")
-		if err := os.Mkdir(cheatDir, 0755); err != nil {
-			t.Fatalf("mkdir .cheat: %v", err)
-		}
-
-		// Search from the deepest directory
-		result := findLocalCheatpath(current)
-
-		// Invariant 1: must find the .cheat we placed
-		if result != cheatDir {
-			t.Errorf("depth=%d cheatAt=%d: expected %s, got %s",
-				depth, cheatAt, cheatDir, result)
-		}
-
-		// Invariant 2: result must end with /.cheat
-		if !strings.HasSuffix(result, string(filepath.Separator)+".cheat") {
-			t.Errorf("result %q does not end with /.cheat", result)
-		}
-
-		// Invariant 3: result must be under tempDir
-		if !strings.HasPrefix(result, tempDir) {
-			t.Errorf("result %q is not under tempDir %s", result, tempDir)
-		}
-	})
-}

internal/config/config_test.go

@@ -4,289 +4,20 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
-	"runtime"
 	"testing"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/mitchellh/go-homedir"
 
 	"github.com/cheat/cheat/internal/cheatpath"
-	"github.com/cheat/cheat/mocks"
+	"github.com/cheat/cheat/internal/mock"
 )
 
-// TestFindLocalCheatpathInCurrentDir tests that .cheat in the given dir is found
-func TestFindLocalCheatpathInCurrentDir(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "cheat-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	cheatDir := filepath.Join(tempDir, ".cheat")
-	if err := os.Mkdir(cheatDir, 0755); err != nil {
-		t.Fatalf("failed to create .cheat dir: %v", err)
-	}
-
-	result := findLocalCheatpath(tempDir)
-	if result != cheatDir {
-		t.Errorf("expected %s, got %s", cheatDir, result)
-	}
-}
-
-// TestFindLocalCheatpathInParent tests walking up to a parent directory
-func TestFindLocalCheatpathInParent(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "cheat-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	cheatDir := filepath.Join(tempDir, ".cheat")
-	if err := os.Mkdir(cheatDir, 0755); err != nil {
-		t.Fatalf("failed to create .cheat dir: %v", err)
-	}
-
-	subDir := filepath.Join(tempDir, "sub")
-	if err := os.Mkdir(subDir, 0755); err != nil {
-		t.Fatalf("failed to create sub dir: %v", err)
-	}
-
-	result := findLocalCheatpath(subDir)
-	if result != cheatDir {
-		t.Errorf("expected %s, got %s", cheatDir, result)
-	}
-}
-
-// TestFindLocalCheatpathInGrandparent tests walking up multiple levels
-func TestFindLocalCheatpathInGrandparent(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "cheat-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	cheatDir := filepath.Join(tempDir, ".cheat")
-	if err := os.Mkdir(cheatDir, 0755); err != nil {
-		t.Fatalf("failed to create .cheat dir: %v", err)
-	}
-
-	deepDir := filepath.Join(tempDir, "a", "b", "c")
-	if err := os.MkdirAll(deepDir, 0755); err != nil {
-		t.Fatalf("failed to create deep dir: %v", err)
-	}
-
-	result := findLocalCheatpath(deepDir)
-	if result != cheatDir {
-		t.Errorf("expected %s, got %s", cheatDir, result)
-	}
-}
-
-// TestFindLocalCheatpathNearestWins tests that the closest .cheat is returned
-func TestFindLocalCheatpathNearestWins(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "cheat-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Create .cheat at root level
-	if err := os.Mkdir(filepath.Join(tempDir, ".cheat"), 0755); err != nil {
-		t.Fatalf("failed to create root .cheat dir: %v", err)
-	}
-
-	// Create sub/.cheat (the nearer one)
-	subDir := filepath.Join(tempDir, "sub")
-	if err := os.Mkdir(subDir, 0755); err != nil {
-		t.Fatalf("failed to create sub dir: %v", err)
-	}
-	nearCheatDir := filepath.Join(subDir, ".cheat")
-	if err := os.Mkdir(nearCheatDir, 0755); err != nil {
-		t.Fatalf("failed to create sub .cheat dir: %v", err)
-	}
-
-	// Search from sub/deep/
-	deepDir := filepath.Join(subDir, "deep")
-	if err := os.Mkdir(deepDir, 0755); err != nil {
-		t.Fatalf("failed to create deep dir: %v", err)
-	}
-
-	result := findLocalCheatpath(deepDir)
-	if result != nearCheatDir {
-		t.Errorf("expected nearest %s, got %s", nearCheatDir, result)
-	}
-}
-
-// TestFindLocalCheatpathNotFound tests that empty string is returned when no .cheat exists
-func TestFindLocalCheatpathNotFound(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "cheat-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	result := findLocalCheatpath(tempDir)
-	if result != "" {
-		t.Errorf("expected empty string, got %s", result)
-	}
-}
-
-// TestFindLocalCheatpathSkipsFile tests that a file named .cheat is not matched
-func TestFindLocalCheatpathSkipsFile(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "cheat-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Create .cheat as a file, not a directory
-	cheatFile := filepath.Join(tempDir, ".cheat")
-	if err := os.WriteFile(cheatFile, []byte("not a directory"), 0644); err != nil {
-		t.Fatalf("failed to create .cheat file: %v", err)
-	}
-
-	result := findLocalCheatpath(tempDir)
-	if result != "" {
-		t.Errorf("expected empty string for .cheat file, got %s", result)
-	}
-}
-
-// TestFindLocalCheatpathSymlink tests that a .cheat symlink to a directory is found
-func TestFindLocalCheatpathSymlink(t *testing.T) {
-	tempDir := t.TempDir()
-
-	// Create the real directory
-	realDir := filepath.Join(tempDir, "real-cheat")
-	if err := os.Mkdir(realDir, 0755); err != nil {
-		t.Fatalf("failed to create real dir: %v", err)
-	}
-
-	// Symlink .cheat -> real-cheat
-	cheatLink := filepath.Join(tempDir, ".cheat")
-	if err := os.Symlink(realDir, cheatLink); err != nil {
-		t.Fatalf("failed to create symlink: %v", err)
-	}
-
-	result := findLocalCheatpath(tempDir)
-	if result != cheatLink {
-		t.Errorf("expected %s, got %s", cheatLink, result)
-	}
-}
-
-// TestFindLocalCheatpathSymlinkInAncestor tests discovery through a symlinked
-// ancestor directory. When the cwd is reached via a symlink, filepath.Dir
-// walks the symlinked path (not the real path), so .cheat must be findable
-// through that chain.
-func TestFindLocalCheatpathSymlinkInAncestor(t *testing.T) {
-	tempDir := t.TempDir()
-
-	// Create real/project/.cheat
-	realProject := filepath.Join(tempDir, "real", "project")
-	if err := os.MkdirAll(realProject, 0755); err != nil {
-		t.Fatalf("failed to create real project dir: %v", err)
-	}
-	if err := os.Mkdir(filepath.Join(realProject, ".cheat"), 0755); err != nil {
-		t.Fatalf("failed to create .cheat dir: %v", err)
-	}
-
-	// Create symlink: linked -> real/project
-	linkedProject := filepath.Join(tempDir, "linked")
-	if err := os.Symlink(realProject, linkedProject); err != nil {
-		t.Fatalf("failed to create symlink: %v", err)
-	}
-
-	// Create sub inside the symlinked path
-	subDir := filepath.Join(linkedProject, "sub")
-	if err := os.Mkdir(subDir, 0755); err != nil {
-		t.Fatalf("failed to create sub dir: %v", err)
-	}
-
-	// Search from linked/sub — should find linked/.cheat
-	// (os.Stat follows symlinks, so linked/.cheat resolves to real/project/.cheat)
-	result := findLocalCheatpath(subDir)
-	expected := filepath.Join(linkedProject, ".cheat")
-	if result != expected {
-		t.Errorf("expected %s, got %s", expected, result)
-	}
-}
-
-// TestFindLocalCheatpathPermissionDenied tests that unreadable ancestor
-// directories are skipped and the walk continues upward.
-func TestFindLocalCheatpathPermissionDenied(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("Unix permissions do not apply on Windows")
-	}
-	if os.Getuid() == 0 {
-		t.Skip("test requires non-root user")
-	}
-
-	tempDir := t.TempDir()
-
-	// Resolve symlinks (macOS /var -> /private/var)
-	tempDir, err := filepath.EvalSymlinks(tempDir)
-	if err != nil {
-		t.Fatalf("failed to resolve symlinks: %v", err)
-	}
-
-	// Create tempDir/.cheat (the target we want found)
-	cheatDir := filepath.Join(tempDir, ".cheat")
-	if err := os.Mkdir(cheatDir, 0755); err != nil {
-		t.Fatalf("failed to create .cheat dir: %v", err)
-	}
-
-	// Create tempDir/restricted/ with its own .cheat and sub/
-	restricted := filepath.Join(tempDir, "restricted")
-	if err := os.Mkdir(restricted, 0755); err != nil {
-		t.Fatalf("failed to create restricted dir: %v", err)
-	}
-	if err := os.Mkdir(filepath.Join(restricted, ".cheat"), 0755); err != nil {
-		t.Fatalf("failed to create restricted .cheat dir: %v", err)
-	}
-	subDir := filepath.Join(restricted, "sub")
-	if err := os.Mkdir(subDir, 0755); err != nil {
-		t.Fatalf("failed to create sub dir: %v", err)
-	}
-
-	// Make restricted/ unreadable — blocks stat of children
-	if err := os.Chmod(restricted, 0000); err != nil {
-		t.Fatalf("failed to chmod: %v", err)
-	}
-	t.Cleanup(func() { os.Chmod(restricted, 0755) })
-
-	// Walk from restricted/sub: stat("restricted/sub/.cheat") fails (EACCES),
-	// stat("restricted/.cheat") fails (EACCES), walk continues to tempDir/.cheat
-	result := findLocalCheatpath(subDir)
-	if result != cheatDir {
-		t.Errorf("expected %s (walked past restricted dir), got %s", cheatDir, result)
-	}
-}
-
 // TestConfig asserts that the configs are loaded correctly
 func TestConfigSuccessful(t *testing.T) {
 
-	// Chdir into a temp directory so no ancestor .cheat directory can
-	// leak into the cheatpaths (findLocalCheatpath walks the full
-	// ancestor chain).
-	oldCwd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("failed to get cwd: %v", err)
-	}
-	defer os.Chdir(oldCwd)
-	if err := os.Chdir(t.TempDir()); err != nil {
-		t.Fatalf("failed to chdir: %v", err)
-	}
-
-	// clear env vars so they don't override the config file value
-	oldVisual := os.Getenv("VISUAL")
-	oldEditor := os.Getenv("EDITOR")
-	os.Unsetenv("VISUAL")
-	os.Unsetenv("EDITOR")
-	defer func() {
-		os.Setenv("VISUAL", oldVisual)
-		os.Setenv("EDITOR", oldEditor)
-	}()
-
 	// initialize a config
-	conf, err := New(mocks.Path("conf/conf.yml"), false)
+	conf, err := New(map[string]interface{}{}, mock.Path("conf/conf.yml"), false)
 	if err != nil {
 		t.Errorf("failed to parse config file: %v", err)
 	}
@@ -306,19 +37,19 @@ func TestConfigSuccessful(t *testing.T) {
 	}
 
 	// assert that the cheatpaths are correct
-	want := []cheatpath.Path{
-		cheatpath.Path{
-			Path:     filepath.Join(home, ".dotfiles", "cheat", "community"),
+	want := []cheatpath.Cheatpath{
+		cheatpath.Cheatpath{
+			Path:     filepath.Join(home, ".dotfiles/cheat/community"),
 			ReadOnly: true,
 			Tags:     []string{"community"},
 		},
-		cheatpath.Path{
-			Path:     filepath.Join(home, ".dotfiles", "cheat", "work"),
+		cheatpath.Cheatpath{
+			Path:     filepath.Join(home, ".dotfiles/cheat/work"),
 			ReadOnly: false,
 			Tags:     []string{"work"},
 		},
-		cheatpath.Path{
-			Path:     filepath.Join(home, ".dotfiles", "cheat", "personal"),
+		cheatpath.Cheatpath{
+			Path:     filepath.Join(home, ".dotfiles/cheat/personal"),
 			ReadOnly: false,
 			Tags:     []string{"personal"},
 		},
@@ -338,84 +69,43 @@ func TestConfigSuccessful(t *testing.T) {
 func TestConfigFailure(t *testing.T) {
 
 	// attempt to read a non-existent config file
-	_, err := New("/does-not-exit", false)
+	_, err := New(map[string]interface{}{}, "/does-not-exit", false)
 	if err == nil {
 		t.Errorf("failed to error on unreadable config")
 	}
 }
 
-// TestEditorEnvOverride asserts that $VISUAL and $EDITOR override the
-// config file value at runtime (regression test for #589)
-func TestEditorEnvOverride(t *testing.T) {
-	// save and clear the environment variables
-	oldVisual := os.Getenv("VISUAL")
-	oldEditor := os.Getenv("EDITOR")
-	defer func() {
-		os.Setenv("VISUAL", oldVisual)
-		os.Setenv("EDITOR", oldEditor)
-	}()
+// TestEmptyEditor asserts that envvars are respected if an editor is not
+// specified in the configs
+func TestEmptyEditor(t *testing.T) {
 
-	// with no env vars, the config file value should be used
-	os.Unsetenv("VISUAL")
-	os.Unsetenv("EDITOR")
-	conf, err := New(mocks.Path("conf/conf.yml"), false)
-	if err != nil {
-		t.Fatalf("failed to init configs: %v", err)
-	}
-	if conf.Editor != "vim" {
-		t.Errorf("expected config file editor: want: vim, got: %s", conf.Editor)
+	// clear the environment variables
+	os.Setenv("VISUAL", "")
+	os.Setenv("EDITOR", "")
+
+	// initialize a config
+	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")
 	}
 
-	// $EDITOR should override the config file value
-	os.Setenv("EDITOR", "nano")
-	conf, err = New(mocks.Path("conf/conf.yml"), false)
-	if err != nil {
-		t.Fatalf("failed to init configs: %v", err)
-	}
-	if conf.Editor != "nano" {
-		t.Errorf("$EDITOR should override config: want: nano, got: %s", conf.Editor)
-	}
-
-	// $VISUAL should override both $EDITOR and the config file value
-	os.Setenv("VISUAL", "emacs")
-	conf, err = New(mocks.Path("conf/conf.yml"), false)
-	if err != nil {
-		t.Fatalf("failed to init configs: %v", err)
-	}
-	if conf.Editor != "emacs" {
-		t.Errorf("$VISUAL should override all: want: emacs, got: %s", conf.Editor)
-	}
-}
-
-// TestEditorEnvFallback asserts that env vars are used as fallback when
-// no editor is specified in the config file
-func TestEditorEnvFallback(t *testing.T) {
-	// save and clear the environment variables
-	oldVisual := os.Getenv("VISUAL")
-	oldEditor := os.Getenv("EDITOR")
-	defer func() {
-		os.Setenv("VISUAL", oldVisual)
-		os.Setenv("EDITOR", oldEditor)
-	}()
-
-	// set $EDITOR and assert it's used when config has no editor
-	os.Unsetenv("VISUAL")
+	// set editor, and assert that it is respected
 	os.Setenv("EDITOR", "foo")
-	conf, err := New(mocks.Path("conf/empty.yml"), false)
+	conf, err = New(map[string]interface{}{}, mock.Path("conf/empty.yml"), false)
 	if err != nil {
-		t.Fatalf("failed to init configs: %v", err)
+		t.Errorf("failed to init configs: %v", err)
 	}
 	if conf.Editor != "foo" {
-		t.Errorf("failed to respect $EDITOR: want: foo, got: %s", conf.Editor)
+		t.Errorf("failed to respect editor: want: foo, got: %s", conf.Editor)
 	}
 
-	// set $VISUAL and assert it takes precedence over $EDITOR
+	// set visual, and assert that it overrides editor
 	os.Setenv("VISUAL", "bar")
-	conf, err = New(mocks.Path("conf/empty.yml"), false)
+	conf, err = New(map[string]interface{}{}, mock.Path("conf/empty.yml"), false)
 	if err != nil {
-		t.Fatalf("failed to init configs: %v", err)
+		t.Errorf("failed to init configs: %v", err)
 	}
 	if conf.Editor != "bar" {
-		t.Errorf("failed to respect $VISUAL: want: bar, got: %s", conf.Editor)
+		t.Errorf("failed to respect editor: want: bar, got: %s", conf.Editor)
 	}
 }

internal/config/editor.go

@@ -1,41 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"runtime"
-)
-
-// Editor attempts to locate an editor that's appropriate for the environment.
-func Editor() (string, error) {
-
-	// default to `notepad.exe` on Windows
-	if runtime.GOOS == "windows" {
-		return "notepad", nil
-	}
-
-	// look for `nano` and `vim` on the `PATH`
-	def, _ := exec.LookPath("editor") // default `editor` wrapper
-	nano, _ := exec.LookPath("nano")
-	vim, _ := exec.LookPath("vim")
-
-	// set editor priority
-	editors := []string{
-		os.Getenv("VISUAL"),
-		os.Getenv("EDITOR"),
-		def,
-		nano,
-		vim,
-	}
-
-	// return the first editor that was found per the priority above
-	for _, editor := range editors {
-		if editor != "" {
-			return editor, nil
-		}
-	}
-
-	// return an error if no path is found
-	return "", fmt.Errorf("no editor set")
-}

internal/config/editor_test.go

@@ -1,95 +0,0 @@
-package config
-
-import (
-	"os"
-	"runtime"
-	"testing"
-)
-
-// TestEditor tests the Editor function
-func TestEditor(t *testing.T) {
-	// Save original env vars
-	oldVisual := os.Getenv("VISUAL")
-	oldEditor := os.Getenv("EDITOR")
-	defer func() {
-		os.Setenv("VISUAL", oldVisual)
-		os.Setenv("EDITOR", oldEditor)
-	}()
-
-	t.Run("windows default", func(t *testing.T) {
-		if runtime.GOOS != "windows" {
-			t.Skip("skipping windows test on non-windows platform")
-		}
-
-		// Clear env vars
-		os.Setenv("VISUAL", "")
-		os.Setenv("EDITOR", "")
-
-		editor, err := Editor()
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if editor != "notepad" {
-			t.Errorf("expected 'notepad' on windows, got %s", editor)
-		}
-	})
-
-	t.Run("VISUAL takes precedence", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("skipping non-windows test on windows platform")
-		}
-
-		os.Setenv("VISUAL", "emacs")
-		os.Setenv("EDITOR", "nano")
-
-		editor, err := Editor()
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if editor != "emacs" {
-			t.Errorf("expected VISUAL to take precedence, got %s", editor)
-		}
-	})
-
-	t.Run("EDITOR when no VISUAL", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("skipping non-windows test on windows platform")
-		}
-
-		os.Setenv("VISUAL", "")
-		os.Setenv("EDITOR", "vim")
-
-		editor, err := Editor()
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if editor != "vim" {
-			t.Errorf("expected EDITOR value, got %s", editor)
-		}
-	})
-
-	t.Run("no editor found error", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("skipping non-windows test on windows platform")
-		}
-
-		// Clear all environment variables
-		os.Setenv("VISUAL", "")
-		os.Setenv("EDITOR", "")
-
-		// Create a custom PATH that doesn't include common editors
-		oldPath := os.Getenv("PATH")
-		defer os.Setenv("PATH", oldPath)
-
-		// Set a very limited PATH that won't have editors
-		os.Setenv("PATH", "/nonexistent")
-
-		editor, err := Editor()
-
-		// If we found an editor, it's likely in the system
-		// This test might not always produce an error on systems with editors
-		if editor == "" && err == nil {
-			t.Error("expected error when no editor found")
-		}
-	})
-}

internal/config/init.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 )
@@ -15,7 +16,7 @@ func Init(confpath string, configs string) error {
 	}
 
 	// write the config file
-	if err := os.WriteFile(confpath, []byte(configs), 0644); err != nil {
+	if err := ioutil.WriteFile(confpath, []byte(configs), 0644); err != nil {
 		return fmt.Errorf("failed to create file: %v", err)
 	}
 

internal/config/init_test.go

@@ -1,123 +0,0 @@
-package config
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-// TestInit asserts that configs are properly initialized
-func TestInit(t *testing.T) {
-
-	// initialize a temporary config file
-	confFile, err := os.CreateTemp("", "cheat-test")
-	if err != nil {
-		t.Errorf("failed to create temp file: %v", err)
-	}
-
-	// clean up the temp file
-	defer os.Remove(confFile.Name())
-
-	// initialize the config file
-	conf := "mock config data"
-	if err = Init(confFile.Name(), conf); err != nil {
-		t.Errorf("failed to init config file: %v", err)
-	}
-
-	// read back the config file contents
-	bytes, err := os.ReadFile(confFile.Name())
-	if err != nil {
-		t.Errorf("failed to read config file: %v", err)
-	}
-
-	// assert that the contents were written correctly
-	got := string(bytes)
-	if got != conf {
-		t.Errorf("failed to write configs: want: %s, got: %s", conf, got)
-	}
-}
-
-// TestInitCreateDirectory tests that Init creates the directory if it doesn't exist
-func TestInitCreateDirectory(t *testing.T) {
-	// Create a temp directory
-	tempDir, err := os.MkdirTemp("", "cheat-init-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Path to a config file in a non-existent subdirectory
-	confPath := filepath.Join(tempDir, "subdir", "conf.yml")
-
-	// Initialize the config file
-	conf := "test config"
-	if err = Init(confPath, conf); err != nil {
-		t.Errorf("failed to init config file: %v", err)
-	}
-
-	// Verify the directory was created
-	if _, err := os.Stat(filepath.Dir(confPath)); os.IsNotExist(err) {
-		t.Error("Init did not create the directory")
-	}
-
-	// Verify the file was created with correct content
-	bytes, err := os.ReadFile(confPath)
-	if err != nil {
-		t.Errorf("failed to read config file: %v", err)
-	}
-	if string(bytes) != conf {
-		t.Errorf("config content mismatch: got %q, want %q", string(bytes), conf)
-	}
-}
-
-// TestInitWriteError tests error handling when file write fails
-func TestInitWriteError(t *testing.T) {
-	// Skip this test if running as root (can write anywhere)
-	if runtime.GOOS != "windows" && os.Getuid() == 0 {
-		t.Skip("Cannot test write errors as root")
-	}
-
-	// Use a platform-appropriate invalid path
-	invalidPath := "/dev/null/impossible/path/conf.yml"
-	if runtime.GOOS == "windows" {
-		invalidPath = `NUL\impossible\path\conf.yml`
-	}
-
-	// Try to write to a read-only directory
-	err := Init(invalidPath, "test")
-	if err == nil {
-		t.Error("expected error when writing to invalid path, got nil")
-	}
-}
-
-// TestInitExistingFile tests that Init overwrites existing files
-func TestInitExistingFile(t *testing.T) {
-	// Create a temp file
-	tempFile, err := os.CreateTemp("", "cheat-init-existing-*")
-	if err != nil {
-		t.Fatalf("failed to create temp file: %v", err)
-	}
-	defer os.Remove(tempFile.Name())
-
-	// Write initial content
-	initialContent := "initial content"
-	if err := os.WriteFile(tempFile.Name(), []byte(initialContent), 0644); err != nil {
-		t.Fatalf("failed to write initial content: %v", err)
-	}
-
-	// Initialize with new content
-	newContent := "new config content"
-	if err = Init(tempFile.Name(), newContent); err != nil {
-		t.Errorf("failed to init over existing file: %v", err)
-	}
-
-	// Verify the file was overwritten
-	bytes, err := os.ReadFile(tempFile.Name())
-	if err != nil {
-		t.Errorf("failed to read config file: %v", err)
-	}
-	if string(bytes) != newContent {
-		t.Errorf("config not overwritten: got %q, want %q", string(bytes), newContent)
-	}
-}

internal/config/new.go

@@ -1,147 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	cp "github.com/cheat/cheat/internal/cheatpath"
-
-	"github.com/mitchellh/go-homedir"
-	"gopkg.in/yaml.v3"
-)
-
-// New returns a new Config struct
-func New(confPath string, resolve bool) (Config, error) {
-
-	// read the config file
-	buf, err := os.ReadFile(confPath)
-	if err != nil {
-		return Config{}, fmt.Errorf("could not read config file: %v", err)
-	}
-
-	// initialize a config object
-	conf := Config{}
-
-	// store the config path
-	conf.Path = confPath
-
-	// unmarshal the yaml
-	err = yaml.Unmarshal(buf, &conf)
-	if err != nil {
-		return Config{}, fmt.Errorf("could not unmarshal yaml: %v", err)
-	}
-
-	// if a .cheat directory exists in the current directory or any ancestor,
-	// append it to the cheatpaths
-	cwd, err := os.Getwd()
-	if err != nil {
-		return Config{}, fmt.Errorf("failed to get cwd: %v", err)
-	}
-
-	if local := findLocalCheatpath(cwd); local != "" {
-		path := cp.Path{
-			Name:     "cwd",
-			Path:     local,
-			ReadOnly: false,
-			Tags:     []string{},
-		}
-		conf.Cheatpaths = append(conf.Cheatpaths, path)
-	}
-
-	// process cheatpaths
-	var validPaths []cp.Path
-	for _, cheatpath := range conf.Cheatpaths {
-
-		// expand ~ in config paths
-		expanded, err := homedir.Expand(cheatpath.Path)
-		if err != nil {
-			return Config{}, fmt.Errorf("failed to expand ~: %v", err)
-		}
-
-		// 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 {
-			evaled, err := filepath.EvalSymlinks(expanded)
-			if err != nil {
-				// if the path simply doesn't exist, warn and skip it
-				if os.IsNotExist(err) {
-					fmt.Fprintf(os.Stderr,
-						"WARNING: cheatpath '%s' does not exist, skipping\n",
-						expanded,
-					)
-					continue
-				}
-				return Config{}, fmt.Errorf(
-					"failed to resolve symlink: %s: %v",
-					expanded,
-					err,
-				)
-			}
-
-			expanded = evaled
-		}
-
-		cheatpath.Path = expanded
-		validPaths = append(validPaths, cheatpath)
-	}
-	conf.Cheatpaths = validPaths
-
-	// determine the editor: env vars override the config file value,
-	// following standard Unix convention (see #589)
-	if v := os.Getenv("VISUAL"); v != "" {
-		conf.Editor = v
-	} else if v := os.Getenv("EDITOR"); v != "" {
-		conf.Editor = v
-	} else {
-		conf.Editor = strings.TrimSpace(conf.Editor)
-	}
-
-	// if an editor was still not determined, attempt to choose one
-	// that's appropriate for the environment
-	if conf.Editor == "" {
-		if conf.Editor, err = Editor(); err != nil {
-			return Config{}, err
-		}
-	}
-
-	// if a chroma style was not provided, set a default
-	if conf.Style == "" {
-		conf.Style = "bw"
-	}
-
-	// if a chroma formatter was not provided, set a default
-	if conf.Formatter == "" {
-		conf.Formatter = "terminal"
-	}
-
-	// load the pager
-	conf.Pager = strings.TrimSpace(conf.Pager)
-
-	return conf, nil
-}
-
-// findLocalCheatpath walks upward from dir looking for a .cheat directory.
-// It returns the path to the first .cheat directory found, or an empty string
-// if none exists. This mirrors the discovery pattern used by git for .git
-// directories.
-func findLocalCheatpath(dir string) string {
-	for {
-		candidate := filepath.Join(dir, ".cheat")
-		if info, err := os.Stat(candidate); err == nil && info.IsDir() {
-			return candidate
-		}
-		parent := filepath.Dir(dir)
-		if parent == dir {
-			return ""
-		}
-		dir = parent
-	}
-}

internal/config/new_test.go

@@ -1,135 +0,0 @@
-package config
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestNewTrimsWhitespace(t *testing.T) {
-	// clear env vars so they don't override the config file value
-	oldVisual := os.Getenv("VISUAL")
-	oldEditor := os.Getenv("EDITOR")
-	os.Unsetenv("VISUAL")
-	os.Unsetenv("EDITOR")
-	defer func() {
-		os.Setenv("VISUAL", oldVisual)
-		os.Setenv("EDITOR", oldEditor)
-	}()
-
-	// Create a temporary config file with whitespace in editor and pager
-	tmpDir := t.TempDir()
-	configPath := filepath.Join(tmpDir, "config.yml")
-
-	configContent := `---
-editor: "  vim -c 'set number'  "
-pager: "  less -R  "
-style: monokai
-formatter: terminal
-cheatpaths:
-  - name: personal
-    path: ~/cheat
-    tags: []
-    readonly: false
-`
-
-	if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
-		t.Fatalf("failed to write test config: %v", err)
-	}
-
-	// Load the config
-	conf, err := New(configPath, false)
-	if err != nil {
-		t.Fatalf("failed to load config: %v", err)
-	}
-
-	// Verify editor is trimmed
-	expectedEditor := "vim -c 'set number'"
-	if conf.Editor != expectedEditor {
-		t.Errorf("editor not properly trimmed: got %q, want %q", conf.Editor, expectedEditor)
-	}
-
-	// Verify pager is trimmed
-	expectedPager := "less -R"
-	if conf.Pager != expectedPager {
-		t.Errorf("pager not properly trimmed: got %q, want %q", conf.Pager, expectedPager)
-	}
-}
-
-func TestNewEmptyEditorFallback(t *testing.T) {
-	// Skip if required environment variables would interfere
-	oldVisual := os.Getenv("VISUAL")
-	oldEditor := os.Getenv("EDITOR")
-	os.Unsetenv("VISUAL")
-	os.Unsetenv("EDITOR")
-	defer func() {
-		os.Setenv("VISUAL", oldVisual)
-		os.Setenv("EDITOR", oldEditor)
-	}()
-
-	// Create a config with whitespace-only editor
-	tmpDir := t.TempDir()
-	configPath := filepath.Join(tmpDir, "config.yml")
-
-	configContent := `---
-editor: "   "
-pager: less
-style: monokai
-formatter: terminal
-cheatpaths:
-  - name: personal
-    path: ~/cheat
-    tags: []
-    readonly: false
-`
-
-	if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
-		t.Fatalf("failed to write test config: %v", err)
-	}
-
-	// Load the config
-	conf, err := New(configPath, false)
-	if err != nil {
-		// It's OK if this fails due to no editor being found
-		// The important thing is it doesn't panic
-		return
-	}
-
-	// If it succeeded, editor should not be empty (fallback was used)
-	if conf.Editor == "" {
-		t.Error("editor should not be empty after fallback")
-	}
-}
-
-func TestNewWhitespaceOnlyPager(t *testing.T) {
-	// Create a config with whitespace-only pager
-	tmpDir := t.TempDir()
-	configPath := filepath.Join(tmpDir, "config.yml")
-
-	configContent := `---
-editor: vim
-pager: "   "
-style: monokai
-formatter: terminal
-cheatpaths:
-  - name: personal
-    path: ~/cheat
-    tags: []
-    readonly: false
-`
-
-	if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
-		t.Fatalf("failed to write test config: %v", err)
-	}
-
-	// Load the config
-	conf, err := New(configPath, false)
-	if err != nil {
-		t.Fatalf("failed to load config: %v", err)
-	}
-
-	// Pager should be empty after trimming
-	if conf.Pager != "" {
-		t.Errorf("pager should be empty after trimming whitespace: got %q", conf.Pager)
-	}
-}

internal/config/pager.go

@@ -1,32 +0,0 @@
-package config
-
-import (
-	"os"
-	"os/exec"
-	"runtime"
-)
-
-// Pager attempts to locate a pager that's appropriate for the environment.
-func Pager() string {
-
-	// default to `more` on Windows
-	if runtime.GOOS == "windows" {
-		return "more"
-	}
-
-	// if $PAGER is set, return the corresponding pager
-	if os.Getenv("PAGER") != "" {
-		return os.Getenv("PAGER")
-	}
-
-	// Otherwise, search for `pager`, `less`, and `more` on the `$PATH`. If
-	// none are found, return an empty pager.
-	for _, pager := range []string{"pager", "less", "more"} {
-		if path, err := exec.LookPath(pager); err == nil {
-			return path
-		}
-	}
-
-	// default to no pager
-	return ""
-}

internal/config/pager_test.go

@@ -1,82 +0,0 @@
-package config
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-// TestPager tests the Pager function
-func TestPager(t *testing.T) {
-	// Save original env var
-	oldPager := os.Getenv("PAGER")
-	defer os.Setenv("PAGER", oldPager)
-
-	t.Run("windows default", func(t *testing.T) {
-		if runtime.GOOS != "windows" {
-			t.Skip("skipping windows test on non-windows platform")
-		}
-
-		os.Setenv("PAGER", "")
-		pager := Pager()
-		if pager != "more" {
-			t.Errorf("expected 'more' on windows, got %s", pager)
-		}
-	})
-
-	t.Run("PAGER env var", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("skipping non-windows test on windows platform")
-		}
-
-		os.Setenv("PAGER", "bat")
-		pager := Pager()
-		if pager != "bat" {
-			t.Errorf("expected PAGER env var value, got %s", pager)
-		}
-	})
-
-	t.Run("fallback to system pager", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("skipping non-windows test on windows platform")
-		}
-
-		os.Setenv("PAGER", "")
-		pager := Pager()
-
-		if pager == "" {
-			return // no pager found is acceptable
-		}
-
-		// Should find one of the known fallback pagers
-		validPagers := map[string]bool{
-			"pager": true,
-			"less":  true,
-			"more":  true,
-		}
-
-		base := filepath.Base(pager)
-		if !validPagers[base] {
-			t.Errorf("unexpected pager value: %s (base: %s)", pager, base)
-		}
-	})
-
-	t.Run("no pager available", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("skipping non-windows test on windows platform")
-		}
-
-		os.Setenv("PAGER", "")
-
-		// Save and modify PATH to ensure no pagers are found
-		oldPath := os.Getenv("PATH")
-		defer os.Setenv("PATH", oldPath)
-		os.Setenv("PATH", "/nonexistent")
-
-		pager := Pager()
-		if pager != "" {
-			t.Errorf("expected empty string when no pager found, got %s", pager)
-		}
-	})
-}

internal/config/path_test.go

@@ -1,52 +0,0 @@
-package config
-
-import (
-	"os"
-	"testing"
-)
-
-// TestPathConfigNotExists asserts that `Path` identifies non-existent config
-// files
-func TestPathConfigNotExists(t *testing.T) {
-
-	// package (invalid) cheatpaths
-	paths := []string{"/cheat-test-conf-does-not-exist"}
-
-	// assert
-	if _, err := Path(paths); err == nil {
-		t.Errorf("failed to identify non-existent config file")
-	}
-
-}
-
-// TestPathConfigExists asserts that `Path` identifies existent config files
-func TestPathConfigExists(t *testing.T) {
-
-	// initialize a temporary config file
-	confFile, err := os.CreateTemp("", "cheat-test")
-	if err != nil {
-		t.Errorf("failed to create temp file: %v", err)
-	}
-
-	// clean up the temp file
-	defer os.Remove(confFile.Name())
-
-	// package cheatpaths
-	paths := []string{
-		"/cheat-test-conf-does-not-exist",
-		confFile.Name(),
-	}
-
-	// assert
-	got, err := Path(paths)
-	if err != nil {
-		t.Errorf("failed to identify config file: %v", err)
-	}
-	if got != confFile.Name() {
-		t.Errorf(
-			"failed to return config path: want: %s, got: %s",
-			confFile.Name(),
-			got,
-		)
-	}
-}

internal/config/paths.go

@@ -2,7 +2,7 @@ package config
 
 import (
 	"fmt"
-	"path/filepath"
+	"path"
 
 	"github.com/mitchellh/go-homedir"
 )
@@ -28,30 +28,25 @@ func Paths(
 	}
 
 	switch sys {
-
-	// darwin/linux/unix
-	case "aix", "android", "darwin", "dragonfly", "freebsd", "illumos", "ios",
-		"linux", "netbsd", "openbsd", "plan9", "solaris":
+	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, filepath.Join(xdgpath, "cheat", "conf.yml"))
+			paths = append(paths, path.Join(xdgpath, "/cheat/conf.yml"))
 		}
 
 		paths = append(paths, []string{
-			filepath.Join(home, ".config", "cheat", "conf.yml"),
-			filepath.Join(home, ".cheat", "conf.yml"),
+			path.Join(home, ".config/cheat/conf.yml"),
+			path.Join(home, ".cheat/conf.yml"),
 			"/etc/cheat/conf.yml",
 		}...)
 
 		return paths, nil
-
-	// windows
 	case "windows":
 		return []string{
-			filepath.Join(envvars["APPDATA"], "cheat", "conf.yml"),
-			filepath.Join(envvars["PROGRAMDATA"], "cheat", "conf.yml"),
+			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

@@ -1,9 +1,7 @@
 package config
 
 import (
-	"path/filepath"
 	"reflect"
-	"runtime"
 	"testing"
 
 	"github.com/davecgh/go-spew/spew"
@@ -12,9 +10,6 @@ import (
 // TestValidatePathsNix asserts that the proper config paths are returned on
 // *nix platforms
 func TestValidatePathsNix(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("filepath.Join uses backslashes on Windows")
-	}
 
 	// mock the user's home directory
 	home := "/home/foo"
@@ -26,7 +21,6 @@ func TestValidatePathsNix(t *testing.T) {
 
 	// specify the platforms to test
 	oses := []string{
-		"android",
 		"darwin",
 		"freebsd",
 		"linux",
@@ -62,9 +56,6 @@ func TestValidatePathsNix(t *testing.T) {
 // TestValidatePathsNixNoXDG asserts that the proper config paths are returned
 // on *nix platforms when `XDG_CONFIG_HOME is not set
 func TestValidatePathsNixNoXDG(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("filepath.Join uses backslashes on Windows")
-	}
 
 	// mock the user's home directory
 	home := "/home/foo"
@@ -114,8 +105,8 @@ func TestValidatePathsWindows(t *testing.T) {
 
 	// mock some envvars
 	envvars := map[string]string{
-		"APPDATA":     filepath.Join("C:", "apps"),
-		"PROGRAMDATA": filepath.Join("C:", "programs"),
+		"APPDATA":     "/apps",
+		"PROGRAMDATA": "/programs",
 	}
 
 	// get the paths for the platform
@@ -126,8 +117,8 @@ func TestValidatePathsWindows(t *testing.T) {
 
 	// specify the expected output
 	want := []string{
-		filepath.Join("C:", "apps", "cheat", "conf.yml"),
-		filepath.Join("C:", "programs", "cheat", "conf.yml"),
+		"/apps/cheat/conf.yml",
+		"/programs/cheat/conf.yml",
 	}
 
 	// assert that output matches expectations

internal/config/validate_test.go

@@ -14,8 +14,8 @@ func TestValidateCorrect(t *testing.T) {
 		Colorize:  true,
 		Editor:    "vim",
 		Formatter: "terminal16m",
-		Cheatpaths: []cheatpath.Path{
-			cheatpath.Path{
+		Cheatpaths: []cheatpath.Cheatpath{
+			cheatpath.Cheatpath{
 				Name:     "foo",
 				Path:     "/foo",
 				ReadOnly: false,
@@ -38,8 +38,8 @@ func TestInvalidateMissingEditor(t *testing.T) {
 	conf := Config{
 		Colorize:  true,
 		Formatter: "terminal16m",
-		Cheatpaths: []cheatpath.Path{
-			cheatpath.Path{
+		Cheatpaths: []cheatpath.Cheatpath{
+			cheatpath.Cheatpath{
 				Name:     "foo",
 				Path:     "/foo",
 				ReadOnly: false,
@@ -71,28 +71,19 @@ func TestInvalidateMissingCheatpaths(t *testing.T) {
 	}
 }
 
-// TestInvalidateInvalidFormatter asserts that configs which contain invalid
+// TestMissingInvalidFormatters asserts that configs which contain invalid
 // formatters are invalidated
-func TestInvalidateInvalidFormatter(t *testing.T) {
+func TestMissingInvalidFormatters(t *testing.T) {
 
-	// mock a config with a valid editor and cheatpaths but invalid formatter
+	// mock a config
 	conf := Config{
 		Colorize: true,
 		Editor:   "vim",
-		Formatter: "html",
-		Cheatpaths: []cheatpath.Path{
-			cheatpath.Path{
-				Name:     "foo",
-				Path:     "/foo",
-				ReadOnly: false,
-				Tags:     []string{},
-			},
-		},
 	}
 
-	// assert that the config is invalidated due to the formatter
+	// assert that no errors are returned
 	if err := conf.Validate(); err == nil {
-		t.Errorf("failed to invalidate config with invalid formatter")
+		t.Errorf("failed to invalidate config without formatter")
 	}
 }
 
@@ -105,14 +96,14 @@ func TestInvalidateDuplicateCheatpathNames(t *testing.T) {
 		Colorize:  true,
 		Editor:    "vim",
 		Formatter: "terminal16m",
-		Cheatpaths: []cheatpath.Path{
-			cheatpath.Path{
+		Cheatpaths: []cheatpath.Cheatpath{
+			cheatpath.Cheatpath{
 				Name:     "foo",
 				Path:     "/foo",
 				ReadOnly: false,
 				Tags:     []string{},
 			},
-			cheatpath.Path{
+			cheatpath.Cheatpath{
 				Name:     "foo",
 				Path:     "/bar",
 				ReadOnly: false,
@@ -136,14 +127,14 @@ func TestInvalidateDuplicateCheatpathPaths(t *testing.T) {
 		Colorize:  true,
 		Editor:    "vim",
 		Formatter: "terminal16m",
-		Cheatpaths: []cheatpath.Path{
-			cheatpath.Path{
+		Cheatpaths: []cheatpath.Cheatpath{
+			cheatpath.Cheatpath{
 				Name:     "foo",
 				Path:     "/foo",
 				ReadOnly: false,
 				Tags:     []string{},
 			},
-			cheatpath.Path{
+			cheatpath.Cheatpath{
 				Name:     "bar",
 				Path:     "/foo",
 				ReadOnly: false,

internal/display/display.go

@@ -9,9 +9,9 @@ import (
 	"github.com/cheat/cheat/internal/config"
 )
 
-// Write writes output either directly to stdout, or through a pager,
+// Display writes output either directly to stdout, or through a pager,
 // depending upon configuration.
-func Write(out string, conf config.Config) {
+func Display(out string, conf config.Config) {
 	// if no pager was configured, print the output to stdout and exit
 	if conf.Pager == "" {
 		fmt.Print(out)
@@ -19,23 +19,19 @@ func Write(out string, conf config.Config) {
 	}
 
 	// otherwise, pipe output through the pager
-	writeToPager(out, conf)
-}
-
-// writeToPager writes output through a pager command
-func writeToPager(out string, conf config.Config) {
-	parts := strings.Fields(conf.Pager)
+	parts := strings.Split(conf.Pager, " ")
 	pager := parts[0]
 	args := parts[1:]
 
-	// configure the pager
+	// run the pager
 	cmd := exec.Command(pager, args...)
 	cmd.Stdin = strings.NewReader(out)
 	cmd.Stdout = os.Stdout
 
-	// run the pager and handle errors
-	if err := cmd.Run(); err != nil {
-		fmt.Fprintf(os.Stderr, "failed to write to pager: %v\n", err)
+	// handle errors
+	err := cmd.Run()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("failed to write to pager: %v", err))
 		os.Exit(1)
 	}
 }

internal/display/faint.go

@@ -1,17 +0,0 @@
-// Package display implement functions pertaining to writing formatted
-// cheatsheet content to stdout, or alternatively the system pager.
-package display
-
-import "fmt"
-
-// Faint returns a faintly-colored string that's used to de-prioritize text
-// written to stdout
-func Faint(str string, colorize bool) string {
-	// make `str` faint only if colorization has been requested
-	if colorize {
-		return fmt.Sprintf("\033[2m%s\033[0m", str)
-	}
-
-	// otherwise, return the string unmodified
-	return str
-}

internal/display/faint_test.go

@@ -1,21 +0,0 @@
-package display
-
-import "testing"
-
-// TestFaint asserts that Faint applies faint formatting
-func TestFaint(t *testing.T) {
-
-	// case: apply colorization
-	want := "\033[2mfoo\033[0m"
-	got := Faint("foo", true)
-	if want != got {
-		t.Errorf("failed to faint: want: %s, got: %s", want, got)
-	}
-
-	// case: do not apply colorization
-	want = "foo"
-	got = Faint("foo", false)
-	if want != got {
-		t.Errorf("failed to faint: want: %s, got: %s", want, got)
-	}
-}

internal/display/indent.go

@@ -1,21 +0,0 @@
-package display
-
-import (
-	"fmt"
-	"strings"
-)
-
-// Indent prepends each line of a string with a tab
-func Indent(str string) string {
-
-	// trim superfluous whitespace
-	str = strings.TrimSpace(str)
-
-	// prepend each line with a tab character
-	out := ""
-	for _, line := range strings.Split(str, "\n") {
-		out += fmt.Sprintf("\t%s\n", line)
-	}
-
-	return out
-}

internal/display/indent_test.go

@@ -1,12 +0,0 @@
-package display
-
-import "testing"
-
-// TestIndent asserts that Indent prepends a tab to each line
-func TestIndent(t *testing.T) {
-	got := Indent("foo\nbar\nbaz")
-	want := "\tfoo\n\tbar\n\tbaz\n"
-	if got != want {
-		t.Errorf("failed to indent: want: %s, got: %s", want, got)
-	}
-}

internal/display/write_test.go

@@ -1,136 +0,0 @@
-package display
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/cheat/cheat/internal/config"
-)
-
-// TestWriteToPager tests the writeToPager function
-func TestWriteToPager(t *testing.T) {
-	// Skip these tests in CI/CD environments where interactive commands might not work
-	if os.Getenv("CI") != "" {
-		t.Skip("Skipping pager tests in CI environment")
-	}
-
-	// Note: We can't easily test os.Exit calls, so we focus on testing writeToPager
-	// which contains the core logic
-
-	t.Run("successful pager execution", func(t *testing.T) {
-		// Save original stdout
-		oldStdout := os.Stdout
-		defer func() {
-			os.Stdout = oldStdout
-		}()
-
-		// Create pipe for capturing output
-		r, w, _ := os.Pipe()
-		os.Stdout = w
-
-		// Use 'cat' as a simple pager that just outputs input
-		conf := config.Config{
-			Pager: "cat",
-		}
-
-		// This will call os.Exit on error, so we need to be careful
-		// We're using 'cat' which should always succeed
-		input := "Test output\n"
-
-		// Run in a goroutine to avoid blocking
-		done := make(chan bool)
-		go func() {
-			writeToPager(input, conf)
-			done <- true
-		}()
-
-		// Wait for completion or timeout
-		select {
-		case <-done:
-			// Success
-		}
-
-		// Close write end and read output
-		w.Close()
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-
-		// Verify output
-		if buf.String() != input {
-			t.Errorf("expected output %q, got %q", input, buf.String())
-		}
-	})
-
-	t.Run("pager with arguments", func(t *testing.T) {
-		// Save original stdout
-		oldStdout := os.Stdout
-		defer func() {
-			os.Stdout = oldStdout
-		}()
-
-		// Create pipe for capturing output
-		r, w, _ := os.Pipe()
-		os.Stdout = w
-
-		// Use 'cat' with '-A' flag (shows non-printing characters)
-		conf := config.Config{
-			Pager: "cat -A",
-		}
-
-		input := "Test\toutput\n"
-
-		// Run in a goroutine
-		done := make(chan bool)
-		go func() {
-			writeToPager(input, conf)
-			done <- true
-		}()
-
-		// Wait for completion
-		select {
-		case <-done:
-			// Success
-		}
-
-		// Close write end and read output
-		w.Close()
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-
-		// cat -A shows tabs as ^I and line endings as $
-		expected := "Test^Ioutput$\n"
-		if buf.String() != expected {
-			t.Errorf("expected output %q, got %q", expected, buf.String())
-		}
-	})
-}
-
-// TestWriteToPagerError tests error handling in writeToPager
-func TestWriteToPagerError(t *testing.T) {
-	if os.Getenv("TEST_PAGER_ERROR_SUBPROCESS") == "1" {
-		// This is the subprocess - run the actual test
-		conf := config.Config{Pager: "/nonexistent/command"}
-		writeToPager("test", conf)
-		return
-	}
-
-	// Run test in subprocess to handle os.Exit
-	cmd := exec.Command(os.Args[0], "-test.run=^TestWriteToPagerError$")
-	cmd.Env = append(os.Environ(), "TEST_PAGER_ERROR_SUBPROCESS=1")
-
-	output, err := cmd.CombinedOutput()
-
-	// Should exit with error
-	if err == nil {
-		t.Error("expected process to exit with error")
-	}
-
-	// Should contain error message
-	if !strings.Contains(string(output), "failed to write to pager") {
-		t.Errorf("expected error message about pager failure, got %q", string(output))
-	}
-}

internal/frontmatter/frontmatter.go

@@ -1,30 +1,30 @@
-package sheet
+package frontmatter
 
 import (
 	"fmt"
 	"strings"
 
-	"gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v1"
 )
 
-// Parse parses cheatsheet frontmatter
-func parse(markdown string) (frontmatter, string, error) {
+// Frontmatter encapsulates cheatsheet frontmatter data
+type Frontmatter struct {
+	Tags   []string
+	Syntax string
+}
 
-	// detect the line-break style used in the content
-	linebreak := "\n"
-	if strings.Contains(markdown, "\r\n") {
-		linebreak = "\r\n"
-	}
+// Parse parses cheatsheet frontmatter
+func Parse(markdown string) (string, Frontmatter, error) {
 
 	// specify the frontmatter delimiter
-	delim := fmt.Sprintf("---%s", linebreak)
+	delim := "---"
 
 	// initialize a frontmatter struct
-	var fm frontmatter
+	var fm Frontmatter
 
 	// if the markdown does not contain frontmatter, pass it through unmodified
 	if !strings.HasPrefix(markdown, delim) {
-		return fm, markdown, nil
+		return strings.TrimSpace(markdown), fm, nil
 	}
 
 	// otherwise, split the frontmatter and cheatsheet text
@@ -32,13 +32,13 @@ func parse(markdown string) (frontmatter, string, error) {
 
 	// return an error if the frontmatter parses into the wrong number of parts
 	if len(parts) != 3 {
-		return fm, markdown, fmt.Errorf("failed to delimit frontmatter")
+		return markdown, fm, fmt.Errorf("failed to delimit frontmatter")
 	}
 
 	// return an error if the YAML cannot be unmarshalled
 	if err := yaml.Unmarshal([]byte(parts[1]), &fm); err != nil {
-		return fm, markdown, fmt.Errorf("failed to unmarshal frontmatter: %v", err)
+		return markdown, fm, fmt.Errorf("failed to unmarshal frontmatter: %v", err)
 	}
 
-	return fm, parts[2], nil
+	return strings.TrimSpace(parts[2]), fm, nil
 }

internal/frontmatter/frontmatter_test.go

@@ -1,4 +1,4 @@
-package sheet
+package frontmatter
 
 import (
 	"testing"
@@ -16,7 +16,7 @@ tags: [ test ]
 To foo the bar: baz`
 
 	// parse the frontmatter
-	fm, text, err := parse(markdown)
+	text, fm, err := Parse(markdown)
 
 	// assert expectations
 	if err != nil {
@@ -38,7 +38,7 @@ To foo the bar: baz`
 		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 1, got: len %d", len(fm.Tags))
+		t.Errorf("failed to parse tags: want: len 0, got: len %d", len(fm.Tags))
 	}
 }
 
@@ -50,7 +50,7 @@ func TestHasNoFrontmatter(t *testing.T) {
 	markdown := "To foo the bar: baz"
 
 	// parse the frontmatter
-	fm, text, err := parse(markdown)
+	text, fm, err := Parse(markdown)
 
 	// assert expectations
 	if err != nil {
@@ -81,7 +81,7 @@ tags: [ test ]
 To foo the bar: baz`
 
 	// parse the frontmatter
-	_, text, err := parse(markdown)
+	text, _, err := Parse(markdown)
 
 	// assert that an error was returned
 	if err == nil {

internal/installer/clone.go

@@ -0,0 +1,24 @@
+package installer
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+)
+
+const cloneURL = "https://github.com/cheat/cheatsheets.git"
+
+// Clone clones the community cheatsheets
+func Clone(path string) error {
+
+	// perform the clone in a shell
+	cmd := exec.Command("git", "clone", cloneURL, path)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err := cmd.Run()
+	if err != nil {
+		return fmt.Errorf("failed to clone cheatsheets: %v", err)
+	}
+
+	return nil
+}

internal/installer/prompt.go

@@ -1,8 +1,7 @@
-// Package installer implements functions that provide a first-time
-// installation wizard.
 package installer
 
 import (
+	"bufio"
 	"fmt"
 	"os"
 	"strings"
@@ -11,34 +10,20 @@ import (
 // Prompt prompts the user for a answer
 func Prompt(prompt string, def bool) (bool, error) {
 
-	// display the prompt
-	fmt.Printf("%s: ", prompt)
+	// initialize a line reader
+	reader := bufio.NewReader(os.Stdin)
 
-	// read one byte at a time until newline to avoid buffering past the
-	// end of the current line, which would consume input intended for
-	// subsequent Prompt calls on the same stdin
-	var line []byte
-	buf := make([]byte, 1)
-	for {
-		n, err := os.Stdin.Read(buf)
-		if n > 0 {
-			if buf[0] == '\n' {
-				break
-			}
-			if buf[0] != '\r' {
-				line = append(line, buf[0])
-			}
-		}
+	// display the prompt
+	fmt.Print(fmt.Sprintf("%s: ", prompt))
+
+	// read the answer
+	ans, err := reader.ReadString('\n')
 	if err != nil {
-			if len(line) > 0 {
-				break
-			}
-			return false, fmt.Errorf("failed to prompt: %v", err)
-		}
+		return false, fmt.Errorf("failed to parse input: %v", err)
 	}
 
 	// normalize the answer
-	ans := strings.ToLower(strings.TrimSpace(string(line)))
+	ans = strings.ToLower(strings.TrimRight(ans, "\n"))
 
 	// return the appropriate response
 	switch ans {

internal/installer/prompt_test.go

@@ -1,159 +0,0 @@
-package installer
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestPrompt(t *testing.T) {
-	// Save original stdin/stdout
-	oldStdin := os.Stdin
-	oldStdout := os.Stdout
-	defer func() {
-		os.Stdin = oldStdin
-		os.Stdout = oldStdout
-	}()
-
-	tests := []struct {
-		name       string
-		prompt     string
-		input      string
-		defaultVal bool
-		want       bool
-		wantErr    bool
-		wantPrompt string
-	}{
-		{
-			name:       "answer yes",
-			prompt:     "Continue?",
-			input:      "y\n",
-			defaultVal: false,
-			want:       true,
-			wantPrompt: "Continue?: ",
-		},
-		{
-			name:       "answer yes with uppercase",
-			prompt:     "Continue?",
-			input:      "Y\n",
-			defaultVal: false,
-			want:       true,
-			wantPrompt: "Continue?: ",
-		},
-		{
-			name:       "answer yes with spaces",
-			prompt:     "Continue?",
-			input:      "  y  \n",
-			defaultVal: false,
-			want:       true,
-			wantPrompt: "Continue?: ",
-		},
-		{
-			name:       "answer no",
-			prompt:     "Continue?",
-			input:      "n\n",
-			defaultVal: true,
-			want:       false,
-			wantPrompt: "Continue?: ",
-		},
-		{
-			name:       "answer no with any text",
-			prompt:     "Continue?",
-			input:      "anything\n",
-			defaultVal: true,
-			want:       false,
-			wantPrompt: "Continue?: ",
-		},
-		{
-			name:       "empty answer uses default true",
-			prompt:     "Continue?",
-			input:      "\n",
-			defaultVal: true,
-			want:       true,
-			wantPrompt: "Continue?: ",
-		},
-		{
-			name:       "empty answer uses default false",
-			prompt:     "Continue?",
-			input:      "\n",
-			defaultVal: false,
-			want:       false,
-			wantPrompt: "Continue?: ",
-		},
-		{
-			name:       "whitespace answer uses default",
-			prompt:     "Continue?",
-			input:      "   \n",
-			defaultVal: true,
-			want:       true,
-			wantPrompt: "Continue?: ",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Create a pipe for stdin
-			r, w, _ := os.Pipe()
-			os.Stdin = r
-
-			// Create a pipe for stdout to capture the prompt
-			rOut, wOut, _ := os.Pipe()
-			os.Stdout = wOut
-
-			// Write input to stdin
-			go func() {
-				defer w.Close()
-				io.WriteString(w, tt.input)
-			}()
-
-			// Call the function
-			got, err := Prompt(tt.prompt, tt.defaultVal)
-
-			// Close stdout write end and read the prompt
-			wOut.Close()
-			var buf bytes.Buffer
-			io.Copy(&buf, rOut)
-
-			// Check error
-			if (err != nil) != tt.wantErr {
-				t.Errorf("Prompt() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-
-			// Check result
-			if got != tt.want {
-				t.Errorf("Prompt() = %v, want %v", got, tt.want)
-			}
-
-			// Check that prompt was displayed correctly
-			if buf.String() != tt.wantPrompt {
-				t.Errorf("Prompt display = %q, want %q", buf.String(), tt.wantPrompt)
-			}
-		})
-	}
-}
-
-func TestPromptError(t *testing.T) {
-	// Save original stdin
-	oldStdin := os.Stdin
-	defer func() {
-		os.Stdin = oldStdin
-	}()
-
-	// Create a pipe and close it immediately to simulate read error
-	r, w, _ := os.Pipe()
-	os.Stdin = r
-	r.Close()
-	w.Close()
-
-	// This should cause a read error
-	_, err := Prompt("Test?", false)
-	if err == nil {
-		t.Error("expected error when reading from closed stdin, got nil")
-	}
-	if !strings.Contains(err.Error(), "failed to prompt") {
-		t.Errorf("expected 'failed to prompt' error, got: %v", err)
-	}
-}

internal/installer/run.go

@@ -1,52 +0,0 @@
-package installer
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/cheat/cheat/internal/config"
-	"github.com/cheat/cheat/internal/repo"
-)
-
-// Run runs the installer
-func Run(configs string, confpath string) error {
-
-	// expand template placeholders with platform-appropriate paths
-	configs = ExpandTemplate(configs, confpath)
-
-	// determine cheatsheet directory paths
-	community, personal, work := cheatsheetDirs(confpath)
-
-	// prompt the user to download the community cheatsheets
-	yes, err := Prompt(
-		"Would you like to download the community cheatsheets? [Y/n]",
-		true,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to prompt: %v", err)
-	}
-
-	// clone the community cheatsheets if so instructed
-	if yes {
-		fmt.Printf("Cloning community cheatsheets to %s.\n", community)
-		if err := repo.Clone(community); err != nil {
-			return fmt.Errorf("failed to clone cheatsheets: %v", err)
-		}
-	} else {
-		configs = CommentCommunity(configs, confpath)
-	}
-
-	// always create personal and work directories
-	for _, dir := range []string{personal, work} {
-		if err := os.MkdirAll(dir, os.ModePerm); err != nil {
-			return fmt.Errorf("failed to create directory: %v", err)
-		}
-	}
-
-	// the config file does not exist, so we'll try to create one
-	if err = config.Init(confpath, configs); err != nil {
-		return fmt.Errorf("failed to create config file: %v", err)
-	}
-
-	return nil
-}

internal/installer/run_test.go

@@ -1,267 +0,0 @@
-package installer
-
-import (
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func TestRun(t *testing.T) {
-	// Create a temporary directory for testing
-	tempDir, err := os.MkdirTemp("", "cheat-installer-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Save original stdin/stdout
-	oldStdin := os.Stdin
-	oldStdout := os.Stdout
-	defer func() {
-		os.Stdin = oldStdin
-		os.Stdout = oldStdout
-	}()
-
-	tests := []struct {
-		name          string
-		configs       string
-		confpath      string
-		userInput     string
-		wantErr       bool
-		wantInErr     string
-		checkFiles    []string
-		dontWantFiles []string
-	}{
-		{
-			name: "user declines community cheatsheets",
-			configs: `---
-editor: EDITOR_PATH
-pager: PAGER_PATH
-cheatpaths:
-  - name: community
-    path: COMMUNITY_PATH
-    tags: [ community ]
-    readonly: true
-  - name: personal
-    path: PERSONAL_PATH
-    tags: [ personal ]
-    readonly: false
-`,
-			confpath:      filepath.Join(tempDir, "conf1", "conf.yml"),
-			userInput:     "n\n",
-			wantErr:       false,
-			checkFiles:    []string{"conf1/conf.yml", "conf1/cheatsheets/personal", "conf1/cheatsheets/work"},
-			dontWantFiles: []string{"conf1/cheatsheets/community"},
-		},
-		{
-			name: "user accepts but clone fails",
-			configs: `---
-cheatpaths:
-  - name: community
-    path: COMMUNITY_PATH
-`,
-			confpath:  filepath.Join(tempDir, "conf2", "conf.yml"),
-			userInput: "y\n",
-			wantErr:   true,
-			wantInErr: "failed to clone cheatsheets",
-		},
-		{
-			name:    "invalid config path",
-			configs: "test",
-			// /dev/null/... is truly uncreatable on Unix;
-			// NUL\... is uncreatable on Windows
-			confpath: func() string {
-				if runtime.GOOS == "windows" {
-					return `NUL\impossible\conf.yml`
-				}
-				return "/dev/null/impossible/conf.yml"
-			}(),
-			userInput: "n\n",
-			wantErr:   true,
-			wantInErr: "failed to create",
-		},
-	}
-
-	// Pre-create a .git dir inside the community path so go-git's PlainClone
-	// returns ErrRepositoryAlreadyExists (otherwise, on CI runners with
-	// network access, the real clone succeeds and the test fails)
-	fakeGitDir := filepath.Join(tempDir, "conf2", "cheatsheets", "community", ".git")
-	if err := os.MkdirAll(fakeGitDir, 0755); err != nil {
-		t.Fatalf("failed to create fake .git dir: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(fakeGitDir, "HEAD"), []byte("ref: refs/heads/main\n"), 0644); err != nil {
-		t.Fatalf("failed to write fake HEAD: %v", err)
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Create stdin pipe
-			r, w, _ := os.Pipe()
-			os.Stdin = r
-
-			// Create stdout pipe to suppress output
-			_, wOut, _ := os.Pipe()
-			os.Stdout = wOut
-
-			// Write user input
-			go func() {
-				defer w.Close()
-				io.WriteString(w, tt.userInput)
-			}()
-
-			// Run the installer
-			err := Run(tt.configs, tt.confpath)
-
-			// Close pipes
-			wOut.Close()
-
-			// Check error
-			if (err != nil) != tt.wantErr {
-				t.Errorf("Run() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			if err != nil && tt.wantInErr != "" && !strings.Contains(err.Error(), tt.wantInErr) {
-				t.Errorf("Run() error = %v, want error containing %q", err, tt.wantInErr)
-			}
-
-			// Check created files
-			for _, file := range tt.checkFiles {
-				path := filepath.Join(tempDir, file)
-				if _, err := os.Stat(path); os.IsNotExist(err) {
-					t.Errorf("expected file %s to exist, but it doesn't", path)
-				}
-			}
-
-			// Check files that shouldn't exist
-			for _, file := range tt.dontWantFiles {
-				path := filepath.Join(tempDir, file)
-				if _, err := os.Stat(path); err == nil {
-					t.Errorf("expected file %s to not exist, but it does", path)
-				}
-			}
-		})
-	}
-}
-
-func TestRunPromptError(t *testing.T) {
-	// Save original stdin
-	oldStdin := os.Stdin
-	defer func() {
-		os.Stdin = oldStdin
-	}()
-
-	// Close stdin to cause prompt error
-	r, w, _ := os.Pipe()
-	os.Stdin = r
-	r.Close()
-	w.Close()
-
-	tempDir, _ := os.MkdirTemp("", "cheat-installer-prompt-test-*")
-	defer os.RemoveAll(tempDir)
-
-	err := Run("test", filepath.Join(tempDir, "conf.yml"))
-	if err == nil {
-		t.Error("expected error when prompt fails, got nil")
-	}
-	if !strings.Contains(err.Error(), "failed to prompt") {
-		t.Errorf("expected 'failed to prompt' error, got: %v", err)
-	}
-}
-
-func TestRunStringReplacements(t *testing.T) {
-	// Test that path replacements work correctly
-	configs := `---
-editor: EDITOR_PATH
-pager: PAGER_PATH
-cheatpaths:
-  - name: personal
-    path: PERSONAL_PATH
-    tags: [ personal ]
-    readonly: false
-  - name: work
-    path: WORK_PATH
-    tags: [ work ]
-    readonly: false
-  - name: community
-    path: COMMUNITY_PATH
-    tags: [ community ]
-    readonly: true
-`
-
-	// Create temp directory
-	tempDir, err := os.MkdirTemp("", "cheat-installer-replace-test-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	confpath := filepath.Join(tempDir, "conf.yml")
-	confdir := filepath.Dir(confpath)
-
-	// Expected paths
-	expectedPersonal := filepath.Join(confdir, "cheatsheets", "personal")
-
-	// Save original stdin/stdout
-	oldStdin := os.Stdin
-	oldStdout := os.Stdout
-	defer func() {
-		os.Stdin = oldStdin
-		os.Stdout = oldStdout
-	}()
-
-	// Create stdin pipe with "n" answer
-	r, w, _ := os.Pipe()
-	os.Stdin = r
-	go func() {
-		defer w.Close()
-		io.WriteString(w, "n\n")
-	}()
-
-	// Suppress stdout
-	_, wOut, _ := os.Pipe()
-	os.Stdout = wOut
-	defer wOut.Close()
-
-	// Run installer
-	err = Run(configs, confpath)
-	if err != nil {
-		t.Fatalf("Run() failed: %v", err)
-	}
-
-	// Read the created config file
-	content, err := os.ReadFile(confpath)
-	if err != nil {
-		t.Fatalf("failed to read config file: %v", err)
-	}
-
-	// Check replacements
-	contentStr := string(content)
-	if strings.Contains(contentStr, "COMMUNITY_PATH") {
-		t.Error("COMMUNITY_PATH was not replaced")
-	}
-	if strings.Contains(contentStr, "PERSONAL_PATH") {
-		t.Error("PERSONAL_PATH was not replaced")
-	}
-	if strings.Contains(contentStr, "EDITOR_PATH") {
-		t.Error("EDITOR_PATH was not replaced")
-	}
-	if strings.Contains(contentStr, "PAGER_PATH") {
-		t.Error("PAGER_PATH was not replaced")
-	}
-	if strings.Contains(contentStr, "WORK_PATH") {
-		t.Error("WORK_PATH was not replaced")
-	}
-
-	// Verify community path is commented out (user declined)
-	if strings.Contains(contentStr, "  - name: community") {
-		t.Error("expected community cheatpath to be commented out when declined")
-	}
-	if !strings.Contains(contentStr, "  #- name: community") {
-		t.Error("expected commented-out community cheatpath")
-	}
-	if !strings.Contains(contentStr, expectedPersonal) {
-		t.Errorf("expected personal path %q in config", expectedPersonal)
-	}
-}

internal/installer/template.go

@@ -1,58 +0,0 @@
-package installer
-
-import (
-	"path/filepath"
-	"strings"
-
-	"github.com/cheat/cheat/internal/config"
-)
-
-// cheatsheetDirs returns the community, personal, and work cheatsheet
-// directory paths derived from a config file path.
-func cheatsheetDirs(confpath string) (community, personal, work string) {
-	confdir := filepath.Dir(confpath)
-	community = filepath.Join(confdir, "cheatsheets", "community")
-	personal = filepath.Join(confdir, "cheatsheets", "personal")
-	work = filepath.Join(confdir, "cheatsheets", "work")
-	return
-}
-
-// ExpandTemplate replaces placeholder tokens in the config template with
-// platform-appropriate paths derived from confpath.
-func ExpandTemplate(configs string, confpath string) string {
-	community, personal, work := cheatsheetDirs(confpath)
-
-	// substitute paths
-	configs = strings.ReplaceAll(configs, "COMMUNITY_PATH", community)
-	configs = strings.ReplaceAll(configs, "PERSONAL_PATH", personal)
-	configs = strings.ReplaceAll(configs, "WORK_PATH", work)
-
-	// locate and set a default pager
-	configs = strings.ReplaceAll(configs, "PAGER_PATH", config.Pager())
-
-	// locate and set a default editor
-	if editor, err := config.Editor(); err == nil {
-		configs = strings.ReplaceAll(configs, "EDITOR_PATH", editor)
-	}
-
-	return configs
-}
-
-// CommentCommunity comments out the community cheatpath block in the config
-// template. This is used when the community cheatsheets directory won't exist
-// (either because the user declined to download them, or because the config
-// is being output as an example).
-func CommentCommunity(configs string, confpath string) string {
-	community, _, _ := cheatsheetDirs(confpath)
-
-	return strings.ReplaceAll(configs,
-		"  - name: community\n"+
-			"    path: "+community+"\n"+
-			"    tags: [ community ]\n"+
-			"    readonly: true",
-		"  #- name: community\n"+
-			"  #  path: "+community+"\n"+
-			"  #  tags: [ community ]\n"+
-			"  #  readonly: true",
-	)
-}

internal/mock/path.go

@@ -0,0 +1,29 @@
+package mock
+
+import (
+	"fmt"
+	"path"
+	"path/filepath"
+	"runtime"
+)
+
+// Path returns the absolute path to the specified mock file.
+func Path(filename string) string {
+
+	// determine the path of this file during runtime
+	_, thisfile, _, _ := runtime.Caller(0)
+
+	// compute the config path
+	file, err := filepath.Abs(
+		path.Join(
+			filepath.Dir(thisfile),
+			"../../mocks",
+			filename,
+		),
+	)
+	if err != nil {
+		panic(fmt.Errorf("failed to resolve config path: %v", err))
+	}
+
+	return file
+}

internal/repo/clone.go

@@ -1,26 +0,0 @@
-// Package repo implements functions pertaining to the management of git repos.
-package repo
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/go-git/go-git/v5"
-)
-
-// Clone clones the community cheatsheets repository to the specified directory
-func Clone(dir string) error {
-
-	// clone the community cheatsheets
-	_, err := git.PlainClone(dir, false, &git.CloneOptions{
-		URL:      "https://github.com/cheat/cheatsheets.git",
-		Depth:    1,
-		Progress: os.Stdout,
-	})
-
-	if err != nil {
-		return fmt.Errorf("failed to clone cheatsheets: %v", err)
-	}
-
-	return nil
-}

internal/repo/clone_integration_test.go

@@ -1,80 +0,0 @@
-//go:build integration
-// +build integration
-
-package repo
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-// TestCloneIntegration performs a real clone operation to verify functionality
-// Run with: go test -tags=integration ./internal/repo -v -run TestCloneIntegration
-func TestCloneIntegration(t *testing.T) {
-	if testing.Short() {
-		t.Skip("Skipping integration test in short mode")
-	}
-
-	// Create a temporary directory
-	tmpDir, err := os.MkdirTemp("", "cheat-clone-integration-*")
-	if err != nil {
-		t.Fatalf("failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	destDir := filepath.Join(tmpDir, "cheatsheets")
-
-	t.Logf("Cloning to: %s", destDir)
-
-	// Perform the actual clone
-	err = Clone(destDir)
-	if err != nil {
-		t.Fatalf("Clone() failed: %v", err)
-	}
-
-	// Verify the clone succeeded
-	info, err := os.Stat(destDir)
-	if err != nil {
-		t.Fatalf("destination directory not created: %v", err)
-	}
-
-	if !info.IsDir() {
-		t.Fatal("destination is not a directory")
-	}
-
-	// Check for .git directory
-	gitDir := filepath.Join(destDir, ".git")
-	if _, err := os.Stat(gitDir); err != nil {
-		t.Error(".git directory not found")
-	}
-
-	// Check for some expected cheatsheets
-	expectedFiles := []string{
-		"bash", // bash cheatsheet should exist
-		"git",  // git cheatsheet should exist
-		"ls",   // ls cheatsheet should exist
-	}
-
-	foundCount := 0
-	for _, file := range expectedFiles {
-		path := filepath.Join(destDir, file)
-		if _, err := os.Stat(path); err == nil {
-			foundCount++
-		}
-	}
-
-	if foundCount < 2 {
-		t.Errorf("expected at least 2 common cheatsheets, found %d", foundCount)
-	}
-
-	t.Log("Clone integration test passed!")
-
-	// Test cloning to existing directory (should fail)
-	err = Clone(destDir)
-	if err == nil {
-		t.Error("expected error when cloning to existing repository, got nil")
-	} else {
-		t.Logf("Expected error when cloning to existing dir: %v", err)
-	}
-}

internal/repo/clone_test.go

@@ -1,53 +0,0 @@
-package repo
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-// TestClone tests the Clone function
-func TestClone(t *testing.T) {
-	// This test requires network access, so we'll only test error cases
-	// that don't require actual cloning
-
-	t.Run("clone to read-only directory", func(t *testing.T) {
-		if runtime.GOOS == "windows" {
-			t.Skip("chmod does not restrict writes on Windows")
-		}
-		if os.Getuid() == 0 {
-			t.Skip("Cannot test read-only directory as root")
-		}
-
-		// Create a temporary directory
-		tempDir, err := os.MkdirTemp("", "cheat-clone-test-*")
-		if err != nil {
-			t.Fatalf("failed to create temp dir: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
-
-		// Create a read-only subdirectory
-		readOnlyDir := filepath.Join(tempDir, "readonly")
-		if err := os.Mkdir(readOnlyDir, 0555); err != nil {
-			t.Fatalf("failed to create read-only dir: %v", err)
-		}
-
-		// Attempt to clone to read-only directory
-		targetDir := filepath.Join(readOnlyDir, "cheatsheets")
-		err = Clone(targetDir)
-
-		// Should fail because we can't write to read-only directory
-		if err == nil {
-			t.Error("expected error when cloning to read-only directory, got nil")
-		}
-	})
-
-	t.Run("clone to invalid path", func(t *testing.T) {
-		// Try to clone to a path with null bytes (invalid on most filesystems)
-		err := Clone("/tmp/invalid\x00path")
-		if err == nil {
-			t.Error("expected error with invalid path, got nil")
-		}
-	})
-}

internal/repo/gitdir.go

@@ -1,125 +0,0 @@
-package repo
-
-import (
-	"fmt"
-	"os"
-	"strings"
-)
-
-// gitSep is the `.git` path component surrounded by path separators.
-// Used to match `.git` as a complete path component, not as a suffix
-// of a directory name (e.g., `personal.git`).
-var gitSep = string(os.PathSeparator) + ".git" + string(os.PathSeparator)
-
-// GitDir returns `true` if we are iterating over a directory contained within
-// a repositories `.git` directory.
-func GitDir(path string) (bool, error) {
-
-	/*
-		A bit of context is called for here, because this functionality has
-		previously caused a number of tricky, subtle bugs.
-
-		Fundamentally, here we are simply trying to avoid walking over the
-		contents of the `.git` directory. Doing so potentially makes
-		hundreds/thousands of needless syscalls, and can noticeably harm
-		performance on machines with slow disks.
-
-		The earliest effort to solve this problem involved simply returning
-		`fs.SkipDir` when the cheatsheet file path began with `.`, signifying a
-		hidden directory. This, however, caused two problems:
-
-		1. The `.cheat` directory was ignored
-		2. Cheatsheets installed by `brew` (which were by default installed to
-		`~/.config/cheat`) were ignored
-
-		See: https://github.com/cheat/cheat/issues/690
-
-		To remedy this, the exclusion criteria were narrowed, and the search
-		for a literal `.` was replaced with a search for a literal `.git`.
-		This, however, broke user installations that stored cheatsheets in
-		`git` submodules, because such an installation would contain a `.git`
-		file that pointed to the upstream repository.
-
-		See: https://github.com/cheat/cheat/issues/694
-
-		The next attempt at solving this was to search for a `.git` literal
-		string in the cheatsheet file path. If a match was not found, we would
-		continue to walk the directory, as before.
-
-		If a match *was* found, we determined whether `.git` referred to a file
-		or directory, and would only stop walking the path in the latter case.
-
-		This, however, caused crashes if a cheatpath contained a `.gitignore`
-		file. (Presumably, a crash would likewise occur on the presence of
-		`.gitattributes`, `.gitmodules`, etc.)
-
-		See: https://github.com/cheat/cheat/issues/699
-
-		Accounting for all of the above, the next solution was to search not
-		for `.git`, but `.git/` (including the directory separator), and then
-		only ceasing to walk the directory on a match.
-
-		This, however, also had a bug: searching for `.git/` also matched
-		directory names that *ended with* `.git`, like `personal.git/`. This
-		caused cheatsheets stored under such paths to be silently skipped.
-
-		See: https://github.com/cheat/cheat/issues/711
-
-		The current (and hopefully final) solution requires the path separator
-		on *both* sides of `.git`, i.e., searching for `/.git/`. This ensures
-		that `.git` is matched only as a complete path component, not as a
-		suffix of a directory name.
-
-		To summarize, this code must account for the following possibilities:
-
-		1. A cheatpath is not a repository
-		2. A cheatpath is a repository
-		3. A cheatpath is a repository, and contains a `.git*` file
-		4. A cheatpath is a submodule
-		5. A cheatpath is a hidden directory
-		6. A cheatpath is inside a directory whose name ends with `.git`
-
-		Care must be taken to support the above on both Unix and Windows
-		systems, which have different directory separators and line-endings.
-
-		NB: `filepath.Walk` always passes absolute paths to the walk function,
-		so `.git` will never appear as the first path component. This is what
-		makes the "separator on both sides" approach safe.
-
-		A reasonable smoke-test for ensuring that skipping is being applied
-		correctly is to run the following command:
-
-		    make && strace ./dist/cheat -l | wc -l
-
-		That check should be run twice: once normally, and once after
-		commenting out the "skip" check in `sheets.Load`.
-
-		The specific line counts don't matter; what matters is that the number
-		of syscalls should be significantly lower with the skip check enabled.
-	*/
-
-	// determine if `.git` appears as a complete path component
-	pos := strings.Index(path, gitSep)
-
-	// if it does not, we know for certain that we are not within a `.git`
-	// directory.
-	if pos == -1 {
-		return false, nil
-	}
-
-	// If `path` does contain the string `.git`, we need to determine if we're
-	// inside of a `.git` directory, or if `path` points to a cheatsheet that's
-	// stored within a `git` submodule.
-	//
-	// See: https://github.com/cheat/cheat/issues/694
-
-	// truncate `path` to the occurrence of `.git`
-	f, err := os.Stat(path[:pos+5])
-	if err != nil {
-		return false, fmt.Errorf("failed to stat path %s: %v", path, err)
-	}
-
-	// return true or false depending on whether the truncated path is a
-	// directory
-	return f.Mode().IsDir(), nil
-}

internal/repo/gitdir_test.go

@@ -1,355 +0,0 @@
-package repo
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-// setupGitDirTestTree creates a temporary directory structure that exercises
-// every case documented in GitDir's comment block. The caller must defer
-// os.RemoveAll on the returned root.
-//
-// Layout:
-//
-//	root/
-//	├── plain/                         # not a repository
-//	│   └── sheet
-//	├── repo/                          # a repository (.git is a directory)
-//	│   ├── .git/
-//	│   │   ├── HEAD
-//	│   │   ├── objects/
-//	│   │   │   └── pack/
-//	│   │   └── refs/
-//	│   │       └── heads/
-//	│   ├── .gitignore
-//	│   ├── .gitattributes
-//	│   └── sheet
-//	├── submodule/                     # a submodule (.git is a file)
-//	│   ├── .git                       # file, not directory
-//	│   └── sheet
-//	├── dotgit-suffix.git/             # directory name ends in .git (#711)
-//	│   └── cheat/
-//	│       └── sheet
-//	├── dotgit-mid.git/                # .git suffix mid-path (#711)
-//	│   └── nested/
-//	│       └── sheet
-//	├── .github/                       # .github directory (not .git)
-//	│   └── workflows/
-//	│       └── ci.yml
-//	└── .hidden/                       # generic hidden directory
-//	    └── sheet
-func setupGitDirTestTree(t *testing.T) string {
-	t.Helper()
-
-	root := t.TempDir()
-
-	dirs := []string{
-		// case 1: not a repository
-		filepath.Join(root, "plain"),
-
-		// case 2: a repository (.git directory with contents)
-		filepath.Join(root, "repo", ".git", "objects", "pack"),
-		filepath.Join(root, "repo", ".git", "refs", "heads"),
-
-		// case 4: a submodule (.git is a file)
-		filepath.Join(root, "submodule"),
-
-		// case 6: directory name ending in .git (#711)
-		filepath.Join(root, "dotgit-suffix.git", "cheat"),
-		filepath.Join(root, "dotgit-mid.git", "nested"),
-
-		// .github (should not be confused with .git)
-		filepath.Join(root, ".github", "workflows"),
-
-		// generic hidden directory
-		filepath.Join(root, ".hidden"),
-	}
-
-	for _, dir := range dirs {
-		if err := os.MkdirAll(dir, 0755); err != nil {
-			t.Fatalf("failed to create dir %s: %v", dir, err)
-		}
-	}
-
-	files := map[string]string{
-		// sheets
-		filepath.Join(root, "plain", "sheet"):                      "plain sheet",
-		filepath.Join(root, "repo", "sheet"):                       "repo sheet",
-		filepath.Join(root, "submodule", "sheet"):                  "submod sheet",
-		filepath.Join(root, "dotgit-suffix.git", "cheat", "sheet"): "dotgit sheet",
-		filepath.Join(root, "dotgit-mid.git", "nested", "sheet"):   "dotgit nested",
-		filepath.Join(root, ".hidden", "sheet"):                    "hidden sheet",
-
-		// git metadata
-		filepath.Join(root, "repo", ".git", "HEAD"):           "ref: refs/heads/main\n",
-		filepath.Join(root, "repo", ".gitignore"):             "*.tmp\n",
-		filepath.Join(root, "repo", ".gitattributes"):         "* text=auto\n",
-		filepath.Join(root, "submodule", ".git"):              "gitdir: ../.git/modules/sub\n",
-		filepath.Join(root, ".github", "workflows", "ci.yml"): "name: CI\n",
-	}
-
-	for path, content := range files {
-		if err := os.WriteFile(path, []byte(content), 0644); err != nil {
-			t.Fatalf("failed to write %s: %v", path, err)
-		}
-	}
-
-	return root
-}
-
-func TestGitDir(t *testing.T) {
-	root := setupGitDirTestTree(t)
-
-	tests := []struct {
-		name string
-		path string
-		want bool
-	}{
-		// Case 1: not a repository — no .git anywhere in path
-		{
-			name: "plain directory, no repo",
-			path: filepath.Join(root, "plain", "sheet"),
-			want: false,
-		},
-
-		// Case 2: a repository — paths *inside* .git/ should be detected
-		{
-			name: "inside .git directory",
-			path: filepath.Join(root, "repo", ".git", "HEAD"),
-			want: true,
-		},
-		{
-			name: "inside .git/objects",
-			path: filepath.Join(root, "repo", ".git", "objects", "pack", "somefile"),
-			want: true,
-		},
-		{
-			name: "inside .git/refs",
-			path: filepath.Join(root, "repo", ".git", "refs", "heads", "main"),
-			want: true,
-		},
-
-		// Case 2 (cont.): files *alongside* .git should NOT be detected
-		{
-			name: "sheet in repo root (beside .git dir)",
-			path: filepath.Join(root, "repo", "sheet"),
-			want: false,
-		},
-
-		// Case 3: .git* files (like .gitignore) should NOT trigger
-		{
-			name: ".gitignore file",
-			path: filepath.Join(root, "repo", ".gitignore"),
-			want: false,
-		},
-		{
-			name: ".gitattributes file",
-			path: filepath.Join(root, "repo", ".gitattributes"),
-			want: false,
-		},
-
-		// Case 4: submodule — .git is a file, not a directory
-		{
-			name: "sheet in submodule (where .git is a file)",
-			path: filepath.Join(root, "submodule", "sheet"),
-			want: false,
-		},
-
-		// Case 6: directory name ends with .git (#711)
-		{
-			name: "sheet under directory ending in .git",
-			path: filepath.Join(root, "dotgit-suffix.git", "cheat", "sheet"),
-			want: false,
-		},
-		{
-			name: "sheet under .git-suffixed dir, nested deeper",
-			path: filepath.Join(root, "dotgit-mid.git", "nested", "sheet"),
-			want: false,
-		},
-
-		// .github directory — must not be confused with .git
-		{
-			name: "file inside .github directory",
-			path: filepath.Join(root, ".github", "workflows", "ci.yml"),
-			want: false,
-		},
-
-		// Hidden directory that is not .git
-		{
-			name: "file inside generic hidden directory",
-			path: filepath.Join(root, ".hidden", "sheet"),
-			want: false,
-		},
-
-		// Path with no .git at all
-		{
-			name: "path with no .git component whatsoever",
-			path: filepath.Join(root, "nonexistent", "file"),
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := GitDir(tt.path)
-			if err != nil {
-				t.Fatalf("GitDir(%q) returned unexpected error: %v", tt.path, err)
-			}
-			if got != tt.want {
-				t.Errorf("GitDir(%q) = %v, want %v", tt.path, got, tt.want)
-			}
-		})
-	}
-}
-
-// TestGitDirWithNestedGitDir tests a repo inside a .git-suffixed parent
-// directory. This is the nastiest combination: a real .git directory that
-// appears *after* a .git suffix in the path.
-func TestGitDirWithNestedGitDir(t *testing.T) {
-	root := t.TempDir()
-
-	// Create: root/cheats.git/repo/.git/HEAD
-	//         root/cheats.git/repo/sheet
-	gitDir := filepath.Join(root, "cheats.git", "repo", ".git")
-	if err := os.MkdirAll(gitDir, 0755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(gitDir, "HEAD"), []byte("ref: refs/heads/main\n"), 0644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(root, "cheats.git", "repo", "sheet"), []byte("content"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	tests := []struct {
-		name string
-		path string
-		want bool
-	}{
-		{
-			name: "sheet beside .git in .git-suffixed parent",
-			path: filepath.Join(root, "cheats.git", "repo", "sheet"),
-			want: false,
-		},
-		{
-			name: "file inside .git inside .git-suffixed parent",
-			path: filepath.Join(root, "cheats.git", "repo", ".git", "HEAD"),
-			want: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := GitDir(tt.path)
-			if err != nil {
-				t.Fatalf("GitDir(%q) returned unexpected error: %v", tt.path, err)
-			}
-			if got != tt.want {
-				t.Errorf("GitDir(%q) = %v, want %v", tt.path, got, tt.want)
-			}
-		})
-	}
-}
-
-// TestGitDirSubmoduleInsideDotGitSuffix tests a submodule (.git file)
-// inside a .git-suffixed parent directory.
-func TestGitDirSubmoduleInsideDotGitSuffix(t *testing.T) {
-	root := t.TempDir()
-
-	// Create: root/personal.git/submod/.git  (file)
-	//         root/personal.git/submod/sheet
-	subDir := filepath.Join(root, "personal.git", "submod")
-	if err := os.MkdirAll(subDir, 0755); err != nil {
-		t.Fatal(err)
-	}
-	// .git as a file (submodule pointer)
-	if err := os.WriteFile(filepath.Join(subDir, ".git"), []byte("gitdir: ../../.git/modules/sub\n"), 0644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(subDir, "sheet"), []byte("content"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	got, err := GitDir(filepath.Join(subDir, "sheet"))
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got {
-		t.Error("GitDir should return false for sheet in submodule under .git-suffixed parent")
-	}
-}
-
-// TestGitDirIntegrationWalk simulates what sheets.Load does: walking a
-// directory tree and checking each path with GitDir. This verifies that
-// the function works correctly in the context of filepath.Walk, which is
-// how it is actually called.
-func TestGitDirIntegrationWalk(t *testing.T) {
-	root := setupGitDirTestTree(t)
-
-	// Walk the tree and collect which paths GitDir says to skip
-	var skipped []string
-	var visited []string
-
-	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if info.IsDir() {
-			return nil
-		}
-
-		isGit, err := GitDir(path)
-		if err != nil {
-			return err
-		}
-		if isGit {
-			skipped = append(skipped, path)
-		} else {
-			visited = append(visited, path)
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("Walk failed: %v", err)
-	}
-
-	// Files inside .git/ should be skipped
-	expectSkipped := []string{
-		filepath.Join(root, "repo", ".git", "HEAD"),
-	}
-	for _, want := range expectSkipped {
-		found := false
-		for _, got := range skipped {
-			if got == want {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Errorf("expected %q to be skipped, but it was not", want)
-		}
-	}
-
-	// Sheets should NOT be skipped — including the #711 case
-	expectVisited := []string{
-		filepath.Join(root, "plain", "sheet"),
-		filepath.Join(root, "repo", "sheet"),
-		filepath.Join(root, "submodule", "sheet"),
-		filepath.Join(root, "dotgit-suffix.git", "cheat", "sheet"),
-		filepath.Join(root, "dotgit-mid.git", "nested", "sheet"),
-		filepath.Join(root, ".hidden", "sheet"),
-	}
-	for _, want := range expectVisited {
-		found := false
-		for _, got := range visited {
-			if got == want {
-				found = true
-				break
-			}
-		}
-		if !found {
-			t.Errorf("expected %q to be visited (not skipped), but it was not found in visited paths", want)
-		}
-	}
-}

internal/sheet/colorize.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/cheat/cheat/internal/config"
 
-	"github.com/alecthomas/chroma/v2/quick"
+	"github.com/alecthomas/chroma/quick"
 )
 
 // Colorize applies syntax-highlighting to a cheatsheet's Text.

internal/sheet/colorize_test.go

@@ -1,42 +0,0 @@
-package sheet
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/cheat/cheat/internal/config"
-)
-
-// TestColorize asserts that syntax-highlighting is correctly applied
-func TestColorize(t *testing.T) {
-
-	// mock configs
-	conf := config.Config{
-		Formatter: "terminal16m",
-		Style:     "solarized-dark",
-	}
-
-	// mock a sheet
-	original := "echo 'foo'"
-	s := Sheet{
-		Text: original,
-	}
-
-	// colorize the sheet text
-	s.Colorize(conf)
-
-	// assert that the text was modified (colorization applied)
-	if s.Text == original {
-		t.Error("Colorize did not modify sheet text")
-	}
-
-	// assert that ANSI escape codes are present
-	if !strings.Contains(s.Text, "\x1b[") && !strings.Contains(s.Text, "[0m") {
-		t.Errorf("colorized text does not contain ANSI escape codes: %q", s.Text)
-	}
-
-	// assert that the original content is still present within the colorized output
-	if !strings.Contains(s.Text, "echo") || !strings.Contains(s.Text, "foo") {
-		t.Errorf("colorized text lost original content: %q", s.Text)
-	}
-}

internal/sheet/copy.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"path/filepath"
+	"path"
 )
 
 // Copy copies a cheatsheet to a new location
@@ -22,7 +22,7 @@ func (s *Sheet) Copy(dest string) error {
 	defer infile.Close()
 
 	// create any necessary subdirectories
-	dirs := filepath.Dir(dest)
+	dirs := path.Dir(dest)
 	if dirs != "." {
 		if err := os.MkdirAll(dirs, 0755); err != nil {
 			return fmt.Errorf("failed to create directory: %s, %v", dirs, err)
@@ -39,8 +39,6 @@ func (s *Sheet) Copy(dest string) error {
 	// copy file contents
 	_, err = io.Copy(outfile, infile)
 	if err != nil {
-		// Clean up the partially written file on error
-		os.Remove(dest)
 		return fmt.Errorf(
 			"failed to copy file: infile: %s, outfile: %s, err: %v",
 			s.Path,

internal/sheet/copy_error_test.go

@@ -1,145 +0,0 @@
-package sheet
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-// TestCopyErrors tests error cases for the Copy method
-func TestCopyErrors(t *testing.T) {
-	tests := []struct {
-		name  string
-		setup func() (*Sheet, string, func())
-	}{
-		{
-			name: "source file does not exist",
-			setup: func() (*Sheet, string, func()) {
-				sheet := &Sheet{
-					Title:     "test",
-					Path:      "/non/existent/file.txt",
-					CheatPath: "test",
-				}
-				dest := filepath.Join(os.TempDir(), "copy-test-dest.txt")
-				cleanup := func() {
-					os.Remove(dest)
-				}
-				return sheet, dest, cleanup
-			},
-		},
-		{
-			name: "destination directory creation fails",
-			setup: func() (*Sheet, string, func()) {
-				src, err := os.CreateTemp("", "copy-test-src-*")
-				if err != nil {
-					t.Fatalf("failed to create temp file: %v", err)
-				}
-				src.WriteString("test content")
-				src.Close()
-
-				sheet := &Sheet{
-					Title:     "test",
-					Path:      src.Name(),
-					CheatPath: "test",
-				}
-
-				blockerFile := filepath.Join(os.TempDir(), "copy-blocker-file")
-				if err := os.WriteFile(blockerFile, []byte("blocker"), 0644); err != nil {
-					t.Fatalf("failed to create blocker file: %v", err)
-				}
-
-				dest := filepath.Join(blockerFile, "subdir", "dest.txt")
-
-				cleanup := func() {
-					os.Remove(src.Name())
-					os.Remove(blockerFile)
-				}
-				return sheet, dest, cleanup
-			},
-		},
-		{
-			name: "destination file creation fails",
-			setup: func() (*Sheet, string, func()) {
-				src, err := os.CreateTemp("", "copy-test-src-*")
-				if err != nil {
-					t.Fatalf("failed to create temp file: %v", err)
-				}
-				src.WriteString("test content")
-				src.Close()
-
-				sheet := &Sheet{
-					Title:     "test",
-					Path:      src.Name(),
-					CheatPath: "test",
-				}
-
-				destDir := filepath.Join(os.TempDir(), "copy-test-dir")
-				if err := os.Mkdir(destDir, 0755); err != nil && !os.IsExist(err) {
-					t.Fatalf("failed to create dest dir: %v", err)
-				}
-
-				cleanup := func() {
-					os.Remove(src.Name())
-					os.RemoveAll(destDir)
-				}
-				return sheet, destDir, cleanup
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			sheet, dest, cleanup := tt.setup()
-			defer cleanup()
-
-			err := sheet.Copy(dest)
-			if err == nil {
-				t.Error("Copy() expected error, got nil")
-			}
-		})
-	}
-}
-
-// TestCopyUnreadableSource verifies that Copy returns an error when the source
-// file cannot be opened (e.g., permission denied).
-func TestCopyUnreadableSource(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("chmod does not restrict reads on Windows")
-	}
-
-	src, err := os.CreateTemp("", "copy-test-unreadable-*")
-	if err != nil {
-		t.Fatalf("failed to create temp file: %v", err)
-	}
-	defer os.Remove(src.Name())
-
-	if _, err := src.WriteString("test content"); err != nil {
-		t.Fatalf("failed to write content: %v", err)
-	}
-	src.Close()
-
-	sheet := &Sheet{
-		Title:     "test",
-		Path:      src.Name(),
-		CheatPath: "test",
-	}
-
-	dest := filepath.Join(os.TempDir(), "copy-unreadable-test.txt")
-	defer os.Remove(dest)
-
-	if err := os.Chmod(src.Name(), 0000); err != nil {
-		t.Skip("Cannot change file permissions on this platform")
-	}
-	defer os.Chmod(src.Name(), 0644)
-
-	err = sheet.Copy(dest)
-	if err == nil {
-		t.Error("expected Copy to fail with permission error")
-	}
-
-	// Destination should not exist since the error occurs before it is created
-	if _, err := os.Stat(dest); !os.IsNotExist(err) {
-		t.Error("destination file should not exist after open failure")
-	}
-}

internal/sheet/copy_test.go

@@ -1,6 +1,7 @@
 package sheet
 
 import (
+	"io/ioutil"
 	"os"
 	"path"
 	"testing"
@@ -12,7 +13,7 @@ func TestCopyFlat(t *testing.T) {
 
 	// mock a cheatsheet file
 	text := "this is the cheatsheet text"
-	src, err := os.CreateTemp("", "foo-src")
+	src, err := ioutil.TempFile("", "foo-src")
 	if err != nil {
 		t.Errorf("failed to mock cheatsheet: %v", err)
 	}
@@ -24,7 +25,7 @@ func TestCopyFlat(t *testing.T) {
 	}
 
 	// mock a cheatsheet struct
-	sheet, err := New("foo", "community", src.Name(), []string{}, false)
+	sheet, err := New("foo", src.Name(), []string{}, false)
 	if err != nil {
 		t.Errorf("failed to init cheatsheet: %v", err)
 	}
@@ -40,7 +41,7 @@ func TestCopyFlat(t *testing.T) {
 	}
 
 	// assert that the destination file contains the correct text
-	got, err := os.ReadFile(outpath)
+	got, err := ioutil.ReadFile(outpath)
 	if err != nil {
 		t.Errorf("failed to read destination file: %v", err)
 	}
@@ -59,7 +60,7 @@ func TestCopyDeep(t *testing.T) {
 
 	// mock a cheatsheet file
 	text := "this is the cheatsheet text"
-	src, err := os.CreateTemp("", "foo-src")
+	src, err := ioutil.TempFile("", "foo-src")
 	if err != nil {
 		t.Errorf("failed to mock cheatsheet: %v", err)
 	}
@@ -71,13 +72,7 @@ func TestCopyDeep(t *testing.T) {
 	}
 
 	// mock a cheatsheet struct
-	sheet, err := New(
-		"/cheat-tests/alpha/bravo/foo",
-		"community",
-		src.Name(),
-		[]string{},
-		false,
-	)
+	sheet, err := New("/cheat-tests/alpha/bravo/foo", src.Name(), []string{}, false)
 	if err != nil {
 		t.Errorf("failed to init cheatsheet: %v", err)
 	}
@@ -93,7 +88,7 @@ func TestCopyDeep(t *testing.T) {
 	}
 
 	// assert that the destination file contains the correct text
-	got, err := os.ReadFile(outpath)
+	got, err := ioutil.ReadFile(outpath)
 	if err != nil {
 		t.Errorf("failed to read destination file: %v", err)
 	}

internal/sheet/parse_extended_test.go

@@ -1,29 +0,0 @@
-package sheet
-
-import (
-	"testing"
-)
-
-// TestParseWindowsLineEndings tests parsing with Windows line endings
-func TestParseWindowsLineEndings(t *testing.T) {
-	// stub our cheatsheet content with Windows line endings
-	markdown := "---\r\nsyntax: go\r\ntags: [ test ]\r\n---\r\nTo foo the bar: baz"
-
-	// parse the frontmatter
-	fm, text, 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)
-	}
-}

internal/sheet/parse_fuzz_test.go

@@ -1,132 +0,0 @@
-package sheet
-
-import (
-	"strings"
-	"testing"
-)
-
-// FuzzParse tests the parse function with fuzzing to uncover edge cases
-// and potential panics in YAML frontmatter parsing
-func FuzzParse(f *testing.F) {
-	// Add seed corpus with various valid and edge case inputs
-	// Valid frontmatter
-	f.Add("---\nsyntax: go\n---\nContent")
-	f.Add("---\ntags: [a, b]\n---\n")
-	f.Add("---\nsyntax: bash\ntags: [linux, shell]\n---\n#!/bin/bash\necho hello")
-
-	// No frontmatter
-	f.Add("No frontmatter here")
-	f.Add("")
-	f.Add("Just plain text\nwith multiple lines")
-
-	// Edge cases with delimiters
-	f.Add("---")
-	f.Add("---\n")
-	f.Add("---\n---")
-	f.Add("---\n---\n")
-	f.Add("---\n---\n---")
-	f.Add("---\n---\n---\n---")
-	f.Add("------\n------")
-
-	// Invalid YAML
-	f.Add("---\n{invalid yaml\n---\n")
-	f.Add("---\nsyntax: \"unclosed quote\n---\n")
-	f.Add("---\ntags: [a, b,\n---\n")
-
-	// Windows line endings
-	f.Add("---\r\nsyntax: go\r\n---\r\nContent")
-	f.Add("---\r\n---\r\n")
-
-	// Mixed line endings
-	f.Add("---\nsyntax: go\r\n---\nContent")
-	f.Add("---\r\nsyntax: go\n---\r\nContent")
-
-	// Unicode and special characters
-	f.Add("---\ntags: [emoji, 🎉]\n---\n")
-	f.Add("---\nsyntax: 中文\n---\n")
-	f.Add("---\ntags: [\x00, \x01]\n---\n")
-
-	// Very long inputs
-	f.Add("---\ntags: [" + strings.Repeat("a,", 1000) + "a]\n---\n")
-	f.Add("---\n" + strings.Repeat("field: value\n", 1000) + "---\n")
-
-	// Nested structures
-	f.Add("---\ntags:\n  - nested\n  - list\n---\n")
-	f.Add("---\nmeta:\n  author: test\n  version: 1.0\n---\n")
-
-	f.Fuzz(func(t *testing.T, input string) {
-		// The parse function should never panic, regardless of input
-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					t.Errorf("parse panicked with input %q: %v", input, r)
-				}
-			}()
-
-			fm, text, err := parse(input)
-
-			// Verify invariants
-			if err == nil {
-				// If parsing succeeded, validate the result
-
-				// The returned text should be a suffix of the input
-				// (either the whole input if no frontmatter, or the part after frontmatter)
-				if !strings.HasSuffix(input, text) && text != input {
-					t.Errorf("returned text %q is not a valid suffix of input %q", text, input)
-				}
-
-				// If input starts with delimiter and has valid frontmatter,
-				// text should be shorter than input
-				if strings.HasPrefix(input, "---\n") || strings.HasPrefix(input, "---\r\n") {
-					if len(fm.Tags) > 0 || fm.Syntax != "" {
-						// We successfully parsed frontmatter, so text should be shorter
-						if len(text) >= len(input) {
-							t.Errorf("text length %d should be less than input length %d when frontmatter is parsed",
-								len(text), len(input))
-						}
-					}
-				}
-
-				// Note: Tags can be nil when frontmatter is not present or empty
-				// This is expected behavior in Go for uninitialized slices
-			} else {
-				// If parsing failed, the original input should be returned as text
-				if text != input {
-					t.Errorf("on error, text should equal input: got %q, want %q", text, input)
-				}
-			}
-		}()
-	})
-}
-
-// FuzzParseDelimiterHandling specifically tests delimiter edge cases
-func FuzzParseDelimiterHandling(f *testing.F) {
-	// Seed corpus focusing on delimiter variations
-	f.Add("---", "content")
-	f.Add("", "---")
-	f.Add("---", "---")
-	f.Add("", "")
-
-	f.Fuzz(func(t *testing.T, prefix string, suffix string) {
-		// Build input with controllable parts around delimiters
-		inputs := []string{
-			prefix + "---\n" + suffix,
-			prefix + "---\r\n" + suffix,
-			prefix + "---\n---\n" + suffix,
-			prefix + "---\r\n---\r\n" + suffix,
-			prefix + "---\n" + "yaml: data\n" + "---\n" + suffix,
-		}
-
-		for _, input := range inputs {
-			func() {
-				defer func() {
-					if r := recover(); r != nil {
-						t.Errorf("parse panicked with constructed input: %v", r)
-					}
-				}()
-
-				_, _, _ = parse(input)
-			}()
-		}
-	})
-}

internal/sheet/search.go

@@ -9,17 +9,16 @@ import (
 func (s *Sheet) Search(reg *regexp.Regexp) string {
 
 	// record matches
-	var matches []string
+	matches := ""
 
 	// search through the cheatsheet's text line by line
 	for _, line := range strings.Split(s.Text, "\n\n") {
 
-		// save matching lines
+		// exit early if the line doesn't match the regex
 		if reg.MatchString(line) {
-			matches = append(matches, line)
+			matches += line + "\n\n"
 		}
 	}
 
-	// Join matches with the same delimiter used for splitting
-	return strings.Join(matches, "\n\n")
+	return strings.TrimSpace(matches)
 }

internal/sheet/search_fuzz_test.go

@@ -1,124 +0,0 @@
-package sheet
-
-import (
-	"regexp"
-	"strings"
-	"testing"
-	"time"
-)
-
-// FuzzSearchRegex tests the regex compilation and search functionality
-// to ensure it handles malformed patterns gracefully and doesn't suffer
-// from catastrophic backtracking
-func FuzzSearchRegex(f *testing.F) {
-	// Add seed corpus with various regex patterns
-	// Valid patterns
-	f.Add("test", "This is a test string")
-	f.Add("(?i)test", "This is a TEST string")
-	f.Add("foo|bar", "foo and bar")
-	f.Add("^start", "start of line\nnext line")
-	f.Add("end$", "at the end\nnext line")
-	f.Add("\\d+", "123 numbers 456")
-	f.Add("[a-z]+", "lowercase UPPERCASE")
-
-	// Edge cases and potentially problematic patterns
-	f.Add("", "empty pattern")
-	f.Add(".", "any character")
-	f.Add(".*", "match everything")
-	f.Add(".+", "match something")
-	f.Add("\\", "backslash")
-	f.Add("(", "unclosed paren")
-	f.Add(")", "unmatched paren")
-	f.Add("[", "unclosed bracket")
-	f.Add("]", "unmatched bracket")
-	f.Add("[^]", "negated empty class")
-	f.Add("(?", "incomplete group")
-
-	// Patterns that might cause performance issues
-	f.Add("(a+)+", "aaaaaaaaaaaaaaaaaaaaaaaab")
-	f.Add("(a*)*", "aaaaaaaaaaaaaaaaaaaaaaaab")
-	f.Add("(a|a)*", "aaaaaaaaaaaaaaaaaaaaaaaab")
-	f.Add("(.*)*", "any text here")
-	f.Add("(\\d+)+", "123456789012345678901234567890x")
-
-	// Unicode patterns
-	f.Add("☺", "Unicode ☺ smiley")
-	f.Add("[一-龯]", "Chinese 中文 characters")
-	f.Add("\\p{L}+", "Unicode letters")
-
-	// Very long patterns
-	f.Add(strings.Repeat("a", 1000), "long pattern")
-	f.Add(strings.Repeat("(a|b)", 100), "complex pattern")
-
-	f.Fuzz(func(t *testing.T, pattern string, text string) {
-		// Test 1: Regex compilation should not panic
-		var reg *regexp.Regexp
-		var compileErr error
-
-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					t.Errorf("regexp.Compile panicked with pattern %q: %v", pattern, r)
-				}
-			}()
-
-			reg, compileErr = regexp.Compile(pattern)
-		}()
-
-		// If compilation failed, that's OK - we're testing error handling
-		if compileErr != nil {
-			// This is expected for invalid patterns
-			return
-		}
-
-		// Test 2: Create a sheet and test Search method
-		sheet := Sheet{
-			Title: "test",
-			Text:  text,
-		}
-
-		// Search should not panic
-		var result string
-		done := make(chan bool, 1)
-
-		go func() {
-			defer func() {
-				if r := recover(); r != nil {
-					t.Errorf("Search panicked with pattern %q on text %q: %v", pattern, text, r)
-				}
-				done <- true
-			}()
-
-			result = sheet.Search(reg)
-		}()
-
-		// Timeout after 100ms to catch catastrophic backtracking
-		select {
-		case <-done:
-			// Search completed successfully
-		case <-time.After(100 * time.Millisecond):
-			t.Errorf("Search timed out (possible catastrophic backtracking) with pattern %q on text %q", pattern, text)
-		}
-
-		// Test 3: Verify search result invariants
-		if result != "" {
-			// The Search function splits by "\n\n", so we need to compare using the same logic
-			resultLines := strings.Split(result, "\n\n")
-			textLines := strings.Split(text, "\n\n")
-
-			// Every result line should exist in the original text lines
-			for _, rLine := range resultLines {
-				found := false
-				for _, tLine := range textLines {
-					if rLine == tLine {
-						found = true
-						break
-					}
-				}
-				if !found && rLine != "" {
-					t.Errorf("Search result contains line not in original text: %q", rLine)
-				}
-			}
-		}
-	})
-}

internal/sheet/sheet.go

@@ -1,23 +1,16 @@
-// Package sheet implements functions pertaining to parsing, searching, and
-// displaying cheatsheets.
 package sheet
 
 import (
 	"fmt"
-	"os"
+	"io/ioutil"
 	"sort"
-)
 
-// Frontmatter encapsulates cheatsheet frontmatter data
-type frontmatter struct {
-	Tags   []string
-	Syntax string
-}
+	"github.com/cheat/cheat/internal/frontmatter"
+)
 
 // Sheet encapsulates sheet information
 type Sheet struct {
 	Title    string
-	CheatPath string
 	Path     string
 	Text     string
 	Tags     []string
@@ -28,20 +21,19 @@ type Sheet struct {
 // New initializes a new Sheet
 func New(
 	title string,
-	cheatpath string,
 	path string,
 	tags []string,
 	readOnly bool,
 ) (Sheet, error) {
 
 	// read the cheatsheet file
-	markdown, err := os.ReadFile(path)
+	markdown, err := ioutil.ReadFile(path)
 	if err != nil {
 		return Sheet{}, fmt.Errorf("failed to read file: %s, %v", path, err)
 	}
 
-	// parse the raw cheatsheet text
-	fm, text, err := parse(string(markdown))
+	// parse the cheatsheet frontmatter
+	text, fm, err := frontmatter.Parse(string(markdown))
 	if err != nil {
 		return Sheet{}, fmt.Errorf("failed to parse front-matter: %v", err)
 	}
@@ -55,9 +47,8 @@ func New(
 	// initialize and return a sheet
 	return Sheet{
 		Title:    title,
-		CheatPath: cheatpath,
 		Path:     path,
-		Text:      text,
+		Text:     text + "\n",
 		Tags:     tags,
 		Syntax:   fm.Syntax,
 		ReadOnly: readOnly,

internal/sheet/sheet_test.go

@@ -4,7 +4,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/cheat/cheat/mocks"
+	"github.com/cheat/cheat/internal/mock"
 )
 
 // TestSheetSuccess asserts that sheets initialize properly
@@ -13,8 +13,7 @@ func TestSheetSuccess(t *testing.T) {
 	// initialize a sheet
 	sheet, err := New(
 		"foo",
-		"community",
-		mocks.Path("sheet/foo"),
+		mock.Path("sheet/foo"),
 		[]string{"alpha", "bravo"},
 		false,
 	)
@@ -27,10 +26,10 @@ func TestSheetSuccess(t *testing.T) {
 		t.Errorf("failed to init title: want: foo, got: %s", sheet.Title)
 	}
 
-	if sheet.Path != mocks.Path("sheet/foo") {
+	if sheet.Path != mock.Path("sheet/foo") {
 		t.Errorf(
 			"failed to init path: want: %s, got: %s",
-			mocks.Path("sheet/foo"),
+			mock.Path("sheet/foo"),
 			sheet.Path,
 		)
 	}
@@ -62,8 +61,7 @@ func TestSheetFailure(t *testing.T) {
 	// initialize a sheet
 	_, err := New(
 		"foo",
-		"community",
-		mocks.Path("/does-not-exist"),
+		mock.Path("/does-not-exist"),
 		[]string{"alpha", "bravo"},
 		false,
 	)
@@ -71,20 +69,3 @@ func TestSheetFailure(t *testing.T) {
 		t.Errorf("failed to return an error on unreadable sheet")
 	}
 }
-
-// TestSheetFrontMatterFailure asserts that an error is returned if the sheet's
-// frontmatter cannot be parsed.
-func TestSheetFrontMatterFailure(t *testing.T) {
-
-	// initialize a sheet
-	_, err := New(
-		"foo",
-		"community",
-		mocks.Path("sheet/bad-fm"),
-		[]string{"alpha", "bravo"},
-		false,
-	)
-	if err == nil {
-		t.Errorf("failed to return an error on malformed front-matter")
-	}
-}

internal/sheet/tagged.go

@@ -1,8 +1,15 @@
 package sheet
 
-import "slices"
-
 // Tagged returns true if a sheet was tagged with `needle`
 func (s *Sheet) Tagged(needle string) bool {
-	return slices.Contains(s.Tags, needle)
+
+	// if any of the tags match `needle`, return `true`
+	for _, tag := range s.Tags {
+		if tag == needle {
+			return true
+		}
+	}
+
+	// otherwise, return `false`
+	return false
 }

internal/sheet/tagged_fuzz_test.go

@@ -1,94 +0,0 @@
-package sheet
-
-import (
-	"strings"
-	"testing"
-)
-
-// FuzzTagged tests the Tagged function with potentially malicious tag inputs
-//
-// Threat model: An attacker crafts a malicious cheatsheet with specially
-// crafted tags that could cause issues when a user searches/filters by tags.
-// This is particularly relevant for shared community cheatsheets.
-func FuzzTagged(f *testing.F) {
-	// Add seed corpus with potentially problematic inputs
-	// These represent tags an attacker might use in a malicious cheatsheet
-	f.Add("normal", "normal")
-	f.Add("", "")
-	f.Add(" ", " ")
-	f.Add("\n", "\n")
-	f.Add("\r\n", "\r\n")
-	f.Add("\x00", "\x00")                         // Null byte
-	f.Add("../../etc/passwd", "../../etc/passwd") // Path traversal attempt
-	f.Add("'; DROP TABLE sheets;--", "sql")       // SQL injection attempt
-	f.Add("<script>alert('xss')</script>", "xss") // XSS attempt
-	f.Add("${HOME}", "${HOME}")                   // Environment variable
-	f.Add("$(whoami)", "$(whoami)")               // Command substitution
-	f.Add("`date`", "`date`")                     // Command substitution
-	f.Add("\\x41\\x42", "\\x41\\x42")             // Escape sequences
-	f.Add("%00", "%00")                           // URL encoded null
-	f.Add("tag\nwith\nnewlines", "tag")
-	f.Add(strings.Repeat("a", 10000), "a") // Very long tag
-	f.Add("🎉", "🎉")                        // Unicode
-	f.Add("\U0001F4A9", "\U0001F4A9")      // Unicode poop emoji
-	f.Add("tag with spaces", "tag with spaces")
-	f.Add("TAG", "tag") // Case sensitivity check
-	f.Add("tag", "TAG") // Case sensitivity check
-
-	f.Fuzz(func(t *testing.T, sheetTag string, searchTag string) {
-		// Create a sheet with the potentially malicious tag
-		sheet := Sheet{
-			Title: "test",
-			Tags:  []string{sheetTag},
-		}
-
-		// The Tagged function should never panic regardless of input
-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					t.Errorf("Tagged panicked with sheetTag=%q, searchTag=%q: %v",
-						sheetTag, searchTag, r)
-				}
-			}()
-
-			result := sheet.Tagged(searchTag)
-
-			// Verify the result is consistent with a simple string comparison
-			expected := false
-			for _, tag := range sheet.Tags {
-				if tag == searchTag {
-					expected = true
-					break
-				}
-			}
-
-			if result != expected {
-				t.Errorf("Tagged returned %v but expected %v for sheetTag=%q, searchTag=%q",
-					result, expected, sheetTag, searchTag)
-			}
-
-			// Additional invariant: Tagged should be case-sensitive
-			if sheetTag != searchTag && result {
-				t.Errorf("Tagged matched different strings: sheetTag=%q, searchTag=%q",
-					sheetTag, searchTag)
-			}
-		}()
-
-		// Test with multiple tags including the fuzzed one
-		sheetMulti := Sheet{
-			Title: "test",
-			Tags:  []string{"safe1", sheetTag, "safe2", sheetTag}, // Duplicate tags
-		}
-
-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					t.Errorf("Tagged panicked with multiple tags including %q: %v",
-						sheetTag, r)
-				}
-			}()
-
-			_ = sheetMulti.Tagged(searchTag)
-		}()
-	})
-}

internal/sheet/testdata/fuzz/FuzzSearchCatastrophicBacktracking/3ad1cae1b78a2478

@@ -1,4 +0,0 @@
-go test fuzz v1
-string("0")
-int(-6)
-int(5)

internal/sheet/testdata/fuzz/FuzzSearchRegex/74c0a5e8e3464bfd

@@ -1,3 +0,0 @@
-go test fuzz v1
-string(".")
-string(" 0000\n\n\n\n00000")

internal/sheet/validate.go

@@ -1,40 +0,0 @@
-package sheet
-
-import (
-	"fmt"
-	"path/filepath"
-	"strings"
-)
-
-// Validate ensures that a cheatsheet name does not contain
-// directory traversal sequences or other potentially dangerous patterns.
-func Validate(name string) error {
-	// Reject empty names
-	if name == "" {
-		return fmt.Errorf("cheatsheet name cannot be empty")
-	}
-
-	// Reject names containing directory traversal
-	if strings.Contains(name, "..") {
-		return fmt.Errorf("cheatsheet name cannot contain '..'")
-	}
-
-	// Reject absolute paths
-	if filepath.IsAbs(name) {
-		return fmt.Errorf("cheatsheet name cannot be an absolute path")
-	}
-
-	// Reject names that start with ~ (home directory expansion)
-	if strings.HasPrefix(name, "~") {
-		return fmt.Errorf("cheatsheet name cannot start with '~'")
-	}
-
-	// Reject hidden files (files that start with a dot)
-	// We don't display hidden files, so we shouldn't create them
-	filename := filepath.Base(name)
-	if strings.HasPrefix(filename, ".") {
-		return fmt.Errorf("cheatsheet name cannot start with '.' (hidden files are not supported)")
-	}
-
-	return nil
-}

internal/sheet/validate_fuzz_test.go

@@ -1,169 +0,0 @@
-package sheet
-
-import (
-	"strings"
-	"testing"
-	"unicode/utf8"
-)
-
-// FuzzValidate tests the Validate function with fuzzing
-// to ensure it properly prevents path traversal and other security issues
-func FuzzValidate(f *testing.F) {
-	// Add seed corpus with various valid and malicious inputs
-	// Valid names
-	f.Add("docker")
-	f.Add("docker/compose")
-	f.Add("lang/go/slice")
-	f.Add("my-cheat_sheet")
-	f.Add("file.txt")
-	f.Add("a")
-	f.Add("123")
-
-	// Path traversal attempts
-	f.Add("..")
-	f.Add("../etc/passwd")
-	f.Add("foo/../bar")
-	f.Add("foo/../../etc/passwd")
-	f.Add("..\\windows\\system32")
-	f.Add("foo\\..\\..\\windows")
-
-	// Encoded traversal attempts
-	f.Add("%2e%2e")
-	f.Add("%2e%2e%2f")
-	f.Add("..%2f")
-	f.Add("%2e.")
-	f.Add(".%2e")
-	f.Add("\x2e\x2e")
-	f.Add("\\x2e\\x2e")
-
-	// Unicode and special characters
-	f.Add("€test")
-	f.Add("test€")
-	f.Add("中文")
-	f.Add("🎉emoji")
-	f.Add("\x00null")
-	f.Add("test\x00null")
-	f.Add("\nnewline")
-	f.Add("test\ttab")
-
-	// Absolute paths
-	f.Add("/etc/passwd")
-	f.Add("C:\\Windows\\System32")
-	f.Add("\\\\server\\share")
-	f.Add("//server/share")
-
-	// Home directory
-	f.Add("~")
-	f.Add("~/config")
-	f.Add("~user/file")
-
-	// Hidden files
-	f.Add(".hidden")
-	f.Add("dir/.hidden")
-	f.Add(".git/config")
-
-	// Edge cases
-	f.Add("")
-	f.Add(" ")
-	f.Add("  ")
-	f.Add("\t")
-	f.Add(".")
-	f.Add("./")
-	f.Add("./file")
-	f.Add(".../")
-	f.Add("...")
-	f.Add("....")
-
-	// Very long names
-	f.Add(strings.Repeat("a", 255))
-	f.Add(strings.Repeat("a/", 100) + "file")
-	f.Add(strings.Repeat("../", 50) + "etc/passwd")
-
-	f.Fuzz(func(t *testing.T, input string) {
-		// The function should never panic
-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					t.Errorf("Validate panicked with input %q: %v", input, r)
-				}
-			}()
-
-			err := Validate(input)
-
-			// Security invariants that must always hold
-			if err == nil {
-				// If validation passed, verify security properties
-
-				// Should not contain ".." for path traversal
-				if strings.Contains(input, "..") {
-					t.Errorf("validation passed but input contains '..': %q", input)
-				}
-
-				// Should not be empty
-				if input == "" {
-					t.Error("validation passed for empty input")
-				}
-
-				// Should not start with ~ (home directory)
-				if strings.HasPrefix(input, "~") {
-					t.Errorf("validation passed but input starts with '~': %q", input)
-				}
-
-				// Base filename should not start with .
-				parts := strings.Split(input, "/")
-				if len(parts) > 0 {
-					lastPart := parts[len(parts)-1]
-					if strings.HasPrefix(lastPart, ".") && lastPart != "." {
-						t.Errorf("validation passed but filename starts with '.': %q", input)
-					}
-				}
-
-				// Additional check: result should be valid UTF-8
-				if !utf8.ValidString(input) {
-					// While the function doesn't explicitly check this,
-					// we want to ensure it handles invalid UTF-8 gracefully
-					t.Logf("validation passed for invalid UTF-8: %q", input)
-				}
-			}
-		}()
-	})
-}
-
-// FuzzValidatePathTraversal specifically targets path traversal bypasses
-func FuzzValidatePathTraversal(f *testing.F) {
-	// Seed corpus focusing on path traversal variations
-	f.Add("..", "/", "")
-	f.Add("", "..", "/")
-	f.Add("a", "b", "c")
-
-	f.Fuzz(func(t *testing.T, prefix string, middle string, suffix string) {
-		// Construct various path traversal attempts
-		inputs := []string{
-			prefix + ".." + suffix,
-			prefix + "/.." + suffix,
-			prefix + "\\.." + suffix,
-			prefix + middle + ".." + suffix,
-			prefix + "../" + middle + suffix,
-			prefix + "..%2f" + suffix,
-			prefix + "%2e%2e" + suffix,
-			prefix + "%2e%2e%2f" + suffix,
-		}
-
-		for _, input := range inputs {
-			func() {
-				defer func() {
-					if r := recover(); r != nil {
-						t.Errorf("Validate panicked with constructed input %q: %v", input, r)
-					}
-				}()
-
-				err := Validate(input)
-
-				// If the input contains literal "..", it must be rejected
-				if strings.Contains(input, "..") && err == nil {
-					t.Errorf("validation incorrectly passed for input containing '..': %q", input)
-				}
-			}()
-		}
-	})
-}