Merge branch 'master' into master

.gitignore

@@ -1,4 +1,7 @@
+*.log
 *.pyc
+.env
+.vagrant
 MANIFEST
 build
 cheat.egg-info

README.md

@@ -83,37 +83,47 @@ with your [dotfiles][].
 Configuring
 -----------
 
-### Setting a DEFAULT_CHEAT_DIR ###
+### Setting a CHEAT_USER_DIR ###
 Personal cheatsheets are saved in the `~/.cheat` directory by default, but you
-can specify a different default by exporting a `DEFAULT_CHEAT_DIR` environment
+can specify a different default by exporting a `CHEAT_USER_DIR` environment
 variable:
 
 ```sh
-export DEFAULT_CHEAT_DIR='/path/to/my/cheats'
+export CHEAT_USER_DIR='/path/to/my/cheats'
 ```
 
-### Setting a CHEATPATH ###
+### Setting a CHEAT_PATH ###
 You can additionally instruct `cheat` to look for cheatsheets in other
-directories by exporting a `CHEATPATH` environment variable:
+directories by exporting a `CHEAT_PATH` environment variable:
 
 ```sh
-export CHEATPATH='/path/to/my/cheats'
+export CHEAT_PATH='/path/to/my/cheats'
 ```
 
-You may, of course, append multiple directories to your `CHEATPATH`:
+You may, of course, append multiple directories to your `CHEAT_PATH`:
 
 ```sh
-export CHEATPATH="$CHEATPATH:/path/to/more/cheats"
+export CHEAT_PATH="$CHEAT_PATH:/path/to/more/cheats"
 ```
 
-You may view which directories are on your `CHEATPATH` with `cheat -d`.
+You may view which directories are on your `CHEAT_PATH` with `cheat -d`.
 
 ### Enabling Syntax Highlighting ###
-`cheat` can optionally apply syntax highlighting to your cheatsheets. To enable
-syntax highlighting, export a `CHEATCOLORS` environment variable:
+`cheat` can optionally apply syntax highlighting to your cheatsheets. To
+enable syntax highlighting, export a `CHEAT_COLORS` environment variable:
 
 ```sh
-export CHEATCOLORS=true
+export CHEAT_COLORS=true
+```
+
+Note that [pygments][] must be installed on your system for this to work.
+
+`cheat` ships with both light and dark colorschemes to support terminals with
+different background colors. A colorscheme may be selected via the
+`CHEAT_COLORSCHEME` envvar:
+
+```sh
+export CHEAT_COLORSCHEME=light # must be 'light' (default) or 'dark'
 ```
 
 #### Specifying a Syntax Highlighter ####
@@ -134,6 +144,23 @@ WHERE id = 100
 If no syntax highlighter is specified, the `bash` highlighter will be used by
 default.
 
+### Enabling Search Match Highlighting ###
+`cheat` can optionally be configured to highlight search term matches in search
+results. To do so, export a `CHEAT_HIGHLIGHT` environment variable with a value
+of one of the following:
+
+- blue
+- cyan
+- green
+- grey
+- magenta
+- red
+- white
+- yellow
+
+Note that the `termcolor` module must be installed on your system for this to
+work.
+
 
 See Also:
 ---------
@@ -141,8 +168,9 @@ See Also:
 - [Related Projects][related-projects]
 
 
-[autocompletion]:   https://github.com/chrisallenlane/cheat/wiki/Enabling-Command-line-Autocompletion
+[autocompletion]:   https://github.com/cheat/cheat/wiki/Enabling-Command-line-Autocompletion
 [dotfiles]:         http://dotfiles.github.io/
 [gfm]:              https://help.github.com/articles/creating-and-highlighting-code-blocks/
-[installing]:       https://github.com/chrisallenlane/cheat/wiki/Installing
-[related-projects]: https://github.com/chrisallenlane/cheat/wiki/Related-Projects
+[installing]:       https://github.com/cheat/cheat/wiki/Installing
+[pygments]:         http://pygments.org/
+[related-projects]: https://github.com/cheat/cheat/wiki/Related-Projects

Vagrantfile

@@ -0,0 +1,17 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "ubuntu/bionic64"
+
+  config.vm.provider "virtualbox" do |vb|
+    vb.memory = "512"
+  end
+
+  config.vm.provision "shell", inline: <<-SHELL
+     sudo apt-get update
+     sudo apt-get install -y python-pip
+     su vagrant && sudo -H pip install docopt pygments termcolor flake8
+     cd /vagrant && sudo python setup.py install
+  SHELL
+end

bin/cheat

@@ -13,7 +13,7 @@ Usage:
   cheat -v
 
 Options:
-  -d --directories  List directories on CHEATPATH
+  -d --directories  List directories on $CHEAT_PATH
   -e --edit         Edit cheatsheet
   -l --list         List cheatsheets
   -s --search       Search cheatsheets for <keyword>
@@ -35,31 +35,71 @@ Examples:
 """
 
 # require the dependencies
-from cheat import sheets, sheet
-from cheat.utils import colorize
+from __future__ import print_function
+from cheat.colorize import Colorize
+from cheat.configuration import Configuration
+from cheat.sheet import Sheet
+from cheat.sheets import Sheets
+from cheat.utils import Utils
 from docopt import docopt
-
+import os
 
 if __name__ == '__main__':
+
     # parse the command-line options
-    options = docopt(__doc__, version='cheat 2.2.3')
+    options = docopt(__doc__, version='cheat 2.5.1')
+
+    # initialize and validate configs
+    config = Configuration()
+    config.validate()
+
+    # create the CHEAT_USER_DIR if it does not exist
+    if not os.path.isdir(config.cheat_user_dir):
+        try:
+            os.mkdir(config.cheat_user_dir)
+
+        except OSError:
+            Utils.die("%s %s %s" % (
+                'Could not create CHEAT_USER_DIR (',
+                config.cheat_user_dir,
+                ')')
+            )
+
+    # assert that the CHEAT_USER_DIR is readable and writable
+    if not os.access(config.cheat_user_dir, os.R_OK):
+        Utils.die("%s %s %s" % (
+            'The CHEAT_USER_DIR (',
+            config.cheat_user_dir,
+            ') is not readable')
+        )
+    if not os.access(config.cheat_user_dir, os.W_OK):
+        Utils.die("%s %s %s" % (
+            'The CHEAT_USER_DIR (',
+            config.cheat_user_dir,
+            ') is not writeable')
+        )
+
+    # bootsrap
+    sheets = Sheets(config)
+    sheet = Sheet(config, sheets)
+    colorize = Colorize(config)
 
     # list directories
     if options['--directories']:
-        print("\n".join(sheets.paths()))
+        print("\n".join(sheets.directories()))
 
     # list cheatsheets
     elif options['--list']:
-        print(sheets.list())
+        print(sheets.list(), end="")
 
     # create/edit cheatsheet
     elif options['--edit']:
-        sheet.create_or_edit(options['<cheatsheet>'])
+        sheet.edit(options['<cheatsheet>'])
 
     # search among the cheatsheets
     elif options['--search']:
-        print(colorize(sheets.search(options['<keyword>'])))
+        print(colorize.syntax(sheets.search(options['<keyword>'])), end="")
 
     # print the cheatsheet
     else:
-        print(colorize(sheet.read(options['<cheatsheet>'])))
+        print(colorize.syntax(sheet.read(options['<cheatsheet>'])), end="")

bin/cheat.bat

@@ -0,0 +1,8 @@
+@echo OFF
+
+if not defined CHEAT_EDITOR if not defined EDITOR if not defined VISUAL (
+    set CHEAT_EDITOR=write
+)
+
+REM %~dp0 is black magic for getting directory of script
+python %~dp0cheat %*

cheat/__init__.py

@@ -1,3 +0,0 @@
-from . import sheet
-from . import sheets
-from . import utils

cheat/cheatsheets/__init__.py

@@ -1,4 +0,0 @@
-import os
-
-def sheets_dir():
-  return os.path.split(__file__)

cheat/cheatsheets/convert

@@ -15,5 +15,5 @@ convert original-image.jpg -resize 100x converted-image.png
 for file in `ls original/image/path/`;
     do new_path=${file%.*};
     new_file=`basename $new_path`;
-    convert $file -resize 150 conerted/image/path/$new_file.png;
+    convert $file -resize 150 converted/image/path/$new_file.png;
 done

cheat/cheatsheets/curl

@@ -29,7 +29,7 @@ curl -C - -o partial_file.zip http://example.com/file.zip
 curl -I http://example.com
 
 # Fetch your external IP and network info as JSON
-curl http://ifconfig.me/all/json
+curl http://ifconfig.me/all.json
 
 # Limit the rate of a download
 curl --limit-rate 1000B -O http://path.to.the/file

cheat/cheatsheets/for

@@ -10,8 +10,26 @@ do
   echo $var
 done
 
+# loop over all the JPG files in the current directory
+for jpg_file in *.jpg
+do
+  echo $jpg_file
+done
+
 # loop specified number of times
 for i in `seq 1 10`
 do
   echo $i
 done
+
+# loop specified number of times: the C/C++ style
+for ((i=1;i<=10;++i))
+do
+  echo $i
+done
+
+# loop specified number of times: the brace expansion
+for i in {1..10}
+do
+  echo $i
+done

cheat/cheatsheets/gcc

@@ -10,7 +10,7 @@ gcc -g
 # Debug with all symbols.
 gcc -ggdb3
 
-# Build for 64 bytes
+# Build for 64 bits
 gcc -m64
 
 # Include the directory {/usr/include/myPersonnal/lib/} to the list of path for #include <....>

cheat/cheatsheets/lsblk

@@ -0,0 +1,21 @@
+# Show all available block devices along with their partitioning schemes
+lsblk
+
+# To show SCSI devices:
+lsblk --scsi
+
+# To show a specific device
+lsblk /dev/sda
+
+# To verify TRIM support:
+# Check the values of DISC-GRAN (discard granularity) and DISC-MAX (discard max bytes) columns.
+# Non-zero values indicate TRIM support
+lsblk --discard
+
+# To featch info about filesystems:
+lsblk --fs
+
+# For JSON, LIST or TREE output formats use the following flags:
+lsblk --json
+lsblk --list
+lsblk --tree # default view

cheat/cheatsheets/markdown

@@ -38,7 +38,7 @@ This is [an example](http://example.com "Title") inline link.
 # image
 ![Alt Text](/path/to/file.png)
 
-# emphasis
+# formatting
 *em* _em_
-
 **strong** __strong__
+~~strikethrough~~

cheat/cheatsheets/mv

@@ -12,3 +12,6 @@ mv -i ~/Desktop/foo.txt ~/Documents/foo.txt
 # Move a file from one place to another but never overwrite anything
 # (This will override any previous -f or -i args)
 mv -n ~/Desktop/foo.txt ~/Documents/foo.txt
+
+# Move listed files to a directory
+mv -t ~/Desktop/ file1 file2 file3

cheat/cheatsheets/nmcli

@@ -34,7 +34,10 @@ nmcli dev status
 # Add a dynamic ethernet connection - parameters:
 #	<name> -- the name of the connection
 #	<iface_name> -- the name of the interface
-ncmli con add type ethernet con-name <name> ifname <iface_name>
+nmcli con add type ethernet con-name <name> ifname <iface_name>
+
+# Import OpenVPN connection settings from file:
+nmcli con import type openvpn file <path_to_ovpn_file>
 
 # Bring up the ethernet connection
 nmcli con up <name>

cheat/cheatsheets/pacman

@@ -27,6 +27,9 @@ pacman -Ql <package name> | sed -n -e 's/.*\/bin\///p' | tail -n +2
 # To list explicitly installed packages
 pacman -Qe
 
+# To list the top-most recent explicitly installed packages (not in the base groups)
+expac --timefmt='%Y-%m-%d %T' '%l\t%n' $(comm -23 <(pacman -Qeq|sort) <(pacman -Qqg base base-devel|sort)) | sort -r | head -20
+
 # To list orphan packages (installed as dependencies and not required anymore)
 pacman -Qdt
 

cheat/cheatsheets/rename

@@ -1,2 +1,5 @@
 # Lowercase all files and folders in current directory
 rename 'y/A-Z/a-z/' *
+
+# Replace 'sometext' with 'replacedby' in all files in current directory
+rename 's/sometext/replacedby/' *

cheat/cheatsheets/rsync

@@ -12,3 +12,6 @@ rsync -auv /src/foo /dest
 
 # Explicitly copy /src/foo to /dest/foo
 rsync -auv /src/foo/ /dest/foo
+
+# Copy file from local to remote over ssh with non standard port 1234 to destination folder in remoteuser's home directory
+rsync -avz -e "ssh -p1234" /source/file1 remoteuser@X.X.X.X:~/destination/

cheat/cheatsheets/scd

@@ -0,0 +1,20 @@
+# To index recursively some paths for the very first run:
+scd -ar ~/Documents/
+
+# To change to a directory path matching "doc":
+scd doc
+
+# To change to a path matching all of "a", "b" and "c":
+scd a b c
+
+# To change to a directory path that ends with "ts":
+scd "ts$"
+
+# To show selection menu and ranking of 20 most likely directories:
+scd -v
+
+# To alias current directory as "xray":
+scd --alias=xray
+
+# To jump to a previously defined aliased directory:
+scd xray

cheat/cheatsheets/scp

@@ -3,3 +3,6 @@ scp foo.txt user@example.com:remote/dir
 
 # To copy a file from a remote server to your local machine:
 scp user@example.com:remote/dir/foo.txt local/dir
+
+# To scp a file over a SOCKS proxy on localhost and port 9999 (see ssh for tunnel setup):
+scp -o "ProxyCommand nc -x 127.0.0.1:9999 -X 4 %h %p" file.txt username@example2.com:/tmp/

cheat/cheatsheets/sed

@@ -15,3 +15,9 @@ sed '/^$/d' file.txt
 
 # To replace newlines in multiple lines
 sed ':a;N;$!ba;s/\n//g'  file.txt
+
+# Insert a line before a matching pattern:
+sed '/Once upon a time/i\Chapter 1'
+
+# Add a line after a matching pattern:
+sed '/happily ever after/a\The end.'

cheat/cheatsheets/slurm

@@ -0,0 +1,15 @@
+# Submit a new job:
+sbatch job.sh
+
+# List all jobs for a user:
+squeue -u user_name
+
+# Cancel a job by id or name:
+scancel job_id
+scancel --name job_name
+
+# List all information for a job:
+scontrol show jobid -dd job_id
+
+# Status info for currently running job:
+sstat --format=AveCPU,AvePages,AveRSS,AveVMSize,JobID -j job_id --allsteps

cheat/cheatsheets/snap

@@ -0,0 +1,98 @@
+# To find the `foo` snap:
+snap find foo
+
+# To view detailed information about snap `foo`:
+snap info foo
+
+# To view all private snaps (must be logged in):
+snap find --private
+
+# To install the `foo` snap:
+sudo snap install foo
+
+# To install the `foo` snap from the "beta" channel:
+sudo snap install foo --channel=beta
+
+# To view installed snaps:
+snap list
+
+# To list all revisions of installed snaps:
+snap list --all
+
+# To (manually) update all snaps:
+sudo snap refresh
+
+# To (manually) update the `foo` snap:
+sudo snap refresh foo
+
+# To update the `foo` snap to the "beta" channel:
+sudo snap refresh foo --channel=beta
+
+# To revert the `foo` snap to a prior version:
+sudo snap revert foo
+
+# To revert the `foo` snap to revision 5:
+snap revert foo --revision 5
+
+# To remove the `foo` snap:
+sudo snap remove foo
+
+# To log in to snap (must first create account online):
+sudo snap login
+
+# To log out of snap:
+snap logout
+
+# To view a transaction log summary:
+snap changes
+
+# To view details of item 123 in the transaction log:
+snap change 123
+
+# To watch transaction 123:
+snap watch 123
+
+# To abort transaction 123:
+snap abort 123
+
+# To download the `foo` snap (and its assertions) *without* installing it:
+snap download foo
+
+# To install the locally-downloaded `foo` snap with assertions:
+snap ack foo.assert
+snap install foo.snap
+
+# To install the locally-downloaded `foo` snap without assertions:
+# NB: this is dangerous, because the integrity of the snap will not be
+# verified. You should only do this to test a snap that you are currently
+# developing.
+snap install --dangerous foo.snap
+
+# To install snap `foo` in "dev mode":
+# NB: this is dangerous, and bypasses the snap sandboxing mechanisms
+snap install --devmode foo
+
+# To install snap `foo` in "classic mode":
+# NB: this is likewise dangerous
+snap install --classic foo
+
+# To view available snap interfaces:
+snap interfaces
+
+# To connect the `foo:camera` plug to the ubuntu core slot:
+snap connect foo:camera :camera
+
+# To disconnect the `foo:camera` plug from the ubuntu core slot:
+snap disconnect foo:camera
+
+# To disable the `foo` snap
+snap disable foo
+
+# To enable the `foo` snap
+snap enable foo
+
+# To set snap `foo`'s `bar` property to 10:
+snap set foo bar=10
+
+# To read snap `foo`'s current `bar` property:
+snap get foo bar

cheat/cheatsheets/socat

@@ -35,4 +35,3 @@ socat exec:'bash -i',pty,stderr tcp:remote.butzel.info:3180
 # listener for above reverse shell (on remote.butzel.info):
 socat file:`tty`,raw,echo=0 tcp-listen:3180
 # or: nc -lp 3180
-

cheat/cheatsheets/ssh

@@ -21,7 +21,10 @@ ssh -f -L 8080:remote.example.com:5000 user@personal.server.com -N
 ssh -X -t user@example.com 'chromium-browser'
 
 # To create a SOCKS proxy on localhost and port 9999
-ssh -D 9999 user@example.com
+ssh -qND 9999 user@example.com
+
+# To tunnel an ssh session over the SOCKS proxy on localhost and port 9999
+ssh -o "ProxyCommand nc -x 127.0.0.1:9999 -X 4 %h %p" username@example2.com
 
 # -X use an xsession, -C compress data, "-c blowfish" use the encryption blowfish
 ssh user@example.com -C -c blowfish -X

cheat/cheatsheets/tee

@@ -3,3 +3,6 @@ ls | tee outfile.txt
 
 # To tee stdout and append to a file:
 ls | tee -a outfile.txt
+
+# To tee stdout to the terminal, and also pipe it into another program for further processing:
+ls | tee /dev/tty | xargs printf "\033[1;34m%s\033[m\n"

cheat/cheatsheets/youtube-dl

@@ -19,5 +19,5 @@ youtube-dl -s example.com/watch?v=id
 # To download audio in mp3 format with best quality available
 youtube-dl --extract-audio --audio-format mp3 --audio-quality 0 example.com/watch?v=id
 
-# For all video formats see
-# http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs
+# For all video formats see link below (unfold "Comparison of YouTube media encoding options")
+# https://en.wikipedia.org/w/index.php?title=YouTube&oldid=723160791#Quality_and_formats

cheat/cheatsheets/zfs

@@ -0,0 +1,126 @@
+# WARNING:
+#   In order to avoid headaches when moving ZFS physical devices around,
+#   one will be much better served to reference devices by their *immutable*
+#   ID - as in /dev/disk/by-id/* - rather than their block device name -
+#   as in /dev/{sd,nvme}* - which is bound to change as per PCI enumeration
+#   order.
+# For the sake of briefness, we'll use the following variables:
+#   ${device}    device (/dev/disk/by-id/${device})
+#   ${part}      partition (/dev/disk/by-id/${part=${device}-part${N}})
+#   ${pool}      ZFS pool (name)
+#   ${fs_vol}    ZFS file system or volume (name)
+#   ${snapshot}  ZFS snapshot (name)
+
+
+## Pools
+
+# Create a new "RAID-5" (raidz1) pool
+# Recommended: use entire devices rather than partitions
+zpool create ${pool} raidz1 ${device} ${device} ${device} [...]
+
+# Add 2nd-level "RAID-1" (mirror) ZFS Intent Log (ZIL; synchronous write cache)
+# Recommended: use separate, fast, low-latency devices (e.g. NVMe)
+zpool add ${pool} log mirror ${part} ${part}
+
+# Add 2nd-level "RAID-0" Adaptive Replacement Cache (ARC; read cache)
+# Recommended: use separate, fast, low-latency devices (e.g. NVMe)
+zpool add ${pool} cache ${part} ${part} [...]
+
+# Remove log or cache components
+zpool remove zfs ${part} [...]
+
+# Import (enable) existing pool from newly connected devices
+# Note: this will create the /etc/zfs/zpool.cache devices cache
+zpool import -d /dev/disk/by-id -aN
+
+# Import (enable) existing pool using the devices cache
+zpool import -c /etc/zfs/zpool.cache -aN
+
+# Export (disable) pool (e.g. before shutdown)
+zpool export -a
+
+# List all (imported) pools
+zpool list
+
+# See pool status
+zpool status ${pool}
+
+# See detailed pool I/O statistics
+zpool iostat ${pool} -v
+
+# Verify pool integrity (data checksums)
+# (watch progress with 'zpool status')
+zpool scrub ${pool}
+
+# Remove a failing device from a pool
+# Note: redundant pools (mirror, raidz) will continue working in degraded state
+zpool detach ${pool} ${device}
+
+# Replace a failed device in a pool
+# Note: new device will be "resilvered" automatically (parity reconstruction)
+#       (watch progress with 'zpool status')
+zpool replace ${pool} ${failed-device} ${new-device}
+
+# Erase zpool labels ("superblock") from a device/partition
+# WARNING: MUST do before reusing a device/partition for other purposes
+zpool labelclear ${device}
+
+# Query pool configuration (properties)
+zpool get all ${pool}
+
+# Change pool configuration (property)
+zpool set <property>=<value> ${pool}
+
+# Dump the entire pool (commands) history
+zpool history ${pool}
+
+# More...
+man zpool
+
+
+## File systems / Volumes
+
+# Create a new file system
+zfs create ${pool}/${fs_vol}
+
+# Create a new volume ("block device")
+# Note: look for it in /dev/zvol/${pool}/${fs_vol}
+zfs create -V <size> ${pool}/${fs_vol}
+
+# List all file systems / volumes
+zfs list
+
+# Mount all file systems
+# Note: see 'zfs get mountpoint ${pool}' for mountpoint root path
+zfs mount -a
+
+# Create a snapshot
+zfs snapshot ${pool}/${fs_vol}@${snapshot}
+
+# Delete a snapshot
+zfs destroy ${pool}/${fs_vol}@${snapshot}
+
+# Full backup
+# Note: pipe (|) source to destination through netcat, SSH, etc.
+# ... on source:
+zfs send -p -R ${pool}/${fs_vol}@${snapshot}
+# ... on destination:
+zfs receive -F ${pool}/${fs_vol}
+
+# Incremental backup
+# Note: pipe (|) source to destination through netcat, SSH, etc.
+# ... on source:
+zfs send -p -R -i ${pool}/${fs_vol}@${snapshot-previous} ${pool}/${fs_vol}@${snapshot}
+# ... on destination:
+zfs receive -F ${pool}/${fs_vol}
+
+# Query file system / volume configuration (properties)
+zfs get all ${pool}
+zfs get all ${pool}/${fs_vol}
+
+# Change file system / volume configuration (property)
+zfs set <property>=<value> ${pool}/${fs_vol}
+
+# More...
+man zfs
+

cheat/cheatsheets/zip

@@ -1,5 +1,8 @@
 # Create zip file
 zip archive.zip file1 directory/
 
+# Create zip file with password
+zip -P password archive.zip file1
+
 # To list, test and extract zip archives, see unzip
 cheat unzip

cheat/colorize.py

@@ -0,0 +1,65 @@
+from __future__ import print_function
+import sys
+
+
+class Colorize:
+
+    def __init__(self, config):
+        self._config = config
+
+    def search(self, needle, haystack):
+        """ Colorizes search results matched within a line """
+
+        # if a highlight color is not configured, exit early
+        if not self._config.cheat_highlight:
+            return haystack
+
+        # otherwise, attempt to import the termcolor library
+        try:
+            from termcolor import colored
+
+        # if the import fails, return uncolored text
+        except ImportError:
+            return haystack
+
+        # if the import succeeds, colorize the needle in haystack
+        return haystack.replace(needle,
+                                colored(needle, self._config.cheat_highlight))
+
+    def syntax(self, sheet_content):
+        """ Applies syntax highlighting """
+
+        # only colorize if cheat_colors is true, and stdout is a tty
+        if self._config.cheat_colors is False or not sys.stdout.isatty():
+            return sheet_content
+
+        # don't attempt to colorize an empty cheatsheet
+        if not sheet_content.strip():
+            return ""
+
+        # otherwise, attempt to import the pygments library
+        try:
+            from pygments import highlight
+            from pygments.lexers import get_lexer_by_name
+            from pygments.formatters import TerminalFormatter
+
+        # if the import fails, return uncolored text
+        except ImportError:
+            return sheet_content
+
+        # otherwise, attempt to colorize
+        first_line = sheet_content.splitlines()[0]
+        lexer = get_lexer_by_name('bash')
+
+        # apply syntax-highlighting if the first line is a code-fence
+        if first_line.startswith('```'):
+            sheet_content = '\n'.join(sheet_content.split('\n')[1:-2])
+            try:
+                lexer = get_lexer_by_name(first_line[3:])
+            except Exception:
+                pass
+
+        return highlight(
+               sheet_content,
+               lexer,
+               TerminalFormatter(bg=self._config.cheat_colorscheme))

cheat/configuration.py

@@ -0,0 +1,119 @@
+from cheat.utils import Utils
+import json
+import os
+
+
+class Configuration:
+
+    def __init__(self):
+        # compute the location of the config files
+        config_file_path_global = self._select([
+            os.environ.get('CHEAT_GLOBAL_CONF_PATH'),
+            '/etc/cheat',
+        ])
+        config_file_path_local = self._select([
+            os.environ.get('CHEAT_LOCAL_CONF_PATH'),
+            os.path.expanduser('~/.config/cheat/cheat'),
+        ])
+
+        # attempt to read the global config file
+        config = {}
+        try:
+            config.update(self._read_config_file(config_file_path_global))
+        except Exception as e:
+            Utils.warn('Error while parsing global configuration: '
+                       + e.message)
+
+        # attempt to read the local config file
+        try:
+            config.update(self._read_config_file(config_file_path_local))
+        except Exception as e:
+            Utils.warn('Error while parsing local configuration: ' + e.message)
+
+        # With config files read, now begin to apply envvar overrides and
+        # default values
+
+        # self.cheat_colors
+        self.cheat_colors = self._select([
+            Utils.boolify(os.environ.get('CHEAT_COLORS')),
+            Utils.boolify(os.environ.get('CHEATCOLORS')),
+            Utils.boolify(config.get('CHEAT_COLORS')),
+            True,
+        ])
+
+        # self.cheat_colorscheme
+        self.cheat_colorscheme = self._select([
+            os.environ.get('CHEAT_COLORSCHEME'),
+            config.get('CHEAT_COLORSCHEME'),
+            'light',
+        ]).strip().lower()
+
+        # self.cheat_user_dir
+        self.cheat_user_dir = self._select(
+            map(os.path.expanduser,
+                filter(None,
+                    [os.environ.get('CHEAT_USER_DIR'),
+                     os.environ.get('CHEAT_DEFAULT_DIR'),
+                     os.environ.get('DEFAULT_CHEAT_DIR'),
+                     # TODO: XDG home?
+                     os.path.join('~', '.cheat')])))
+
+        # self.cheat_editor
+        self.cheat_editor = self._select([
+            os.environ.get('CHEAT_EDITOR'),
+            os.environ.get('EDITOR'),
+            os.environ.get('VISUAL'),
+            config.get('CHEAT_EDITOR'),
+            'vi',
+        ])
+
+        # self.cheat_highlight
+        self.cheat_highlight = self._select([
+            os.environ.get('CHEAT_HIGHLIGHT'),
+            config.get('CHEAT_HIGHLIGHT'),
+            False,
+        ])
+        if isinstance(self.cheat_highlight, str):
+            Utils.boolify(self.cheat_highlight)
+
+        # self.cheat_path
+        self.cheat_path = self._select([
+            os.environ.get('CHEAT_PATH'),
+            os.environ.get('CHEATPATH'),
+            config.get('CHEAT_PATH'),
+            '/usr/share/cheat',
+        ])
+
+    def _read_config_file(self, path):
+        """ Reads configuration file and returns list of set variables """
+        config = {}
+        if os.path.isfile(path):
+            with open(path) as config_file:
+                config.update(json.load(config_file))
+        return config
+
+    def _select(self, values):
+        for v in values:
+            if v is not None:
+                return v
+
+    def validate(self):
+        """ Validates configuration parameters """
+
+        # assert that cheat_highlight contains a valid value
+        highlights = [
+            'grey', 'red', 'green', 'yellow',
+            'blue', 'magenta', 'cyan', 'white',
+            False
+        ]
+        if self.cheat_highlight not in highlights:
+            Utils.die("%s %s" %
+                      ('CHEAT_HIGHLIGHT must be one of:', highlights))
+
+        # assert that the color scheme is valid
+        colorschemes = ['light', 'dark']
+        if self.cheat_colorscheme not in colorschemes:
+            Utils.die("%s %s" %
+                      ('CHEAT_COLORSCHEME must be one of:', colorschemes))
+
+        return True

cheat/editor.py

@@ -0,0 +1,29 @@
+from __future__ import print_function
+from cheat.utils import Utils
+import subprocess
+
+
+class Editor:
+
+    def __init__(self, config):
+        self._config = config
+
+    def editor(self):
+        """ Determines the user's preferred editor """
+
+        # assert that the editor is set
+        if not self._config.cheat_editor:
+            Utils.die(
+                'You must set a CHEAT_EDITOR, VISUAL, or EDITOR environment '
+                'variable or setting in order to create/edit a cheatsheet.'
+            )
+
+        return self._config.cheat_editor
+
+    def open(self, filepath):
+        """ Open `filepath` using the EDITOR specified by the env variables """
+        editor_cmd = self.editor().split()
+        try:
+            subprocess.call(editor_cmd + [filepath])
+        except OSError:
+            Utils.die('Could not launch ' + self.editor())

cheat/sheet.py

@@ -1,76 +1,64 @@
+from cheat.editor import Editor
+from cheat.utils import Utils
+import io
 import os
 import shutil
 
-from cheat import sheets
-from cheat.utils import die, open_with_editor
 
-def copy(current_sheet_path, new_sheet_path):
-    """ Copies a sheet to a new path """
+class Sheet:
 
-    # attempt to copy the sheet to DEFAULT_CHEAT_DIR
-    try:
-        shutil.copy(current_sheet_path, new_sheet_path)
+    def __init__(self, config, sheets):
+        self._config = config
+        self._editor = Editor(config)
+        self._sheets = sheets
 
-    # fail gracefully if the cheatsheet cannot be copied. This can happen if
-    # DEFAULT_CHEAT_DIR does not exist
-    except IOError:
-        die('Could not copy cheatsheet for editing.')
+    def _exists(self, sheet):
+        """ Predicate that returns true if the sheet exists """
+        return (sheet in self._sheets.get() and
+                os.access(self._path(sheet), os.R_OK))
 
+    def _exists_in_default_path(self, sheet):
+        """ Predicate that returns true if the sheet exists in default_path"""
+        default_path = os.path.join(self._config.cheat_user_dir, sheet)
+        return (sheet in self._sheets.get() and
+                os.access(default_path, os.R_OK))
 
-def create_or_edit(sheet):
-    """ Creates or edits a cheatsheet """
+    def _path(self, sheet):
+        """ Returns a sheet's filesystem path """
+        return self._sheets.get()[sheet]
 
-    # if the cheatsheet does not exist
-    if not exists(sheet):
-        create(sheet)
+    def edit(self, sheet):
+        """ Creates or edits a cheatsheet """
 
-    # if the cheatsheet exists but not in the default_path, copy it to the
-    # default path before editing
-    elif exists(sheet) and not exists_in_default_path(sheet):
-        copy(path(sheet), os.path.join(sheets.default_path(), sheet))
-        edit(sheet)
+        # if the cheatsheet does not exist
+        if not self._exists(sheet):
+            new_path = os.path.join(self._config.cheat_user_dir, sheet)
+            self._editor.open(new_path)
 
-    # if it exists and is in the default path, then just open it
-    else:
-        edit(sheet)
+        # if the cheatsheet exists but not in the default_path, copy it to the
+        # default path before editing
+        elif self._exists(sheet) and not self._exists_in_default_path(sheet):
+            try:
+                shutil.copy(
+                            self._path(sheet),
+                            os.path.join(self._config.cheat_user_dir, sheet)
+                           )
 
+            # fail gracefully if the cheatsheet cannot be copied. This can
+            # happen if CHEAT_USER_DIR does not exist
+            except IOError:
+                Utils.die('Could not copy cheatsheet for editing.')
 
-def create(sheet):
-    """ Creates a cheatsheet """
-    new_sheet_path = os.path.join(sheets.default_path(), sheet)
-    open_with_editor(new_sheet_path)
+            self._editor.open(self._path(sheet))
 
+        # if it exists and is in the default path, then just open it
+        else:
+            self._editor.open(self._path(sheet))
 
-def edit(sheet):
-    """ Opens a cheatsheet for editing """
-    open_with_editor(path(sheet))
+    def read(self, sheet):
+        """ Returns the contents of the cheatsheet as a String """
+        if not self._exists(sheet):
+            Utils.die('No cheatsheet found for ' + sheet)
 
-
-def exists(sheet):
-    """ Predicate that returns true if the sheet exists """
-    return sheet in sheets.get() and os.access(path(sheet), os.R_OK)
-
-
-def exists_in_default_path(sheet):
-    """ Predicate that returns true if the sheet exists in default_path"""
-    default_path_sheet = os.path.join(sheets.default_path(), sheet)
-    return sheet in sheets.get() and os.access(default_path_sheet, os.R_OK)
-
-
-def is_writable(sheet):
-    """ Predicate that returns true if the sheet is writeable """
-    return sheet in sheets.get() and os.access(path(sheet), os.W_OK)
-
-
-def path(sheet):
-    """ Returns a sheet's filesystem path """
-    return sheets.get()[sheet]
-
-
-def read(sheet):
-    """ Returns the contents of the cheatsheet as a String """
-    if not exists(sheet):
-        die('No cheatsheet found for ' + sheet)
-
-    with open(path(sheet)) as cheatfile:
-        return cheatfile.read()
+        with io.open(self._path(sheet), encoding='utf-8') as cheatfile:
+            return cheatfile.read()

cheat/sheets.py

@@ -1,92 +1,77 @@
+from cheat.colorize import Colorize
+from cheat.utils import Utils
+import io
 import os
 
-from cheat import cheatsheets
-from cheat.utils import die
 
-def default_path():
-    """ Returns the default cheatsheet path """
+class Sheets:
 
-    # determine the default cheatsheet dir
-    default_sheets_dir = os.environ.get('DEFAULT_CHEAT_DIR') or os.path.join('~', '.cheat')
-    default_sheets_dir = os.path.expanduser(os.path.expandvars(default_sheets_dir))
+    def __init__(self, config):
+        self._config = config
+        self._colorize = Colorize(config)
 
-    # create the DEFAULT_CHEAT_DIR if it does not exist
-    if not os.path.isdir(default_sheets_dir):
-        try:
-            # @kludge: unclear on why this is necessary
-            os.umask(0000)
-            os.mkdir(default_sheets_dir)
+        # Assembles a dictionary of cheatsheets as name => file-path
+        self._sheets = {}
+        sheet_paths = [
+            config.cheat_user_dir
+        ]
 
-        except OSError:
-            die('Could not create DEFAULT_CHEAT_DIR')
+        # merge the CHEAT_PATH paths into the sheet_paths
+        if config.cheat_path:
+            for path in config.cheat_path.split(os.pathsep):
+                if os.path.isdir(path):
+                    sheet_paths.append(path)
 
-    # assert that the DEFAULT_CHEAT_DIR is readable and writable
-    if not os.access(default_sheets_dir, os.R_OK):
-        die('The DEFAULT_CHEAT_DIR (' + default_sheets_dir +') is not readable.')
-    if not os.access(default_sheets_dir, os.W_OK):
-        die('The DEFAULT_CHEAT_DIR (' + default_sheets_dir +') is not writable.')
+        if not sheet_paths:
+            Utils.die('The CHEAT_USER_DIR dir does not exist '
+                      + 'or the CHEAT_PATH is not set.')
 
-    # return the default dir
-    return default_sheets_dir
+        # otherwise, scan the filesystem
+        for cheat_dir in reversed(sheet_paths):
+            self._sheets.update(
+                dict([
+                    (cheat, os.path.join(cheat_dir, cheat))
+                    for cheat in os.listdir(cheat_dir)
+                    if not cheat.startswith('.')
+                    and not cheat.startswith('__')
+                ])
+            )
 
+    def directories(self):
+        """ Assembles a list of directories containing cheatsheets """
+        sheet_paths = [
+            self._config.cheat_user_dir,
+        ]
 
-def get():
-    """ Assembles a dictionary of cheatsheets as name => file-path """
-    cheats = {}
+        # merge the CHEATPATH paths into the sheet_paths
+        for path in self._config.cheat_path.split(os.pathsep):
+            sheet_paths.append(path)
 
-    # otherwise, scan the filesystem
-    for cheat_dir in reversed(paths()):
-        cheats.update(
-            dict([
-                (cheat, os.path.join(cheat_dir, cheat))
-                for cheat in os.listdir(cheat_dir)
-                if not cheat.startswith('.')
-                and not cheat.startswith('__')
-            ])
-        )
+        return sheet_paths
 
-    return cheats
+    def get(self):
+        """ Returns a dictionary of cheatsheets as name => file-path """
+        return self._sheets
 
+    def list(self):
+        """ Lists the available cheatsheets """
+        sheet_list = ''
+        pad_length = max([len(x) for x in self.get().keys()]) + 4
+        for sheet in sorted(self.get().items()):
+            sheet_list += sheet[0].ljust(pad_length) + sheet[1] + "\n"
+        return sheet_list
 
-def paths():
-    """ Assembles a list of directories containing cheatsheets """
-    sheet_paths = [
-        default_path(),
-        cheatsheets.sheets_dir()[0],
-    ]
+    def search(self, term):
+        """ Searches all cheatsheets for the specified term """
+        result = ''
 
-    # merge the CHEATPATH paths into the sheet_paths
-    if 'CHEATPATH' in os.environ and os.environ['CHEATPATH']:
-        for path in os.environ['CHEATPATH'].split(os.pathsep):
-            if os.path.isdir(path):
-                sheet_paths.append(path)
+        for cheatsheet in sorted(self.get().items()):
+            match = ''
+            for line in io.open(cheatsheet[1], encoding='utf-8'):
+                if term in line:
+                    match += '  ' + self._colorize.search(term, line)
 
-    if not sheet_paths:
-        die('The DEFAULT_CHEAT_DIR dir does not exist or the CHEATPATH is not set.')
+            if match != '':
+                result += cheatsheet[0] + ":\n" + match + "\n"
 
-    return sheet_paths
-
-
-def list():
-    """ Lists the available cheatsheets """
-    sheet_list = ''
-    pad_length = max([len(x) for x in get().keys()]) + 4
-    for sheet in sorted(get().items()):
-        sheet_list += sheet[0].ljust(pad_length) + sheet[1] + "\n"
-    return sheet_list
-
-
-def search(term):
-    """ Searches all cheatsheets for the specified term """
-    result = ''
-
-    for cheatsheet in sorted(get().items()):
-        match = ''
-        for line in open(cheatsheet[1]):
-            if term in line:
-                match += '  ' + line
-
-        if match != '':
-            result += cheatsheet[0] + ":\n" + match + "\n"
-
-    return result
+        return result

cheat/utils.py

@@ -1,71 +1,26 @@
 from __future__ import print_function
-import os
 import sys
-import subprocess
 
 
-def colorize(sheet_content):
-    """ Colorizes cheatsheet content if so configured """
+class Utils:
 
-    # only colorize if so configured
-    if not 'CHEATCOLORS' in os.environ:
-        return sheet_content
+    @staticmethod
+    def die(message):
+        """ Prints a message to stderr and then terminates """
+        Utils.warn(message)
+        exit(1)
 
-    try:
-        from pygments import highlight
-        from pygments.lexers import get_lexer_by_name
-        from pygments.formatters import TerminalFormatter
+    @staticmethod
+    def warn(message):
+        """ Prints a message to stderr """
+        print((message), file=sys.stderr)
 
-    # if pygments can't load, just return the uncolorized text
-    except ImportError:
-        return sheet_content
+    @staticmethod
+    def boolify(value):
+        """ Type-converts 'true' and 'false' to Booleans """
+        # if `value` is not a string, return it as-is
+        if not isinstance(value, str):
+            return value
 
-    first_line = sheet_content.splitlines()[0]
-    lexer      = get_lexer_by_name('bash')
-    if first_line.startswith('```'):
-        sheet_content = '\n'.join(sheet_content.split('\n')[1:-2])
-        try:
-            lexer = get_lexer_by_name(first_line[3:])
-        except Exception:
-            pass
-
-    return highlight(sheet_content, lexer, TerminalFormatter())
-
-
-def die(message):
-    """ Prints a message to stderr and then terminates """
-    warn(message)
-    exit(1)
-
-
-def editor():
-    """ Determines the user's preferred editor """
-
-    # determine which editor to use
-    editor = os.environ.get('CHEAT_EDITOR') \
-        or os.environ.get('VISUAL')         \
-        or os.environ.get('EDITOR')         \
-        or False
-
-    # assert that the editor is set
-    if editor == False:
-        die(
-            'You must set a CHEAT_EDITOR, VISUAL, or EDITOR environment '
-            'variable in order to create/edit a cheatsheet.'
-        )
-
-    return editor
-
-
-def open_with_editor(filepath):
-    """ Open `filepath` using the EDITOR specified by the environment variables """
-    editor_cmd = editor().split()
-    try:
-        subprocess.call(editor_cmd + [filepath])
-    except OSError:
-        die('Could not launch ' + editor())
-
-
-def warn(message):
-    """ Prints a message to stderr """
-    print((message), file=sys.stderr)
+        # otherwise, convert "true" and "false" to Boolean counterparts
+        return value.strip().lower() == "true"

ci/lint.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+# Resolve the app root
+SCRIPT=`realpath $0`
+SCRIPTPATH=`dirname $SCRIPT`
+APPROOT=`realpath "$SCRIPTPATH/.."`
+
+flake8 $APPROOT/setup.py
+flake8 $APPROOT/bin/cheat
+flake8 $APPROOT/cheat/*.py

config/cheat

@@ -0,0 +1,6 @@
+{
+  "CHEAT_COLORS"      : true,
+  "CHEAT_COLORSCHEME" : "light",
+  "CHEAT_EDITOR"      : "vi",
+  "CHEAT_PATH"        : "/usr/share/cheat"
+}

setup.py

@@ -1,28 +1,40 @@
 from distutils.core import setup
 import os
 
+# determine the directory in which to install system-wide cheatsheets
+# KLUDGE: It would be better to read `/usr/share/cheat` from `config/cheat`
+# rather than hard-coding it here
+cheat_path = os.environ.get('CHEAT_PATH') or '/usr/share/cheat'
+
+# aggregate the systme-wide cheatsheets
+cheat_files = []
+for f in os.listdir('cheat/cheatsheets/'):
+    cheat_files.append(os.path.join('cheat/cheatsheets/', f))
+
+# specify build params
 setup(
-    name         = 'cheat',
-    version      = '2.2.3',
-    author       = 'Chris Lane',
-    author_email = 'chris@chris-allen-lane.com',
-    license      = 'GPL3',
-    description  = 'cheat allows you to create and view interactive cheatsheets '
+    name='cheat',
+    version='2.5.1',
+    author='Chris Lane',
+    author_email='chris@chris-allen-lane.com',
+    license='GPL3',
+    description='cheat 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.',
-    url          = 'https://github.com/chrisallenlane/cheat',
-    packages     = [
+    url='https://github.com/chrisallenlane/cheat',
+    packages=[
         'cheat',
-        'cheat.cheatsheets',
         'cheat.test',
     ],
-    package_data = {
-        'cheat.cheatsheets': [f for f in os.listdir('cheat/cheatsheets') if '.' not in f]
-    },
-    scripts          = ['bin/cheat'],
-    install_requires = [
+    scripts=['bin/cheat'],
+    install_requires=[
         'docopt >= 0.6.1',
         'pygments >= 1.6.0',
-    ]
+        'termcolor >= 1.1.0',
+    ],
+    data_files=[
+        (cheat_path, cheat_files),
+        ('/etc', ['config/cheat']),
+    ],
 )

tests/test_configuration.py

@@ -0,0 +1,86 @@
+import unittest2
+import os
+import shutil
+from cheat.configuration import Configuration
+
+
+def _set_loc_conf(key, value):
+    _path = os.path.dirname(os.path.abspath(__file__)) + '/home/.config/cheat/cheat'
+    if value == None:
+        os.remove(_path)
+    else:
+        if not os.path.exists(os.path.dirname(_path)):
+            os.makedirs(os.path.dirname(_path))
+        f = open(_path,"w+")
+        f.write('{"'+ key +'":"'+ value +'"}')
+        f.close()
+
+
+def _set_glob_conf(key, value):
+    _path = os.path.dirname(os.path.abspath(__file__))+ "/etc/cheat"
+    if value == None:
+        os.remove(_path)
+    else:
+        if not os.path.exists(os.path.dirname(_path)):
+            os.mkdir(os.path.dirname(_path))
+        f = open(_path,"w+")
+        f.write('{"'+ key +'":"'+ value +'"}' )
+        f.close()
+
+
+def _set_env_var(key, value):
+    if value == None:
+        del os.environ[key]
+    else:
+        os.environ[key] = value
+
+
+def _configuration_key_test(TestConfiguration, key,values, conf_get_method):
+    for glob_conf in values:
+            _set_glob_conf(key,glob_conf)
+            for loc_conf in values:
+                _set_loc_conf(key,loc_conf)
+                for env_conf in values:
+                    _set_env_var(key,env_conf)
+                    if env_conf:
+                        TestConfiguration.assertEqual(conf_get_method(Configuration()),env_conf)
+                    elif loc_conf:
+                        TestConfiguration.assertEqual(conf_get_method(Configuration()),loc_conf)
+                    elif glob_conf:
+                        TestConfiguration.assertEqual(conf_get_method(Configuration()),glob_conf)
+                    else:
+                        TestConfiguration.assertEqual(conf_get_method(Configuration()),None)
+
+
+class ConfigurationTestCase(unittest2.TestCase):
+
+
+    def setUp(self):
+        os.environ['CHEAT_GLOBAL_CONF_PATH'] = os.path.dirname(os.path.abspath(__file__)) \
+        + '/etc/cheat'
+        os.environ['CHEAT_LOCAL_CONF_PATH'] = os.path.dirname(os.path.abspath(__file__)) \
+        + '/home/.config/cheat/cheat'
+
+
+    def test_get_editor(self):
+        _configuration_key_test(self,"EDITOR",["nano","vim","gedit",None],
+        Configuration.get_editor)
+
+
+    def test_get_cheatcolors(self):
+        _configuration_key_test(self,"CHEATCOLORS",["true",None],
+        Configuration.get_cheatcolors)
+
+
+    def test_get_cheatpath(self):
+        _configuration_key_test(self,"CHEATPATH",["/etc/myglobalcheats",
+        "/etc/anotherglobalcheats","/rootcheats",None],Configuration.get_cheatpath)
+
+
+    def test_get_defaultcheatdir(self):
+        _configuration_key_test(self,"DEFAULT_CHEAT_DIR",["/etc/myglobalcheats",
+        "/etc/anotherglobalcheats","/rootcheats",None],Configuration.get_default_cheat_dir)
+
+    def tearDown(self):
+        shutil.rmtree(os.path.dirname(os.path.abspath(__file__)) +'/etc')
+        shutil.rmtree(os.path.dirname(os.path.abspath(__file__)) +'/home')