Merge pull request #472 from asamarin/master

Add: sqlite3 - describe table schema

.gitignore

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

CHANGELOG

@@ -1,3 +0,0 @@
-Changelog
-=========
-

CONTRIBUTING.md

@@ -1,17 +1,29 @@
 Contributing
 ============
 If you would like to contribute cheetsheets or program functionality, please
-fork this repository, make your changes, and submit a pull request.
+fork this repository, make your changes, and submit a pull request against the
+`master` branch.
 
+
+## Python standards ##
 Python code should conform to [PEP 8][].
 
-Licensing
----------
-By contributing to the project, you agree to license your work under the same
-licenses as `cheat` itself. `cheat` is currently dual-licensed under the GPL3
-and MIT licenses, though that could change without notice in the future.
 
-`cheat`, however, will always remain free software (as in both "free as in
+## Cheatsheet Format ##
-freedom" and "free as in beer") and shall always be licensed accordingly.
+Please pattern your cheatsheets after the following:
+
+```sh
+# To extract an uncompressed archive:
+tar -xvf /path/to/foo.tar
+
+# To create an uncompressed archive:
+tar -cvf /path/to/foo.tar /path/to/foo/
+
+# To extract a .gz archive:
+tar -xzvf /path/to/foo.tgz
+```
+
+If you are submitting a cheatsheet that contains side-by-side columns of text,
+please align the columns using spaces rather than tabs.
 
 [PEP 8]: http://legacy.python.org/dev/peps/pep-0008/ 

MANIFEST.in

@@ -0,0 +1,6 @@
+include CHANGELOG
+include CONTRIBUTING.md
+include LICENSE
+include README.md
+include licenses/gpl-3.txt
+include licenses/mit.txt

README.md

@@ -1,5 +1,4 @@
 [![PyPI](https://img.shields.io/pypi/v/cheat.svg)](https://pypi.python.org/pypi/cheat/)
-[![PyPI](https://img.shields.io/pypi/dm/cheat.svg)](https://pypi.python.org/pypi/cheat/)
 
 cheat
 =====
@@ -51,9 +50,12 @@ Installing
 It is recommended to install `cheat` with `pip`:
 
 ```sh
-[sudo] pip install cheat
+pip install cheat --user
 ```
 
+(You must ensure that the `Location` identified by `pip show cheat` exists on
+your `PATH`.)
+
 [Other installation methods are available][installing].
 
 
@@ -67,14 +69,14 @@ Cheatsheets are stored in the `~/.cheat/` directory, and are named on a
 per-keyphrase basis. In other words, the content for the `tar` cheatsheet lives
 in the `~/.cheat/tar` file.
 
-Provided that you have an `EDITOR` environment variable set, you may edit
+Provided that you have a `CHEAT_EDITOR`, `VISUAL`, or `EDITOR` environment
-cheatsheets with:
+variable set, you may edit cheatsheets with:
 
 ```sh
 cheat -e foo
 ```
 
-If the 'foo' cheatsheet already exists, it will be opened for editing.
+If the `foo` cheatsheet already exists, it will be opened for editing.
 Otherwise, it will be created automatically.
 
 After you've customized your cheatsheets, I urge you to track `~/.cheat/` along
@@ -84,46 +86,94 @@ 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 apply syntax highlighting to your cheatsheets if so desired. To
+`cheat` can optionally apply syntax highlighting to your cheatsheets. To
-enable this feature, set a `CHEATCOLORS` environment variable:
+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 ####
+You may manually specify which syntax highlighter to use for each cheatsheet by
+wrapping the sheet's contents in a [Github-Flavored Markdown code-fence][gfm].
+
+Example:
+
+<pre>
+```sql
+-- to select a user by ID
+SELECT *
+FROM Users
+WHERE id = 100
+```
+</pre>
+
+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:
 ---------
 - [Enabling Command-line Autocompletion][autocompletion]
 - [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/
-[installing]:       https://github.com/chrisallenlane/cheat/wiki/Installing
+[gfm]:              https://help.github.com/articles/creating-and-highlighting-code-blocks/
-[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,20 @@
+# -*- 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", privileged: false, inline: <<-SHELL
+     sudo apt-get update
+     sudo apt-get install -y python-pip
+     sudo -H pip install flake8
+     pip install --user docopt pygments termcolor
+     cd /vagrant/ && python setup.py install --user
+     echo 'export PATH=$PATH:/home/vagrant/.local/bin' >> /home/vagrant/.bashrc
+  SHELL
+
+end

bin/cheat

@@ -2,6 +2,8 @@
 
 """cheat
 
+Create and view cheatsheets on the command line.
+
 Usage:
   cheat <cheatsheet>
   cheat -e <cheatsheet>
@@ -10,52 +12,94 @@ Usage:
   cheat -d
   cheat -v
 
-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.
-
-Examples:
-  To look up 'tar':
-  cheat tar
-
-  To create or edit the cheatsheet for 'foo':
-  cheat -e foo
-
 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>
   -v --version      Print the version number
+
+Examples:
+
+  To view the `tar` cheatsheet:
+    cheat tar
+
+  To edit (or create) the `foo` cheatsheet:
+    cheat -e foo
+
+  To list all available cheatsheets:
+    cheat -l
+
+  To search for "ssh" among all cheatsheets:
+    cheat -s ssh
 """
 
 # require the dependencies
-from cheat import sheets, sheet
+from __future__ import print_function
-from cheat.utils import colorize
+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.1.26')
+    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/appdirs.py

@@ -0,0 +1,618 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+"""Utilities for determining application-specific dirs.
+
+See <https://github.com/ActiveState/appdirs> for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: https://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version__ = "1.4.4"
+__version_info__ = tuple(int(segment) for segment in __version__.split("."))
+
+
+import sys
+import os
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    unicode = str
+
+if sys.platform.startswith('java'):
+    import platform
+    os_name = platform.java_ver()[3][0]
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
+        system = 'win32'
+    elif os_name.startswith('Mac'): # "Mac OS X", etc.
+        system = 'darwin'
+    else: # "Linux", "SunOS", "FreeBSD", etc.
+        # Setting this to "linux2" is not ideal, but only Windows or Mac
+        # are actually checked for and the rest of the module expects
+        # *sys.platform* style strings.
+        system = 'linux2'
+else:
+    system = sys.platform
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               ~/Library/Application Support/<AppName>
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(_get_win_folder(const))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Application Support/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of data dirs should be
+            returned. By default, the first item from XDG_DATA_DIRS is
+            returned, or '/usr/local/share/<AppName>',
+            if XDG_DATA_DIRS is not set
+
+    Typical site data directories are:
+        Mac OS X:   /Library/Application Support/<AppName>
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
+
+    For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Application Support')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_DATA_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_DATA_DIRS',
+                         os.pathsep.join(['/usr/local/share', '/usr/share']))
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+        return path
+
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user config directories are:
+        Mac OS X:               ~/Library/Preferences/<AppName>
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by default "~/.config/<AppName>".
+    """
+    if system == "win32":
+        path = user_data_dir(appname, appauthor, None, roaming)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Preferences/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of config dirs should be
+            returned. By default, the first item from XDG_CONFIG_DIRS is
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
+
+    Typical site config directories are:
+        Mac OS X:   same as site_data_dir
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
+                    $XDG_CONFIG_DIRS
+        Win *:      same as site_data_dir
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == 'win32':
+        path = site_data_dir(appname, appauthor)
+        if appname and version:
+            path = os.path.join(path, version)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Preferences')
+        if appname:
+            path = os.path.join(path, appname)
+    elif system == 'linux':
+        path = os.path.join('/etc/', appname)
+    else:
+        # XDG default for $XDG_CONFIG_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+    return path
+
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Cache" to the base app data dir for Windows. See
+            discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go in
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+    app data dir (the default returned by `user_data_dir` above). Apps typically
+    put cache data somewhere *under* the given dir here. Some examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+            if opinion:
+                path = os.path.join(path, "Cache")
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Caches')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific state dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user state directories are:
+        Mac OS X:  same as user_data_dir
+        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
+        Win *:     same as user_data_dir
+
+    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
+    to extend the XDG spec and support $XDG_STATE_HOME.
+
+    That means, by default "~/.local/state/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific log dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Logs" to the base app data dir for Windows, and "log" to the
+            base cache dir for Unix. See discussion below.
+
+    Typical user log directories are:
+        Mac OS X:   ~/Library/Logs/<AppName>
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
+
+    On Windows the only suggestion in the MSDN docs is that local settings
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+    examples of what some windows apps use for a logs dir.)
+
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+    value for Windows and appends "log" to the user cache dir for Unix.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "darwin":
+        path = os.path.join(
+            os.path.expanduser('~/Library/Logs'),
+            appname)
+    elif system == "win32":
+        path = user_data_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "Logs")
+    else:
+        path = user_cache_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "log")
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+class AppDirs(object):
+    """Convenience wrapper for getting application dirs."""
+    def __init__(self, appname=None, appauthor=None, version=None,
+            roaming=False, multipath=False):
+        self.appname = appname
+        self.appauthor = appauthor
+        self.version = version
+        self.roaming = roaming
+        self.multipath = multipath
+
+    @property
+    def user_data_dir(self):
+        return user_data_dir(self.appname, self.appauthor,
+                             version=self.version, roaming=self.roaming)
+
+    @property
+    def site_data_dir(self):
+        return site_data_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_config_dir(self):
+        return user_config_dir(self.appname, self.appauthor,
+                               version=self.version, roaming=self.roaming)
+
+    @property
+    def site_config_dir(self):
+        return site_config_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_cache_dir(self):
+        return user_cache_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_state_dir(self):
+        return user_state_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_log_dir(self):
+        return user_log_dir(self.appname, self.appauthor,
+                            version=self.version)
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+    """This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    if PY3:
+      import winreg as _winreg
+    else:
+      import _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+    return dir
+
+
+def _get_win_folder_with_pywin32(csidl_name):
+    from win32com.shell import shellcon, shell
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+    # Try to make this a unicode path because SHGetFolderPath does
+    # not return unicode strings when there is unicode data in the
+    # path.
+    try:
+        dir = unicode(dir)
+
+        # Downgrade to short path name if have highbit chars. See
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+        has_high_char = False
+        for c in dir:
+            if ord(c) > 255:
+                has_high_char = True
+                break
+        if has_high_char:
+            try:
+                import win32api
+                dir = win32api.GetShortPathName(dir)
+            except ImportError:
+                pass
+    except UnicodeError:
+        pass
+    return dir
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    import ctypes
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+def _get_win_folder_with_jna(csidl_name):
+    import array
+    from com.sun import jna
+    from com.sun.jna.platform import win32
+
+    buf_size = win32.WinDef.MAX_PATH * 2
+    buf = array.zeros('c', buf_size)
+    shell = win32.Shell32.INSTANCE
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in dir:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf = array.zeros('c', buf_size)
+        kernel = win32.Kernel32.INSTANCE
+        if kernel.GetShortPathName(dir, buf, buf_size):
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    return dir
+
+if system == "win32":
+    try:
+        import win32com.shell
+        _get_win_folder = _get_win_folder_with_pywin32
+    except ImportError:
+        try:
+            from ctypes import windll
+            _get_win_folder = _get_win_folder_with_ctypes
+        except ImportError:
+            try:
+                import com.sun.jna
+                _get_win_folder = _get_win_folder_with_jna
+            except ImportError:
+                _get_win_folder = _get_win_folder_from_registry
+
+
+#---- self test code
+
+if __name__ == "__main__":
+    appname = "MyApp"
+    appauthor = "MyCompany"
+
+    props = ("user_data_dir",
+             "user_config_dir",
+             "user_cache_dir",
+             "user_state_dir",
+             "user_log_dir",
+             "site_data_dir",
+             "site_config_dir")
+
+    print("-- app dirs %s --" % __version__)
+
+    print("-- app dirs (with optional 'version')")
+    dirs = AppDirs(appname, appauthor, version="1.0")
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = AppDirs(appname, appauthor)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = AppDirs(appname)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = AppDirs(appname, appauthor=False)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))

cheat/cheatsheets/7z

@@ -11,7 +11,7 @@ u       update
 x       extract with full paths
 
 Example:
-7z a -t7z -m0-lzma -mx=9 -mfb=64 -md=32m -ms=on archive.7z dir1
+7z a -t7z -m0=lzma -mx=9 -mfb=64 -md=32m -ms=on archive.7z dir1
 
 -t7z        7z archive
 -m0=lzma    lzma method

cheat/cheatsheets/__init__.py

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

cheat/cheatsheets/alias

@@ -0,0 +1,5 @@
+# Show a list of your current shell aliases
+alias
+
+# Map `ll` to `ls -l` (Can be used per session or put inside a shell config file)
+alias ll='ls -l'

cheat/cheatsheets/aria2c

@@ -0,0 +1,12 @@
+# Just download a file
+# The url can be a http(s), ftp, .torrent file or even a magnet link
+aria2c <url>
+
+# To prevent downloading the .torrent file
+aria2c --follow-torrent=mem <url>
+
+# Download 1 file at a time (-j) 
+# continuing (-c) any partially downloaded ones
+# to the directory specified (-d)
+# reading urls from the file (-i)
+aria2c -j 1 -c -d ~/Downloads -i /path/to/file

cheat/cheatsheets/bzip2

@@ -0,0 +1,11 @@
+# compress foo -> foo.bz2
+bzip2 -z foo
+
+# decompress foo.bz2 -> foo
+bzip2 -d foo.bz2
+
+# compress foo to stdout
+bzip2 -zc foo > foo.bz2
+
+# decompress foo.bz2 to stdout
+bzip2 -dc foo.bz2

cheat/cheatsheets/cat

@@ -0,0 +1,8 @@
+# Display the contents of a file
+cat /path/to/foo
+
+# Display contents with line numbers
+cat -n /path/to/foo
+
+# Display contents with line numbers (blank lines excluded)
+cat -b /path/to/foo

cheat/cheatsheets/cd

@@ -0,0 +1,11 @@
+#Go to the given directory
+cd path/to/directory
+
+#Go to home directory of current user
+cd
+
+#Go up to the parent of the current directory
+cd ..
+
+#Go to the previously chosen directory
+cd -

cheat/cheatsheets/cheat

@@ -0,0 +1,14 @@
+# To see example usage of a program:
+cheat <command>
+
+# To edit a cheatsheet
+cheat -e <command>
+
+# To list available cheatsheets
+cheat -l
+
+# To search available cheatsheets
+cheat -s <command>
+
+# To get the current `cheat' version
+cheat -v

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/cp

@@ -0,0 +1,11 @@
+# Create a copy of a file
+cp ~/Desktop/foo.txt ~/Downloads/foo.txt
+
+# Create a copy of a directory
+cp -r ~/Desktop/cruise_pics/ ~/Pictures/
+
+# Create a copy but ask to overwrite if the destination file already exists
+cp -i ~/Desktop/foo.txt ~/Documents/foo.txt
+
+# Create a backup file with date
+cp foo.txt{,."$(date +%Y%m%d-%H%M%S)"}

cheat/cheatsheets/crontab

@@ -16,7 +16,7 @@ SHELL=/bin/bash
 */15 * * * * /home/user/command.sh
 
 # every midnight
-* 0 * * * /home/user/command.sh
+0 0 * * * /home/user/command.sh
 
 # every Saturday at 8:05 AM
 5 8 * * 6 /home/user/command.sh

cheat/cheatsheets/cryptsetup

@@ -0,0 +1,8 @@
+# open encrypted partition /dev/sdb1 (reachable at /dev/mapper/backup)
+cryptsetup open --type luks /dev/sdb1 backup
+
+# open encrypted partition /dev/sdb1 using a keyfile (reachable at /dev/mapper/hdd)
+cryptsetup open --type luks --key-file hdd.key /dev/sdb1 hdd
+
+# close luks container at /dev/mapper/hdd
+cryptsetup close hdd

cheat/cheatsheets/curl

@@ -29,7 +29,13 @@ 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
+
+# Get your global IP
+curl httpbin.org/ip 
+
+# Get only the HTTP status code
+curl -o /dev/null -w '%{http_code}\n' -s -I URL

cheat/cheatsheets/dd

@@ -1,7 +1,7 @@
 # Read from {/dev/urandom} 2*512 Bytes and put it into {/tmp/test.txt}
 # Note: At the first iteration, we read 512 Bytes.
 # Note: At the second iteration, we read 512 Bytes.
-dd if=/dev/urandom of=/tmp/test.txt count=512 bs=2
+dd if=/dev/urandom of=/tmp/test.txt count=2 bs=512
 
 # Watch the progress of 'dd'
 dd if=/dev/zero of=/dev/null bs=4KB &; export dd_pid=`pgrep '^dd'`; while [[ -d /proc/$dd_pid ]]; do kill -USR1 $dd_pid && sleep 1 && clear; done

cheat/cheatsheets/deb

@@ -0,0 +1,7 @@
+# Extract contents of a .deb file
+$ ar vx foo.deb    # -> data.tar.gz
+$ tar xf data.tar.gz
+
+# Install .deb file to a debian like system, e.g. ubuntu
+$ sudo dpkg -i foo.deb
+$ sudo apt-get install -f

cheat/cheatsheets/diff

@@ -21,3 +21,6 @@ diff -s version1 version2
 
 # To diff the output of two commands or scripts:
 diff <(command1) <(command2)
+
+# Generate a patch file from two files
+diff -Naur version1 version2 > version.patch

cheat/cheatsheets/dpkg

@@ -5,7 +5,7 @@ dpkg -i test.deb
 dpkg -P test.deb
 
 # List all installed packages with versions and details
-dpkg -I
+dpkg -l
 
 # Find out if a Debian package is installed or not
 dpkg -s test.deb | grep Status

cheat/cheatsheets/emacs

@@ -1,70 +1,64 @@
+# Running emacs
+
+  GUI mode            $ emacs
+  Terminal mode       $ emacs -nw
+
 # Basic usage
 
   Indent              Select text then press TAB
-  Cut                 CTRL-w
+  Cut                 C-w
-  Copy                ALT-w
+  Copy                M-w
-  Paste               CTRL-y
+  Paste ("yank")      C-y
-  Search/Find         CTRL-s
+  Begin selection     C-SPACE
-  Replace             ALT-% (ALT-SHIFT-5)
+  Search/Find         C-s
-  Save                CTRL-x CTRL-s
+  Replace             M-% (M-SHIFT-5)
-  Load/Open           CTRL-x CTRL-f
+  Save                C-x C-s
-  Undo                CTRL-x u
+  Save as             C-x C-w
-  Highlight all text  CTRL-x h
+  Load/Open           C-x C-f
-  Directory listing   CTRL-x d
+  Undo                C-x u
-  Cancel a command    ESC ESC ESC
+  Highlight all text  C-x h
-  Font size bigger    CTRL-x CTRL-+
+  Directory listing   C-x d
-  Font size smaller   CTRL-x CTRL--
+  Cancel a command    C-g
+  Font size bigger    C-x C-+
+  Font size smaller   C-x C--
 
-#  Buffers
+# Buffers
 
-  Split screen vertically                         CTRL-x 2
+  Split screen vertically                         C-x 2
-  Split screen vertically with 5 row height       CTRL-u 5 CTRL-x 2
+  Split screen vertically with 5 row height       C-u 5 C-x 2
-  Split screen horizontally                       CTRL-x 3
+  Split screen horizontally                       C-x 3
-  Split screen horizontally with 24 column width  CTRL-u 24 CTRL-x 3
+  Split screen horizontally with 24 column width  C-u 24 C-x 3
-  Revert to single screen                         CTRL-x 1
+  Revert to single screen                         C-x 1
-  Hide the current screen                         CTRL-x 0
+  Hide the current screen                         C-x 0
-  Kill the current screen                         CTRL-x k
+  Move to the next screen                         C-x o
-  Move to the next buffer                         CTRL-x O
+  Kill the current buffer                         C-x k
-  Select a buffer                                 CTRL-x b
+  Select a buffer                                 C-x b
-  Run command in the scratch buffer               CTRL-x CTRL-e
+  Run command in the scratch buffer               C-x C-e
+
+# Navigation ( backward / forward )
+  
+  Character-wise                                  C-b , C-f
+  Word-wise                                       M-b  , M-f
+  Line-wise                                       C-p , C-n
+  Sentence-wise                                   M-a  , M-e
+  Paragraph-wise                                  M-{ , M-}
+  Function-wise                                   C-M-a , C-M-e
+  Line beginning / end                            C-a , C-e
 
 # Other stuff
 
-  Open a shell         ALT-x eshell
+  Open a shell         M-x eshell
-  Goto a line number   ALT-x goto-line
+  Goto a line number   M-x goto-line
-  Word wrap            ALT-x toggle-word-wrap
+  Word wrap            M-x toggle-word-wrap
-  Spell checking       ALT-x flyspell-mode
+  Spell checking       M-x flyspell-mode
-  Line numbers         ALT-x linum-mode
+  Line numbers         M-x linum-mode
-  Toggle line wrap     ALT-x visual-line-mode
+  Toggle line wrap     M-x visual-line-mode
-  Compile some code    ALT-x compile
+  Compile some code    M-x compile
-  List packages        ALT-x package-list-packages
+  List packages        M-x package-list-packages
-
-#  Sudoing within eshell
-
-  By default when using the sudo command within eshell you'll just
-  get "permission denied" messages. To overcome that type:
-
-    alias sudo '*sudo $*'
 
 # Line numbers
 
-  To add line numbers and enable moving to a line with CTRL-l:
+  To add line numbers and enable moving to a line with C-l:
 
     (global-set-key "\C-l" 'goto-line)
     (add-hook 'find-file-hook (lambda () (linum-mode 1)))
-
-# Org-mode
-
-  To begin org-mode                            ALT-x org-mode
-  Table column separator                       Vertical/pipe character
-  Reorganize table                             TAB
-  Section heading                              *
-  Open/collapse section                        TAB
-  Open/collapse All                            CTRL-TAB
-  Export in other file formats (eg HTML,PDF)   CTRL-c CTRL-e
-
-  To make org-mode automatically wrap lines:
-
-    (add-hook 'org-mode-hook
-              '(lambda ()
-                 (visual-line-mode 1)))

cheat/cheatsheets/export

@@ -0,0 +1,5 @@
+# Calling export with no arguments will show current shell attributes
+export
+
+# Create new environment variable
+export VARNAME="value"

cheat/cheatsheets/ffmpeg

@@ -2,7 +2,17 @@
 ffmpeg -i path/to/file.ext
 
 # Convert all m4a files to mp3
-for f in *.m4a; do ffmpeg -i "$f" -acodec libmp3lame -ab 320k "${f%.m4a}.mp3"; done
+for f in *.m4a; do ffmpeg -i "$f" -acodec libmp3lame -vn -b:a 320k "${f%.m4a}.mp3"; done
+
+# Convert video from .foo to .bar
+# -g : GOP, for searchability
+ffmpeg -i input.foo -vcodec bar -acodec baz -b:v 21000k -b:a 320k -g 150 -threads 4 output.bar
+
+# Convert image sequence to video
+ffmpeg -r 18 -pattern_type glob -i '*.png' -b:v 21000k -s hd1080 -vcodec vp9 -an -pix_fmt yuv420p -deinterlace output.ext
+
+# Combine video and audio into one file
+ffmpeg -i video.ext -i audio.ext -c:v copy -c:a copy output.ext
 
 # Listen to 10 seconds of audio from a video file
 #
@@ -10,3 +20,4 @@ for f in *.m4a; do ffmpeg -i "$f" -acodec libmp3lame -ab 320k "${f%.m4a}.mp3"; d
 # -t  : seconds to cut
 # -autoexit : closes ffplay as soon as the audio finishes
 ffmpeg -ss 00:34:24.85 -t 10 -i path/to/file.mp4 -f mp3 pipe:play | ffplay -i pipe:play -autoexit
+

cheat/cheatsheets/find

@@ -19,11 +19,11 @@ find ./path/ -name '*.txt' -exec rm '{}' \;
 # To find files with extension '.txt' and look for a string into them:
 find ./path/ -name '*.txt' | xargs grep 'string'
 
-# To find files with size bigger than 5 Mb and sort them by size:
+# To find files with size bigger than 5 Mebibyte and sort them by size:
 find . -size +5M -type f -print0 | xargs -0 ls -Ssh | sort -z
 
-# To find files bigger thank 2 MB and list them:
+# To find files bigger than 2 Megabyte and list them:
-find . -type f -size +20000k -exec ls -lh {} \; | awk '{ print $9 ": " $5 }'
+find . -type f -size +200000000c -exec ls -lh {} \; | awk '{ print $9 ": " $5 }'
 
 # To find files modified more than 7 days ago and list file information
 find . -type f -mtime +7d -ls

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/git

@@ -11,6 +11,24 @@ git config --global color.ui true
 # To stage all changes for commit:
 git add --all
 
+# To stash changes locally, this will keep the changes in a separate changelist
+# called stash and the working directory is cleaned. You can apply changes
+# from the stash anytime
+git stash
+
+# To stash changes with a message
+git stash save "message"
+
+# To list all the stashed changes
+git stash list
+
+# To apply the most recent change and remove the stash from the stash list
+git stash pop
+
+# To apply any stash from the list of stashes. This does not remove the stash
+# from the stash list
+git stash apply stash@{6}
+
 # To commit staged changes
 git commit -m "Your commit message"
 
@@ -124,3 +142,10 @@ git show :/cool
 
 # Undo parts of last commit in a specific file
 git checkout -p HEAD^ -- /path/to/file
+
+# Revert a commit and keep the history of the reverted change as a separate revert commit
+git revert <commit SHA>
+
+# Pich a commit from a branch to current branch. This is different than merge as
+# this just applies a single commit from a branch to current branch
+git cherry-pick <commit SHA1>

cheat/cheatsheets/gyb

@@ -0,0 +1,12 @@
+# To estimate the number and the size of all mails on youremail@gmail.com
+gyb --email youremail@gmail.com --action estimate
+
+# To backup from youremail@gmail.com to your local-folder 
+gyb --email youremail@gmail.com --action backup --local-folder "~/MyLocalFolder/"
+
+# To backup from youremail@gmail.com only important or starred emails to the
+# default local folder GYB-GMail-Backup-youremail@gmail.com
+gyb --email youremail@gmail.com --search "is:important OR is:starred"
+
+# To restore from your local-folder to youremail@gmail.com
+gyb --email youremail@gmail.com --action restore --local-folder "~/MyLocalFolder/" 

cheat/cheatsheets/hg

@@ -0,0 +1,20 @@
+# Clone a directory
+hg clone
+
+# Add files to hg tracker
+hg add filename
+
+# Add all files in a folder to hg tracker
+hg add folder/
+
+# Create a commit with all tracked changes and a message
+hg commit -m "message"
+
+# Push commits to source repository
+hg push
+
+# Pull changes from source repository
+hg pull
+
+# Rebase local commits to disambiguate with remote repository
+hg pull --rebase

cheat/cheatsheets/iconv

@@ -0,0 +1,3 @@
+# To convert file (iconv.src) from iso-8859-1 to utf-8 and save to
+# /tmp/iconv.out
+iconv -f iso-8859-1 -t utf-8 iconv.src -o /tmp/iconv.out

cheat/cheatsheets/kill

@@ -0,0 +1,5 @@
+# Kill a process gracefully
+kill -15 <process id>
+
+# Kill a process forcefully
+kill -9 <process id>

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/lsof

@@ -4,20 +4,34 @@ sudo lsof -i4
 # List all IPv6 network files
 sudo lsof -i6
 
-# To find listening ports:
+# List all open sockets
+lsof -i
+
+# List all listening ports
 lsof -Pnl +M -i4
 
-# To find which program is using the port 80:
+# Find which program is using the port 80
 lsof -i TCP:80
 
+# List all connections to a specific host
+lsof -i@192.168.1.5
+
 # List all processes accessing a particular file/directory
 lsof </path/to/file>
 
 # List all files open for a particular user
 lsof -u <username>
 
-# List all files/network connections a given process is using
+# List all files/network connections a command is using
 lsof -c <command-name>
 
+# List all files a process has open
+lsof -p <pid>
+
+# List all files open mounted at /mount/point.
+# Particularly useful for finding which process(es) are using a
+# mounted USB stick or CD/DVD.
+lsof +f -- </mount/point>
+
 # See this primer: http://www.danielmiessler.com/study/lsof/
 # for a number of other useful lsof tips

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/mutt

@@ -0,0 +1,22 @@
+# Create new mailbox in IMAP
+	+ When located in mailbox list (c)
+		shift + C 
+
+# Move multiple messages to folder (bulk operations)
+	
+	1. Select/tag them with alt+'t'
+	2. ;s in mail inbox overview for bulk operation
+
+# Deleting / Undeleting all messages in mutt
+	
+	1. In mutt’s index, hit ‘D’ (UPPERCASE D)
+	2. It will prompt you with “Delete messages matching: “
+		
+		+ enter this string:
+
+		~A
+
+	3. It should mark all for deletion!
+
+ 
+	4. Conversely, you can do the same thing with UPPERCASE U to undelete multiple messages. 

cheat/cheatsheets/mv

@@ -0,0 +1,17 @@
+# Move a file from one place to another
+mv ~/Desktop/foo.txt ~/Documents/foo.txt
+
+# Move a file from one place to another and automatically overwrite if the destination file exists
+# (This will override any previous -i or -n args)
+mv -f ~/Desktop/foo.txt ~/Documents/foo.txt
+
+# Move a file from one place to another but ask before overwriting an existing file
+# (This will override any previous -f or -n args)
+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/mysql

@@ -28,4 +28,10 @@ INSERT INTO tbl_name (col1,col2) VALUES(15,col1*2);
 UPDATE tbl_name SET col1 = "example";
 
 # Basic DELETE Statement
-DELETE FROM tbl_name WHERE user = 'jcole';
+DELETE FROM tbl_name WHERE user = 'jcole';
+
+# To check stored procedure
+SHOW PROCEDURE STATUS;
+
+# To check stored function
+SHOW FUNCTION STATUS;

cheat/cheatsheets/netstat

@@ -18,11 +18,11 @@ sudo netstat -vtlnp --listening -4
 # Replace it by:
 ss
 
-# For netstat-r
+# For netstat -r
 ip route
 
 # For netstat -i
 ip -s link
 
-# For netstat-g
+# For netstat -g
 ip maddr

cheat/cheatsheets/nmap

@@ -67,3 +67,38 @@ nmap -T5 --min-parallelism=50 -n --script "ssl-heartbleed" -pT:443 127.0.0.1
 
 # Show all informations (debug mode)
 nmap -d ...
+
+## Port Status Information
+- Open: This indicates that an application is listening for connections on this port.
+- Closed: This indicates that the probes were received but there is no application listening on this port.
+- Filtered: This indicates that the probes were not received and the state could not be established. It also indicates that the probes are being dropped by some kind of filtering.
+- Unfiltered: This indicates that the probes were received but a state could not be established.
+- Open/Filtered: This indicates that the port was filtered or open but Nmap couldn’t establish the state.
+- Closed/Filtered: This indicates that the port was filtered or closed but Nmap couldn’t establish the state.
+
+## Additional Scan Types
+
+nmap -sn: Probe only (host discovery, not port scan)
+nmap -sS: SYN Scan
+nmap -sT: TCP Connect Scan
+nmap -sU: UDP Scan
+nmap -sV: Version Scan
+nmap -O: Used for OS Detection/fingerprinting
+nmap --scanflags: Sets custom list of TCP using `URG ACK PSH RST SYN FIN` in any order
+
+### Nmap Scripting Engine Categories
+The most common Nmap scripting engine categories:
+- auth: Utilize credentials or bypass authentication on target hosts.
+- broadcast: Discover hosts not included on command line by broadcasting on local network.
+- brute: Attempt to guess passwords on target systems, for a variety of protocols, including http, SNMP, IAX, MySQL, VNC, etc.
+- default: Scripts run automatically when -sC or -A are used.
+- discovery: Try to learn more information about target hosts through public sources of information, SNMP, directory services, and more.
+- dos: May cause denial of service conditions in target hosts.
+- exploit: Attempt to exploit target systems.
+- external: Interact with third-party systems not included in target list.
+- fuzzer: Send unexpected input in network protocol fields.
+- intrusive: May crash target, consume excessive resources, or otherwise impact target machines in a malicious fashion.
+- malware: Look for signs of malware infection on the target hosts.
+- safe: Designed not to impact target in a negative fashion.
+- version: Measure the version of software or protocols on the target hosts.
+- vul: Measure whether target systems have a known vulnerability.

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/npm

@@ -0,0 +1,22 @@
+# Every command shown here can be used with the `-g` switch for global scope
+
+# Install a package in the current directory
+npm install <package>
+
+# Install a package, and save it in the `dependencies` section of `package.json`
+npm install --save <package>
+
+# Install a package, and save it in the `devDependencies` section of `package.json`
+npm install --save-dev <package>
+
+# Show outdated packages in the current directory
+npm outdated
+
+# Update outdated packages
+npm update
+
+# Update `npm` (will override the one shipped with Node.js)
+npm install -g npm
+
+# Uninstall a package
+npm uninstall <package>

cheat/cheatsheets/openssl

@@ -15,6 +15,9 @@ openssl req -text -noout -in server.csr
 # To show certificate information for generated certificate
 openssl x509 -text -noout -in server.crt 
 
+# To get the sha256 fingerprint of a certificate
+openssl x509 -in server.crt -noout -sha256 -fingerprint
+
 # To view certificate expiration:
 echo | openssl s_client -connect <hostname>:443 2> /dev/null | \
 awk '/-----BEGIN/,/END CERTIFICATE-----/' | \

cheat/cheatsheets/org-mode

@@ -0,0 +1,46 @@
+  Begin org-mode                               ALT-x org-mode
+  Save                                         CTRL-x CTRL-s
+  Export in other file formats (eg HTML,PDF)   CTRL-c CTRL-e
+
+# Outline
+
+  Section heading                              *
+  New headline                                 ALT-return
+  Move headline up or down                     ALT-up_arrow/down_arrow
+  Adjust indent depth of headline              ALT-left_arrow/right_arrow
+  Open/collapse section                        TAB
+  Open/collapse All                            CTRL-TAB
+
+# To-Do Lists
+
+  Mark list item as TODO                       ** TODO
+  Cycle through workflow                       SHIFT-left_arrow/right_arrow
+  Show only outstanding TODO                   items CTRL-c CTRL-v
+
+# Tables
+
+  Table column separator                       Vertical/pipe character
+  Reorganize table                             TAB
+  Move column                                  ALT-left_arrow/right_arrow
+  Move row                                     ALT-up_arrow/down_arrow
+
+# Styles
+
+  *bold*
+  /italic/
+  _underlined_
+  =code=
+  ~verbatim~
+  +strike-through+
+
+# Heading
+
+  Header         -*- mode: org -*-
+
+# .emacs
+
+  To make org-mode automatically wrap lines:
+
+    (add-hook 'org-mode-hook
+              '(lambda ()
+                 (visual-line-mode 1)))

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/patch

@@ -0,0 +1,13 @@
+# Patch one file
+patch version1 < version.patch
+
+# Reverse a patch
+patch -R version1 < version.patch
+
+# Patch all files in a directory, adding any missing new files
+# -p strips leading slashes
+$ cd dir
+$ patch -p1 -i ../big.patch
+
+# Patch files in a directory, with one level (/) offset
+patch -p1 -r version1/ < version.patch

cheat/cheatsheets/perl

@@ -0,0 +1,8 @@
+# To view the perl version:
+perl -v
+
+# Replace string "\n" to newline
+echo -e "foo\nbar\nbaz" | perl -pe 's/\n/\\n/g;'
+
+# Replace newline with multiple line to space
+cat test.txt | perl -0pe "s/test1\ntest2/test1 test2/m"

cheat/cheatsheets/pgrep

@@ -0,0 +1,5 @@
+# Get a list of PIDs matching the pattern 
+pgrep example
+
+# Kill all PIDs matching the pattern
+pgrep -f example | xargs kill

cheat/cheatsheets/pip

@@ -23,5 +23,8 @@ pip list --outdated
 # Upgrade all outdated packages, thanks to http://stackoverflow.com/a/3452888
 pip freeze --local | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U
 
+# Upgrade outdated packages on latest version of pip
+pip list --outdated --format=freeze | cut -d = -f 1 | xargs -n1 pip install -U
+
 # Install specific version of a package
 pip install -I SomePackage1==1.1.0 'SomePackage2>=1.0.4'

cheat/cheatsheets/pkgtools

@@ -0,0 +1,27 @@
+# Create a Slackware package from a structured directory and sub-tree
+$ cd /path/to/pkg/dir
+$ su - c 'makepkg --linkadd y --chown n $foo-1.0.3-x86_64-1_tag.tgz'
+
+
+# Install a Slackware package
+installpkg foo-1.0.3-x86_64-1.tgz
+
+# Install a Slackware package to non-standard location
+ROOT=/path/to/dir installpkg foo-1.0.4-noarch-1.tgz
+
+# Create backup of files that will be overwritten when installing
+tar czvf /tmp/backup.tar.gz $(installpkg --warn foo-1.0.4-noarch-1.tgz)
+
+
+# Upgrade a Slackware package including files only in new version
+upgradepkg --install-new foo-1.0.6-noarch-1.tgz
+
+# Upgrade a Slackware package even if version is the same
+upgradepkg --reinstall foo-1.0.4-noarch-1.tgz
+
+
+# Remove a Slackware package
+removepkg foo-0.2.8-x86_64-1
+
+# Remove a Slackware package, retaining a backup (uninstalled) copy
+removepkg -copy foo-0.2.8-x86_64-1  # -> /var/log/setup/tmp/preserved_packages/foo...

cheat/cheatsheets/pkill

@@ -0,0 +1,5 @@
+# To kill a process using it's full process name
+pkill <processname>
+
+# To kill a process by it's partial name
+pkill -f <string>

cheat/cheatsheets/popd

@@ -0,0 +1,2 @@
+# Returns to the directory at the top of the `pushd' stack
+popd

cheat/cheatsheets/psql

@@ -0,0 +1,27 @@
+# psql is the PostgreSQL terminal interface. The following commands were tested on version 9.5.
+# Connection options:
+# -U username (if not specified current OS user is used).
+# -p port.
+# -h server hostname/address.
+
+# Connect to a specific database:
+psql -U postgres -h serverAddress -d dbName
+
+# Get databases on a server:
+psql -U postgres -h serverAddress --list
+
+# Execute sql query and save output to file:
+psql -U postgres -d dbName -c 'select * from tableName;' -o fileName
+
+# Execute query and get tabular html output:
+psql -U postgres -d dbName -H -c 'select * from tableName;'
+
+# Execute query and save resulting rows to csv file
+# (if column names in the first row are not needed, remove the word 'header'):
+psql -U postgres -d dbName -c 'copy (select * from tableName) to stdout with csv header;' -o fileName.csv
+
+# Read commands from file:
+psql -f fileName
+
+# Restore databases from file:
+psql -f fileName.backup postgres

cheat/cheatsheets/pushd

@@ -0,0 +1,5 @@
+# Pushes your current directory to the top of a stack while changing to the specified directory
+pushd <directory>
+
+# To return use popd
+popd

cheat/cheatsheets/pwd

@@ -0,0 +1,2 @@
+# Show the absolute path of your current working directory on the filesystem
+pwd

cheat/cheatsheets/r2

@@ -0,0 +1,936 @@
+# Command Line options
+	-L: List of supported IO plugins
+
+	-q: Exit after processing commands
+
+	-w: Write mode enabled
+
+	-i: Interprets a r2 script
+
+	-A: Analize executable at load time (xrefs, etc)
+
+	-n: Bare load. Do not load executable info as the entrypoint
+
+	-c'cmds': Run r2 and execute commands (eg: r2 -wqc'wx 3c @ main')
+
+	-p: Creates a project for the file being analyzed (CC add a comment when opening a file as a project)
+
+	-: Opens r2 with the malloc plugin that gives a 512 bytes memory area to play with (size can be changed); Similar to r2 malloc://512
+
+-----------------------------------------------------------------------------------------------------------------------------
+
+# Configuration properties
+	e: Returs configuration properties
+	
+	e <property>: Checks a specific property:
+    		e asm.tabs => false
+
+	e <property>=<value>: Change property value
+    		e asm.arch=ppc
+
+	e? help about a configuration property
+    		e? cmd.stack
+
+	
+	
+	# Show comments at right of disassembly if they fit in screen
+		e asm.cmtright=true
+
+	# Shows pseudocode in disassembly. Eg mov eax, str.ok = > eax = str.ok
+		e asm.pseudo = true
+
+	# Display stack and register values on top of disasembly view (visual mode)
+		e cmd.stack = true
+
+	# Solarized theme
+		eco solarized
+
+	# Use UTF-8 to show cool arrows that do not look like crap :)
+		e scr.utf8 = true
+
+-----------------------------------------------------------------------------------------------------------------------------
+
+# Basic Commands
+
+	; Command chaining: x 3;s+3;pi 3;s+3;pxo 4;
+    
+	| Pipe with shell commands: pd | less
+    
+	! Run shell commands: !cat /etc/passwd
+    
+	!! Escapes to shell, run command and pass output to radare buffer
+    		
+		Note: 	The double exclamation mark tells radare to skip the plugin list to find an IO plugin handling this
+			command to launch it directly to the shell. A single one will walk through the io plugin list.
+
+    	` Radare commands: wx `!ragg2 -i exec`
+    
+	~ grep
+    
+	~! grep -v
+    
+	~[n] grep by columns afl~[0]
+
+    	~:n grep by rows afl~:0
+	
+	<command>~.. less/more mode
+
+	+-------------------------------------------------------------------
+	
+	pi~mov,eax            ; lines with mov or eax
+    	pi~mov&eax            ; lines with mov and eax
+    	pi~mov,eax:6          ; 6 first lines with mov or eax
+    	pd 20~call[0]:0       ; grep first column of the first row matching 'call'
+	
+	+-------------------------------------------------------------------
+
+	.cmd Interprets command output
+	
+	+-------------------------------------------------------------------
+	
+	is* prints symbolos
+	.is* interprets output and define the symbols in radare (normally they are already loaded if r2 was not invoked with -n)
+	
+	+-------------------------------------------------------------------
+	
+	.. repeats last commands (same as enter \n)
+    	
+	( Used to define and run macros
+    
+	$ Used to define alias
+    
+	$$: Resolves to current address
+    	
+	Offsets (@) are absolute, we can use $$ for relative ones @ $$+4
+    
+	? Evaluate expression
+	+-------------------------------------------------------------------
+
+	[0x00000000]> ? 33 +2
+	35 0x23 043 0000:0023 35 00100011 35.0 0.000000
+	Note: | and & need to be escaped
+
+	+-------------------------------------------------------------------
+
+	?$? Help for variables used in expressions
+    
+	$$: Here
+    
+	$s: File size
+    
+	$b: Block size
+    
+	$l: Opcode length
+    
+	$j: When $$ is at a jmp, $j is the address where we are going to jump to
+    
+	$f: Same for jmp fail address
+	
+	$m: Opcode memory reference (e.g. mov eax,[0x10] => 0x10)
+    
+	??? Help for ? command
+    
+	?i Takes input from stdin. Eg ?i username
+    
+	?? Result from previous operations
+    
+	?s from to [step]: Generates sequence from to every
+    
+	?p: Get physical address for given virtual address
+    
+	?P: Get virtual address for given physical one
+    
+	?v Show hex value of math expr
+
+	+-------------------------------------------------------------------
+
+	?v 0x1625d4ca ^ 0x72ca4247 = 0x64ef968d
+	?v 0x4141414a - 0x41414140  = 0xa
+
+	+-------------------------------------------------------------------
+
+	?l str: Returns the length of string
+    
+	@@: Used for iteractions
+
+	+-------------------------------------------------------------------
+
+	wx ff @@10 20 30      Writes ff at offsets 10, 20 and 30
+	wx ff @@`?s  1 10 2`  Writes ff at offsets 1, 2 and 3
+	wx 90 @@ sym.*        Writes a nop on every symbol
+
+	+-------------------------------------------------------------------
+
+# Positioning
+
+	s address: Move cursor to address or symbol
+	
+	s-5 (5 bytes backwards)
+	
+	s- undo seek
+
+	s+ redo seek
+
+# Block Size
+
+	b size: Change block size
+
+# Analyze
+	
+	aa: Analyze all (fcns + bbs) same that running r2 with -A
+
+	ahl <length> <range>: fake opcode length for a range of bytes
+	
+	ad: Analyze data
+
+	ad@rsp (analize the stack)
+
+	+ Normal mode
+		
+		af: Analyze functions
+
+		afl: List all functions
+    			number of functions: afl~?
+
+		afi: Returns information about the functions we are currently at
+
+		afr: Rename function: structure and flag
+	
+		afr off: Restore function name set by r2
+
+		afn: Rename function
+		
+		afn strlen 0x080483f0
+
+		af-: Removes metadata generated by the function analysis
+
+		af+: Define a function manually given the start address and length
+			af+ 0xd6f 403 checker_loop
+
+		axt: Returns cross references to (xref to)
+
+		axf: Returns cross references from (xref from)
+	
+	+ Visual mode
+
+		d, f: Function analysis
+
+		d, u: Remove metadata generated by function analysis
+
+	+ Opcode analysis
+		
+		ao x: Analize x opcodes from current offset
+
+		a8 bytes: Analize the instruction represented by specified bytes
+
+# Information
+
+		iI: File info
+
+		iz: Strings in data section
+
+		izz: Strings in the whole binary
+	
+		iS: Sections
+			iS~w returns writable sections
+
+		is: Symbols
+			is~FUNC exports
+		
+		il: Linked libraries
+
+		ii: Imports
+
+		ie: Entrypoint
+
+	+ Mitigations
+
+		i~pic : check if the binary has position-independent-code
+	
+		i~nx : check if the binary has non-executable stack
+
+		i~canary : check if the binary has canaries
+
+# Print
+
+	psz n @ offset: Print n zero terminated String
+
+	px n @ offset: Print hexdump (or just x) of n bytes
+
+	pxw n @ offset: Print hexdump of n words
+		pxw size@offset  prints hexadecimal words at address
+
+	pd n @ offset: Print n opcodes disassambled
+
+	pD n @ offset: Print n bytes disassembled
+
+	pi n @ offset: Print n instructions disassambeled (no address, XREFs, etc. just instrunctions)
+
+	pdf @ offset: Print disassembled function
+		pdf~XREF (grep: XREFs)
+		pdf~call (grep: calls)
+
+	pcp n @ offset: Print n bytes in python string output.
+		pcp 0x20@0x8048550
+		import struct
+		buf = struct.pack ("32B",
+    			0x55,0x89,0xe5,0x83,0xzz,0xzz,0xzz,0xzz,0xf0,0x00,0x00,
+			0x00,0x00,0xc7,0x45,0xf4,0x00,0x00,0x00,0x00,0xeb,0x20,
+			0xc7,0x44,0x24,0x04,0x01,0x00,0x00,0x00,0xzz,0xzz)
+
+	p8 n @ offset: Print n bytes (8bits) (no hexdump)
+	
+	pv: Print file contents as IDA bar and shows metadata for each byte (flags , ...)
+
+	pt: Interpret data as dates
+
+	pf: Print with format
+
+	pf.: list all formats
+
+	p=: Print entropy ascii graph
+
+# Write
+
+	wx: Write hex values in current offset
+    		wx 123456
+    		wx ff @ 4
+
+	wa: Write assembly
+    		wa jnz 0x400d24
+
+	wc: Write cache commit
+
+	wv: Writes value doing endian conversion and padding to byte
+
+	wo[x]: Write result of operation
+    		wow 11223344 @102!10
+        		write looped value from 102 to 102+10
+        		0x00000066  1122 3344 1122 3344 1122 0000 0000 0000
+    
+	wox 0x90
+        	XOR the current block with 0x90. Equivalent to wox 0x90 $$!$b (write from current position, a whole block)
+    	
+	wox 67 @4!10
+        	XOR from offset 4 to 10 with value 67
+
+	wf file: Writes the content of the file at the current address or specified offset (ASCII characters only)
+
+	wF file: Writes the content of the file at the current address or specified offset
+
+	wt file [sz]: Write to file (from current seek, blocksize or sz bytes)
+    		Eg: Dump ELF files with wt @@ hit0* (after searching for ELF headers: \x7fELF)
+
+	woO 41424344 : get the index in the De Bruijn Pattern of the given word
+
+# Flags
+
+	f: List flags
+
+	f label @ offset: Define a flag `label` at offset
+    		f str.pass_len @ 0x804999c
+
+	f -label: Removes flag
+
+	fr: Rename flag
+
+	fd: Returns position from nearest flag (looking backwards). Eg => entry+21
+
+	fs: Show all flag spaces
+
+	fs flagspace: Change to the specified flag space
+
+	fe loop and create numbered flags:
+		
+		1. fs demo_flagspace
+		2. fe demo_flagspace @@=`pdf~jne[1]`
+
+# Yank & Paste
+
+	y n: Copies n bytes from current position
+
+	y: Shows yank buffer contentent with address and length where each entry was copied from
+
+	yp: Prints yank buffer
+
+	yy offset: Paste the contents of the yank buffer at the specified offset
+
+	yt n target @ source: Yank to. Copy n bytes fromsource to target address
+
+# Visual Mode
+
+	q: Exits visual mode
+
+	hjkl: move around (or HJKL) (left-down-up-right)
+
+	o: go/seek to given offset
+
+	?: Help
+
+	.: Seek EIP
+
+	<enter>: Follow address of the current jump/call
+
+	:cmd: Enter radare commands. Eg: x @ esi
+
+	d[f?]: Define cursor as a string, data, code, a function, or simply to undefine it.
+    		dr: Rename a function
+    		df: Define a function
+
+	v: Get into the visual code analysis menu to edit/look closely at the current function.
+
+	p/P: Rotate print (visualization) modes
+    		hex, the hexadecimal view
+    		disasm, the disassembly listing
+        		Use numbers in [] to follow jump
+        		Use "u" to go back
+    		
+		debug, the debugger
+    		words, the word-hexidecimal view
+    		buf, the C-formatted buffer
+    		annotated, the annotated hexdump.
+
+	c: Changes to cursor mode or exits the cursor mode
+    		select: Shift+[hjkl]
+    		i: Insert mode
+    		a: assembly inline
+    		A: Assembly in visual mode
+    		y: Copy
+    		Y: Paste
+    		f: Creates a flag where cursor points to
+    		<tab> in the hexdump view to toggle between hex and strings columns
+
+	V: View ascii-art basic block graph of current function
+
+	W: WebUI
+
+	x, X: XREFs to current function. ("u" to go back)
+
+	t: track flags (browse symbols, functions..)
+
+	gG: Begging or end of file
+
+	HUD
+    		_ Show HUD
+    		backspace: Exits HUD
+    		We can add new commands to HUD in: radare2/shlr/hud/main
+
+	;[-]cmt: Add/remove comment
+
+	m<char>: Define a bookmark
+
+	'<char>: Go to previously defined bookmark
+
+# ROP
+	
+	/R opcodes: Search opcodes
+    	
+	/R pop,pop,ret
+	
+	/Rl opcodes: Search opcodes and print them in linear way
+	
+	/Rl jmp eax,call ebx
+
+	/a: Search assembly
+    	
+	/a jmp eax
+
+	pda: Returns a library of gadgets that can be use. These gadgets are obtained by disassmbling byte per byte instead of obeying to opcode leng
+
+	e search.roplen = 4  (change the depth of the search, to speed-up the hunt)
+
+# Searching
+
+	/ bytes: Search bytes
+    		\x7fELF
+
+	+-------------------------------------------------------------------
+
+	push ebp
+	mov ebp, esp
+
+	Opcodes: 5589e5
+
+	/x 5589e5
+		[# ]hits: 54c0f4 < 0x0804c600  hits = 1
+    		0x08049f70 hit0_0 5589e557565383e4f081ec
+    		0x0804c31a hit0_1 5589e583ec18c704246031
+    		0x0804c353 hit0_2 5589e583ec1889442404c7
+    		0x0804c379 hit0_3 5589e583ec08e87cffffff
+    		0x0804c3a2 hit0_4 5589e583ec18c70424302d
+
+		pi 5 @@hit* (Print 5 first instructions of every hit)
+
+	+-------------------------------------------------------------------
+
+	Its possible to run a command for each hit. Use the cmd.hit property:
+
+		e cmd.hit=px
+
+# Comments and defines
+
+	Cd [size]: Define as data
+
+	C- [size]: Define as code
+
+	Cs [size]: Define as String
+
+	Cf [size]: Define as struct
+    		We can define structures to be shown in the disassmbly
+
+	CC: List all comments or add a new comment in console mode
+    		C* Show all comments/metadata
+    		CC <comment> add new comment
+    		CC- remove comment
+
+# Magic files
+
+	pm: Print Magic files analysis
+    		[0x00000000]> pm
+    		0x00000000 1 ELF 32-bit LSB executable, Intel 80386, version 1
+
+	/m [magicfile]: Search magic number headers with libmagic
+
+	search.align
+	search.from (0 = beginning)
+	search.to (0 = end)
+	search.asmstr
+	search.in
+
+# Yara
+	
+	:yara scan
+
+# Zignatures
+
+	zg <language> <output file>: Generate signatures
+		eg: zg go go.z
+
+	Run the generated script to load signatures
+    		eg: . go.z
+
+	z: To show signatures loaded:
+
+	+-------------------------------------------------------------------
+	
+	r2-(pid2)> pd 35 @ 0x08049adb-10
+	|          0x08049adb   call fcn.0805b030
+	|             fcn.0805b030(unk, unk, unk, unk) ; sign.sign.b.sym.fmt.Println
+	|          0x08049ae0   add esp, 0xc
+	|          0x08049ae3   call fcn.08095580
+
+	+-------------------------------------------------------------------
+
+# Compare Files
+
+	r2 -m 0xf0000 /etc/fstab    ; Open source file
+	
+	o /etc/issue                ; Open file2 at offset 0
+	
+	o                           ; List both files
+
+	cc offset: Diff by columns between current offset address and "offset"
+
+# Graphs
+
+	+ Basic block graphs
+		
+		af: Load function metadata
+
+		ag $$ > a.dot: Dump basic block graph to file
+
+		ag $$ | xdot: Show current function basic block graph
+
+	+ Call graphs
+
+		af: Load function metadata
+
+		agc $$ > b.dot: Dump basic block graph to file
+
+	+ Convert .dot in .png
+
+		dot -Tpng -o /tmp/b.png b.dot
+
+	+ Generate graph for file
+
+		radiff2 -g main crackme.bin crackme.bin > /tmp/a
+		xdot /tmp/a
+
+# Debugger
+
+	+ Start r2 in debugger mode. r2 will fork and attach
+		
+		r2 -d [pid|cmd|ptrace] (if command contains spaces use quotes: r2 -d "ls /")
+		
+		ptrace://pid (debug backend does not notice, only access to mapped memory)
+
+	+ Pass arguments
+		
+		r2 -d rarun2 program=pwn1 arg1=$(python exploit.py)
+
+	+ Pass stdin
+		
+		r2 -d rarun2 program=/bin/ls stdin=$(python exploit.py)
+
+	+ Commands
+
+		do: Reopen program
+
+		dp: Shows debugged process, child processes and threads
+
+		dc: Continue
+
+		dcu <address or symbol>: Continue until symbol (sets bp in address, continua until bp and remove bp)
+
+		dc[sfcp]: Continue until syscall(eg: write), fork, call, program address (To exit a library)
+
+		ds: Step in
+
+		dso: Step out
+
+		dss: Skip instruction
+
+		dr register=value: Change register value
+
+		dr(=)?: Show register values
+
+		db address: Sets a breakpoint at address
+    			db sym.main add breakpoint into sym.main
+    			db 0x804800 add breakpoint
+    			db -0x804800 remove breakpoint
+
+		dsi (conditional step): Eg: "dsi eax==3,ecx>0"
+
+		dbt: Shows backtrace
+
+		drr: Display in colors and words all the refs from registers or memory
+
+		dm: Shows memory map (* indicates current section)
+    			[0xb776c110]> dm
+    			sys 0x08048000 - 0x08062000 s r-x /usr/bin/ls
+    			sys 0x08062000 - 0x08064000 s rw- /usr/bin/ls
+    			sys 0xb776a000 - 0xb776b000 s r-x [vdso]
+    			sys 0xb776b000 * 0xb778b000 s r-x /usr/lib/ld-2.17.so
+    			sys 0xb778b000 - 0xb778d000 s rw- /usr/lib/ld-2.17.so
+    			sys 0xbfe5d000 - 0xbfe7e000 s rw- [stack]
+
+	+ To follow child processes in forks (set-follow-fork-mode in gdb)
+
+		dcf until a fork happen then use dp to select what process you want to debug.
+
+	+ PEDA like details
+		
+		drr;pd 10@-10;pxr 40@esp
+
+	+ Debug in visual mode
+
+		toggl breakpoints with F2
+		single-step with F7 (s)
+		step-over with F8 (S)
+		continue with F9
+
+# WebGUI
+	
+	=h: Start the server
+	=H: Start server and browser
+
+# rax2 - Base Conversion
+
+	-e: Change endian
+	
+	-k: random ASCII art to represent a number/hash. Similar to how SSH represents keys
+	
+	-s: ASCII to hex
+    		rax2 -S hola (from string to hex)
+    		rax2 -s 686f6c61 (from hex to string)
+
+	-S: binary to hex (for files)
+	
+	-N: pack an integer 
+		rax2 -N 0x1234 # \x34\x12\x00\x00
+
+# rahash2 - Entropy, hashes and checksums
+
+	-a: Specify the algorithm
+
+	-b XXX: Block size
+
+	-B: Print all blocks
+
+	-a entropy: Show file entropy or entropy per block (-B -b 512 -a entropy)
+	
+	+ Rot13 with rahash2
+		rahash2 -E rot -S s:13 -s ‘Hello\n’
+
+# radiff2 - File diffing
+
+	-s: Calculate text distance from two files.
+
+	-d: Delta diffing (For files with different sizes. Its not byte per byte)
+
+	-C: Code diffing (instead of data)
+
+	+-------------------------------------------------------------------
+
+	Diff original and patched on x86_32, using graphdiff algorithm
+    		radiff2 -a x86 -b32 -C original patched
+
+	Show differences between original and patched on x86_32
+    		radiff2 -a x86 -b32 original patched :
+
+	+-------------------------------------------------------------------
+
+# rasm2 - Assembly/Disasembly
+ 
+	-L: Supported architectures
+
+	-a arch instruction: Sets architecture
+    		rasm2 -a x86 'mov eax,30' => b81e000000
+
+	-b tam: Sets block size
+
+	-d: Disassembly
+    		rasm2 -d b81e000000 => mov eax, 0x1e
+
+	-C: Assembly in C output
+    		rasm2 -C 'mov eax,30' => "\xb8\x1e\x00\x00\x00"
+
+	-D: Disassemble showing hexpair and opcode
+    		rasm2 -D b81e0000 => 0x00000000   5               b81e000000  mov eax, 0x1e
+
+	-f: Read data from file instead of ARG.
+
+	-t: Write data to file
+
+	+ Disassemble shellcode from hex stdin
+
+	+-------------------------------------------------------------------
+
+	echo -n "31c048bbd19d9691d08c97ff48f7db53545f995257545eb03b0f05" | rasm2 -a x86 -b 64 -d -
+		xor eax, eax
+		movabs rbx, 0xff978cd091969dd1
+		neg rbx
+		push rbx
+		push rsp
+		pop rdi
+		cdq
+		push rdx
+		push rdi
+		push rsp
+		pop rsi
+		mov al, 0x3b
+		syscall
+
+	+-------------------------------------------------------------------
+
+# rafind2 - Search
+
+	-Z: Look for Zero terminated strings
+
+	-s str: Look for specifc string
+
+	-X: Hex dump around output
+
+	+ Search "/bin/sh" in libc
+
+		rafind2 -X -s "/bin/sh" /usr/lib/libc.so.6
+
+# ragg2 - Shellcode generator, C/opcode compiler
+
+	P: Generate De Bruijn patterns
+    		ragg2 -P 300 -r
+
+	-a arch: Configure architecture
+
+	-b bits: Specify architecture bits (32/64)
+
+	-i shellcode: Specify shellcode to generate
+
+	-e encoder: Specify encoder
+
+	+ ragg2-cc: Generate shellcode from c
+
+	+ Generate a x86, 32 bits exec shellcode
+    		ragg2 -a x86 -b 32 -i exec
+
+# rabin2 - Executable analysis: symbols, imports, strings
+
+	-I: Executable information
+
+	-C: Returns classes. Useful to list Java Classes
+
+	-l: Dynamic linked libraries
+
+	-s: Symbols
+
+	-z: Strings
+
+# rarun2 - Launcher to run programs with different environments, args, stdin, permissions, fds
+
+	r2 -b 32 -d rarun2 program=pwn1 arg1=$(ragg2 -P 300 -r) : runs pwn1 with a De Bruijn Pattern as first argument, inside radare2's debugger, and force 32 bits
+	r2 -d rarun2 program=/bin/ls stdin=$(python exploit.py) : runs /bin/ls with the output of exploit.py directed to stdin
+
+# ESIL emulation
+
+	1) aei: Initialize ESIL VM
+	
+	2) aeim: Assign ESIL stack
+		aeim 0xffffd000 0x1000 stack
+	
+	3) aeip: Program counter to current seek
+
+	4) e io.cache=true: Enable caching read/write of virtual memory (Important if self modifying code)
+
+	5) aes: Single stepping in emulation mode
+
+	+ Toggle IL representation via O in Visual Mode
+
+# ESIL Linear emulation
+
+	Find all references to curr. address using linear esil emulation on all imports.
+		
+		/re$$@@ sym.imp.*
+
+# ESIL IL Representation
+
+	op 	esil
+	------------
+	mov 	=
+	mul 	*
+	div 	/
+	and 	&
+	neg	!
+	read 	[]
+	if 	?{
+	add	+
+	sub	-
+	xor 	^
+	or	|
+	cmp	==
+	write	=[]
+	
+	+ prefix is %
+	+ carry from bit x -> %cx
+	+ borrow from bit x -> %bx
+	+ zero-flag -> %z
+	+ parity of dst -> %p
+	+ sign-flag -> %s
+	+ overflow-flag -> %o
+
+	+ BREAK - Stop parsing and emulate next instruction
+	+ LOOP - restart emulation of instruction
+	+ GOTO n - jump to n
+	+ TODO - stop emulation and eprintf("TDOD %s", ins)
+
+	x86			ESIL
+	------------------------------------------------------
+	mov eax, ebx		ebx,eax,=
+	jz 0xaabbccdd		zf,?{,0xaabbccdd,eip,=,}
+	cmp ecx,edx		edx,ecx,==,%z,zf,=,%b32,cf,=,%p,pf,=,%s,sf,=
+	push ebp		4,esp,-=ebp,esp,=[4]
+
+	+ ESIL Doc
+		https://github.com/radare/radare2book/blob/master/esil.md
+	
+# r2pipe commands
+
+	+ Invoke r2pipe script via r2 cmdline
+		
+		[0x00000000]> #!pipe node script.js
+		[0x00000000]> #!pipe python script.py
+
+	+ Good collection:
+		https://radare.org/get/r2pipe-nn2015.pdf
+		https://github.com/jpenalbae/r2-scripts
+# Parsing ELF
+	
+	!!! open with r2 -nn 
+
+	+ Parse 9 program headers (elf_phdr) from curr. seek plus offset 0x40 with temporary block size 0x200 in less mode (~..)
+
+		[0x00000000]> pf 9? (elf_phdr)phdr @ $$+0x40!0x200~..
+	
+# pf Templates
+	
+	+ Generate templates for structs/enums with td command
+
+		"td enum elf_class {ELFCLASSNONE=0, ELFCLASS32=1, ELFCLASS64=2};"
+
+	https://github.com/Maijin/r2-pf-templates/
+
+	+ Cast data @ <addr> to <type> and print it		
+		
+		tp <type>  = <address>
+
+# r2scapy
+
+	r2 -i r2scapy.py dump.bin
+		[0x00000000]> scapy DNS 0x81de3c 48
+		DNS(aa=1L, qr=1L, an=DNSRR(rclass=32769, ttl=120, rrname='flashair.local.', rdata='192.168.0.1', type=1), ad=0L, nscount=0, qdcount=1, ns=None, tc=0L, rd=1L, arcount=0, ar=None, opcode=0L, ra=0L, cd=0L, z=0L, rcode=0L, id=0, ancount=1, qd=DNSQR(qclass=32769, qtype=255, qname='flashair.local.'))
+	
+	+ generate packets with scapy
+		>>> from scapy.all import *
+		>>> sr1(IP(dst="8.8.8.8")/UDP(dport=53)/DNS(rd=1,qd=DNSQR(qname="www.thepacketgeek.com")),verbose=0)
+
+# r2m2 -Miasm  Intermediate Representation Plugin
+	
+	+ Assemble and disassemble MIPS32 using rasm2
+
+		r2m2$ export R2M2_ARCH=mips32l; rasm2 -a r2m2 'addiu a0, a1, 2' |rasm2 -a r2m2 -d -
+		ADDIU      A0, A1, 0x2
+
+	+ Disassemble random MSP430 instructions in r2
+
+		r2m2$ R2M2_ARCH=msp430 r2 -a r2m2 -qc 'woR; pd 5' -
+            		0x00000000      07fa           and.w      R10, R7
+            		0x00000002      47ad           dadd.b     R13, R7
+            		0x00000004      f05e0778       add.b      @R14+, 0x7807(PC)
+            		0x00000008      f46d81ed       addc.b     @R13+, 0xED81(R4)
+            		0x0000000c      3fdc           bis.w      @R12+, R15
+	+ Assemble MIPS32 using rasm2 and display the call graph using r2
+
+		r2m2$ R2M2_ARCH=mips32b rasm2 -a r2m2 'j 0x4; nop' -B > j_nop.bin
+
+		r2m2$ R2M2_ARCH=mips32b r2 -a r2m2 -qc 'pd 2' j_nop.bin
+        		,=< 0x00000000      0c000001       JAL        0x4
+       			`-> 0x00000004      00000000       NOP
+
+# bin carving with r2
+
+	+ Open raw dump
+		
+		r2 -n dump.bin
+	
+	+ Searching for  magic
+		
+		[0x00000000]> / \x7fELF
+		Searching 4 bytes from 0x00000000 to 0x0000002d: 7f 45 4c 46
+		0x00001340 hit0_0
+		0x00001744 hit0_1
+		...
+
+	+ Dump 1M with at several hits
+
+		[0x00000000]> b 1M
+		[0x00000000]> wt @@ hit0*
+
+	+ Automate it
+		
+		$ for a in dump.* ; do
+		sz=`rabin2 -Z $a`     # get RBin.filesize
+		r2 -wnqc"r $sz" $a  # resize file
+		done
+
+	http://radare.today/posts/carving-bins/
+
+# r4ge - symbolic execution
+	+ https://github.com/gast04/r4ge
+
+	Usage: https://asciinema.org/a/155856
+
+# r2wiki -Macro for using wiki in commandline
+	
+	+ https://github.com/securisec/r2wiki
+
+	$wiki "query string"
+	

cheat/cheatsheets/rcs

@@ -0,0 +1,26 @@
+# Initial check-in of file (leaving file active in filesystem)
+ci -u <filename>
+
+# Check out with lock
+co -l <filename>
+
+# Check in and unlock (leaving file active in filesystem)
+ci -u <filename>
+
+# Display version x.y of a file
+co -px.y <filename>
+
+# Undo to version x.y (overwrites file active in filesystem with the specified revision)
+co -rx.y <filename>
+
+# Diff file active in filesystem and last revision
+rcsdiff <filename>
+
+# Diff versions x.y and x.z
+rcsdiff -rx.y -rx.z <filename>
+
+# View log of check-ins
+rlog <filename>
+
+# Break an RCS lock held by another person on a file
+rcs -u <filename>

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/rpm2cpio

@@ -0,0 +1,5 @@
+# List contents of RPM
+rpm2cpio foo.rpm | cpio -vt
+
+# Extract contents of RPM
+rpm2cpio foo.rpm | cpio -vid

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/shutdown

@@ -0,0 +1,8 @@
+# Reboot the system immediately
+shutdown -r now
+
+# Shut system down immediately
+shutdown -h now
+
+# Reboot system after 5 minutes
+shutdown -r +5

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

@@ -0,0 +1,37 @@
+# socat connect to http-server (port 80 on 'butzel.info')
+socat TCP4:butzel.info:80 -
+
+# connect to https-server (port 443 on 'butzel.info' with tls)
+socat openssl:butzel.info:443 -
+
+# tcp-listener (port 3180), output as hexdump (-x) and fork for new connetions
+socat -x tcp-listen:3180,fork -
+
+# practical examples:
+
+# complete real working http-example:  
+#  (sleep is necessary to prevent socat closing socket before data received)
+(echo -e "GET / HTTP/1.1\r\nHost: butzel.info\r\n\r" && sleep 1) \ 
+| socat tcp4:butzel.info:80 -
+
+# http to httpS 'Proxy' (for an webserver without TLS-Support)
+socat OPENSSL-LISTEN:443,reuseaddr,pf=ip4,fork,cert=server.pem,cafile=client.crt,verify=0 TCP4-CONNECT:127.0.0.1:80
+
+# port forwarding (e.g. own port 3180 to port 22(ssh) on target
+socat TCP4-LISTEN:3180,reuseaddr,fork TCP4:butzel.info:ssh
+
+# TOR-forwarding (needs tor-daemon on port 9050 running)
+socat tcp4-listen:8080,reuseaddr,fork socks4A:127.0.0.1:t0rhidd3ns3rvice.onion:80,socksport=9050
+
+# network (port 8266) to serial bridge (/dev/ttyUSB0 baudrate: 115200)
+socat TCP4-LISTEN:8266,fork,reuseaddr /dev/ttyUSB0,raw,crnl,b115200
+
+# udp to tcp
+socat -u udp-recvfrom:1234,fork tcp:localhost:4321
+
+# reverse shell:
+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/sport

@@ -0,0 +1,32 @@
+# Sync to newest SlackBuild.org tree
+sport r
+
+# Search (fuzzy) SlackBuild tree for packages foo and BaR
+sport s foo bar
+
+# Operate from alternate build tree
+SBOPATH=/path/to/tree sport s foo
+
+# View info and README of BaR (not fuzzy)
+sport c foo BaR
+
+# Build a package
+sport i --build-only foo
+
+# Build and install package foo and BaR
+sport i foo BaR
+
+# Build and install package from current directory
+sport i .
+
+# Upgrade instead of install
+INSTALLER=upgradepkg sport i foo
+
+# Build dependency list for baz
+echo "foo BaR" >> /tmp/baz.list
+
+# Install list of packages from file
+sport i $(< /tmp/baz.list)
+
+# Check if package is installed
+sport k foo

cheat/cheatsheets/sqlite3

@@ -0,0 +1,23 @@
+# create database and launch interactive shell
+sqlite3 example.db
+
+# create table
+sqlite3 example.db "CREATE TABLE Os(ID INTEGER PRIMARY KEY, Name TEXT, Year INTEGER);"
+
+# insert data
+sqlite3 example.db "INSERT INTO 'Os' VALUES(1,'Linux',1991);"
+
+# list tables
+sqlite3 example.db ".tables"
+
+# describe table
+sqlite3 example.db ".schema 'Os'"
+
+# view records in table
+sqlite3 example.db "SELECT * FROM 'Os';"
+
+# view records in table conditionally
+sqlite example.db "SELECT * FROM 'Os' WHERE Year='1991';"
+
+# view records with fuzzy matching
+sqlite3 ~/example.db "SELECT * FROM 'Os' WHERE Year like '19%';"

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/ssh-keygen

@@ -12,3 +12,9 @@ ssh-keygen -p -P old_passphrase -N '' -f /path/to/keyfile
 
 # To generate a 4096 bit RSA key with a passphase and comment containing the user and hostname
 ssh-keygen -t rsa -b 4096 -C "$USER@$HOSTNAME" -P passphrase
+
+# To print the fingerprint of a public key
+ssh-keygen -lf /path/to/keyfile
+
+# To print the Github-style (MD5) fingerprint of a public key
+ssh-keygen -E md5 -lf /path/to/keyfile

cheat/cheatsheets/su

@@ -0,0 +1,2 @@
+# Switch to another user account
+su USERNAME

cheat/cheatsheets/tar

@@ -19,6 +19,9 @@ tar -xjvf /path/to/foo.tgz
 # To create a .bz2 archive:
 tar -cjvf /path/to/foo.tgz /path/to/foo/
 
+# To extract a .tar in specified Directory:
+tar -xvf /path/to/foo.tar -C /path/to/destination/
+
 # To list the content of an .bz2 archive:
 tar -jtvf /path/to/foo.tgz
 

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/tmux

@@ -51,3 +51,6 @@ Ctrl-b %
 
 # Split windows vertically:
 Ctrl-b "
+
+# Swap windows
+Ctrl-b :swap-window -s [0-9] -t [0-9]

cheat/cheatsheets/trashy

@@ -0,0 +1,14 @@
+# Trash foo and bar
+trash foo bar
+
+# Trash "foo bar"
+trash foo\ bar
+
+# List files in trash
+trash -v --list
+
+# Restore foo from trash
+trash --restore foo
+
+# Empty trash
+trash --empty

cheat/cheatsheets/urpm

@@ -0,0 +1,14 @@
+# search (fuzzy) for package foo
+urpmq -Y foo
+
+# check if foo is installed
+rpm -q foo
+
+# install package foo
+urpmi foo
+
+# download but don't install foo
+urpmi --no-install foo
+
+# uninstall package foo
+urpme foo

cheat/cheatsheets/vagrant

@@ -30,4 +30,4 @@ vagrant suspend
 vagrant destroy
 
 # Restart vm with new provision script
-vagran reload --provision
+vagrant reload --provision

cheat/cheatsheets/vim

@@ -63,3 +63,18 @@ d{motion}       delete text that {motion} moves over
 2dw         deletes 2 words
 5yy         copies 5 lines
 42G         go to line 42
+
+# Multiple windows
+:e filename      - edit another file
+:split filename  - split window and load another file
+ctrl-w up arrow  - move cursor up a window
+ctrl-w ctrl-w    - move cursor to another window (cycle)
+ctrl-w_          - maximize current window
+ctrl-w=          - make all equal size
+10 ctrl-w+       - increase window size by 10 lines
+:vsplit file     - vertical split
+:sview file      - same as split, but readonly
+:hide            - close current window
+:only            - keep only this window open
+:ls              - show current buffers
+:b 2             - open buffer #2 in this window

cheat/cheatsheets/wc

@@ -0,0 +1,18 @@
+# Count the number of words (file or STDIN)
+wc -w /path/to/foo.txt
+cat /path/to/foo.txt | wc -w
+
+# Count the number of lines (file or STDIN)
+wc -l /path/to/foo.txt
+cat /path/to/foo.txt | wc -l
+
+# Count the number of bytes (file or STDIN)
+wc -c /path/to/foo.txt
+cat /path/to/foo.txt | wc -c
+
+# Count files and directories at a given location
+ls -l | wc -l
+
+# If you ever use `wc` in a shell script and need to compare the output with an int you can
+# clean the output (wc returns extra characters around the integer) by using xargs:
+ls -l | wc -l | xargs

cheat/cheatsheets/xargs

@@ -10,3 +10,7 @@ find -name *.pdf | xargs -I{} rm -rf '{}'
 # -n1 => One file by one file. ( -n2 => 2 files by 2 files )
 
 find -name *.pdf | xargs -I{} -n1 echo '&{}='
+
+# If find returns no result, do not run rm
+# This option is a GNU extension.
+find -name "*.pdf" | xargs --no-run-if-empty rm

cheat/cheatsheets/xmlto

@@ -0,0 +1,14 @@
+# DocBook XML to PDF
+xmlto pdf mydoc.xml
+
+# DocBook XML to HTML
+xmlto -o html-dir html mydoc.xml
+
+# DocBook XML to single HTML file
+xmlto html-nochunks mydoc.xml
+
+# modify output with XSL override
+xmlto -m ulink.xsl pdf mydoc.xml
+
+# use non-default xsl
+xmlto -x mystylesheet.xsl pdf mydoc.xml

cheat/cheatsheets/youtube-dl

@@ -16,5 +16,8 @@ youtube-dl --playlist-start 5 example.com/watch?v=id&list=listid
 # To simulate a download with youtube-dl:
 youtube-dl -s example.com/watch?v=id
 
-# For all video formats see
+# To download audio in mp3 format with best quality available
-# http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs
+youtube-dl --extract-audio --audio-format mp3 --audio-quality 0 example.com/watch?v=id
+
+# 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/z

@@ -0,0 +1,14 @@
+# To `cd` to most frecent dir matching `foo`
+z foo
+
+# To `cd` to most frecent dir matching `foo`, then `bar`
+z foo bar
+
+# To `cd` to highest ranked dir matching `foo`
+z -r foo
+
+# To `cd` to most recently accessed dir matching `foo`
+z -t foo
+
+# To list all dirs matching `foo` - By frecency
+z -l foo

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,11 @@
 # Create zip file
 zip archive.zip file1 directory/
 
+# Create zip file from directory
+zip -r archive.zip directory/
+
+# Create zip file with password
+zip -P password archive.zip file1
+
 # To list, test and extract zip archives, see unzip
 cheat unzip

cheat/cheatsheets/zsh

@@ -0,0 +1,82 @@
+# A plain old glob
+print -l *.txt
+print -l **/*.txt
+
+# Show text files that end in a number from 1 to 10
+print -l **/*<1-10>.txt
+
+# Show text files that start with the letter a
+print -l **/[a]*.txt
+
+# Show text files that start with either ab or bc
+print -l **/(ab|bc)*.txt
+
+# Show text files that don't start with a lower or uppercase c
+print -l **/[^cC]*.txt
+
+# Show only directories
+print -l **/*(/)
+
+# Show only regular files
+print -l **/*(.)
+
+# Show empty files
+print -l **/*(L0)
+
+# Show files greater than 3 KB
+print -l **/*(Lk+3)
+
+# Show files modified in the last hour
+print -l **/*(mh-1)
+
+# Sort files from most to least recently modified and show the last 3
+print -l **/*(om[1,3])
+
+# `.` show files, `Lm-2` smaller than 2MB, `mh-1` modified in last hour,
+# `om` sort by modification date, `[1,3]` only first 3 files
+print -l **/*(.Lm-2mh-1om[1,3])
+
+# Show every directory that contain directory `.git`
+print -l **/*(e:'[[ -d $REPLY/.git ]]':)
+
+# Return the file name (t stands for tail)
+print -l *.txt(:t)
+
+# Return the file name without the extension (r stands for remove_extension)
+print -l *.txt(:t:r)
+
+# Return the extension
+print -l *.txt(:e)
+
+# Return the parent folder of the file (h stands for head)
+print -l *.txt(:h)
+
+# Return the parent folder of the parent
+print -l *.txt(:h:h)
+
+# Return the parent folder of the first file
+print -l *.txt([1]:h)
+
+# Parameter expansion
+files=(*.txt)          # store a glob in a variable
+print -l $files
+print -l $files(:h)    # this is the syntax we saw before
+print -l ${files:h}
+print -l ${files(:h)}  # don't mix the two, or you'll get an error
+print -l ${files:u}    # the :u modifier makes the text uppercase
+
+# :s modifier
+variable="path/aaabcd"
+echo ${variable:s/bc/BC/}    # path/aaaBCd
+echo ${variable:s_bc_BC_}    # path/aaaBCd
+echo ${variable:s/\//./}     # path.aaabcd (escaping the slash \/)
+echo ${variable:s_/_._}      # path.aaabcd (slightly more readable)
+echo ${variable:s/a/A/}      # pAth/aaabcd (only first A is replaced)
+echo ${variable:gs/a/A/}     # pAth/AAAbcd (all A is replaced)
+
+# Split the file name at each underscore
+echo ${(s._.)file}
+
+# Join expansion flag, opposite of the split flag.
+array=(a b c d)
+echo ${(j.-.)array} # a-b-c-d

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 cheat.appdirs as appdirs
+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'),
+            appdirs.site_config_dir('cheat', 'cheat'),
+        ])
+        config_file_path_local = self._select([
+            os.environ.get('CHEAT_LOCAL_CONF_PATH'),
+            appdirs.user_config_dir('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'),
+                     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'),
+            appdirs.user_data_dir('cheat', '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,87 +1,64 @@
+from cheat.editor import Editor
+from cheat.utils import Utils
+import io
 import os
 import shutil
-import subprocess
-
-from cheat import sheets
-from cheat.utils import die, editor
-
-def copy(current_sheet_path, new_sheet_path):
-    """ Copies a sheet to a new path """
-
-    # attempt to copy the sheet to DEFAULT_CHEAT_DIR
-    try:
-        shutil.copy(current_sheet_path, new_sheet_path)
-
-    # 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 create_or_edit(sheet):
+class Sheet:
-    """ Creates or edits a cheatsheet """
 
-    # if the cheatsheet does not exist
+    def __init__(self, config, sheets):
-    if not exists(sheet):
+        self._config = config
-        create(sheet)
+        self._editor = Editor(config)
+        self._sheets = sheets
 
-    # if the cheatsheet exists but not in the default_path, copy it to the
+    def _exists(self, sheet):
-    # default path before editing
+        """ Predicate that returns true if the sheet exists """
-    elif exists(sheet) and not exists_in_default_path(sheet):
+        return (sheet in self._sheets.get() and
-        copy(path(sheet), os.path.join(sheets.default_path(), sheet))
+                os.access(self._path(sheet), os.R_OK))
-        edit(sheet)
 
-    # if it exists and is in the default path, then just open it
+    def _exists_in_default_path(self, sheet):
-    else:
+        """ Predicate that returns true if the sheet exists in default_path"""
-        edit(sheet)
+        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 _path(self, sheet):
+        """ Returns a sheet's filesystem path """
+        return self._sheets.get()[sheet]
 
-def create(sheet):
+    def edit(self, sheet):
-    """ Creates a cheatsheet """
+        """ Creates or edits a cheatsheet """
-    new_sheet_path = os.path.join(sheets.default_path(), sheet)
 
-    try:
+        # if the cheatsheet does not exist
-        subprocess.call([editor(), new_sheet_path])
+        if not self._exists(sheet):
+            new_path = os.path.join(self._config.cheat_user_dir, sheet)
+            self._editor.open(new_path)
 
-    except OSError:
+        # if the cheatsheet exists but not in the default_path, copy it to the
-        die('Could not launch ' + editor())
+        # 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 edit(sheet):
+            self._editor.open(self._path(sheet))
-    """ Opens a cheatsheet for editing """
 
-    try:
+        # if it exists and is in the default path, then just open it
-        subprocess.call([editor(), path(sheet)])
+        else:
+            self._editor.open(self._path(sheet))
 
-    except OSError:
+    def read(self, sheet):
-        die('Could not launch ' + editor())
+        """ Returns the contents of the cheatsheet as a String """
+        if not self._exists(sheet):
+            Utils.die('No cheatsheet found for ' + sheet)
 
-
+        with io.open(self._path(sheet), encoding='utf-8') as cheatfile:
-def exists(sheet):
+            return cheatfile.read()
-    """ 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()

cheat/sheets.py

@@ -1,91 +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():
+class Sheets:
-    """ Returns the default cheatsheet path """
 
-    # determine the default cheatsheet dir
+    def __init__(self, config):
-    default_sheets_dir = os.environ.get('DEFAULT_CHEAT_DIR') or os.path.join(os.path.expanduser('~'), '.cheat')
+        self._config = config
+        self._colorize = Colorize(config)
 
-    # create the DEFAULT_CHEAT_DIR if it does not exist
+        # Assembles a dictionary of cheatsheets as name => file-path
-    if not os.path.isdir(default_sheets_dir):
+        self._sheets = {}
-        try:
+        sheet_paths = [
-            # @kludge: unclear on why this is necessary
+            config.cheat_user_dir
-            os.umask(0000)
+        ]
-            os.mkdir(default_sheets_dir)
 
-        except OSError:
+        # merge the CHEAT_PATH paths into the sheet_paths
-            die('Could not create DEFAULT_CHEAT_DIR')
+        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 sheet_paths:
-    if not os.access(default_sheets_dir, os.R_OK):
+            Utils.die('The CHEAT_USER_DIR dir does not exist '
-        die('The DEFAULT_CHEAT_DIR (' + default_sheets_dir +') is not readable.')
+                      + 'or the CHEAT_PATH is not set.')
-    if not os.access(default_sheets_dir, os.W_OK):
-        die('The DEFAULT_CHEAT_DIR (' + default_sheets_dir +') is not writable.')
 
-    # return the default dir
+        # otherwise, scan the filesystem
-    return default_sheets_dir
+        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():
+        # merge the CHEATPATH paths into the sheet_paths
-    """ Assembles a dictionary of cheatsheets as name => file-path """
+        for path in self._config.cheat_path.split(os.pathsep):
-    cheats = {}
+            sheet_paths.append(path)
 
-    # otherwise, scan the filesystem
+        return sheet_paths
-    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 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():
+    def search(self, term):
-    """ Assembles a list of directories containing cheatsheets """
+        """ Searches all cheatsheets for the specified term """
-    sheet_paths = [
+        result = ''
-        default_path(),
-        cheatsheets.sheets_dir()[0],
-    ]
 
-    # merge the CHEATPATH paths into the sheet_paths
+        for cheatsheet in sorted(self.get().items()):
-    if 'CHEATPATH' in os.environ and os.environ['CHEATPATH']:
+            match = ''
-        for path in os.environ['CHEATPATH'].split(os.pathsep):
+            for line in io.open(cheatsheet[1], encoding='utf-8'):
-            if os.path.isdir(path):
+                if term in line:
-                sheet_paths.append(path)
+                    match += '  ' + self._colorize.search(term, line)
 
-    if not sheet_paths:
+            if match != '':
-        die('The DEFAULT_CHEAT_DIR dir does not exist or the CHEATPATH is not set.')
+                result += cheatsheet[0] + ":\n" + match + "\n"
 
-    return sheet_paths
+        return result
-
-
-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

cheat/utils.py

@@ -1,50 +1,26 @@
 from __future__ import print_function
-import os
 import sys
 
 
-def colorize(sheet_content):
+class Utils:
-    """ Colorizes cheatsheet content if so configured """
 
-    # only colorize if so configured
+    @staticmethod
-    if not 'CHEATCOLORS' in os.environ:
+    def die(message):
-        return sheet_content
+        """ Prints a message to stderr and then terminates """
+        Utils.warn(message)
+        exit(1)
 
-    try:
+    @staticmethod
-        from pygments import highlight
+    def warn(message):
-        from pygments.lexers import BashLexer
+        """ Prints a message to stderr """
-        from pygments.formatters import TerminalFormatter
+        print((message), file=sys.stderr)
 
-    # if pygments can't load, just return the uncolorized text
+    @staticmethod
-    except ImportError:
+    def boolify(value):
-        return sheet_content
+        """ Type-converts 'true' and 'false' to Booleans """
+        # if `value` is not a string, return it as-is
+        if not isinstance(value, str):
+            return value
 
-    return highlight(sheet_content, BashLexer(), TerminalFormatter())
+        # otherwise, convert "true" and "false" to Boolean counterparts
-
+        return value.strip().lower() == "true"
-
-def die(message):
-    """ Prints a message to stderr and then terminates """
-    warn(message)
-    exit(1)
-
-
-def editor():
-    """ Determines the user's preferred editor """
-    if 'EDITOR' not in os.environ:
-        die(
-            'In order to create/edit a cheatsheet you must set your EDITOR '
-            'environment variable to your editor\'s path.'
-        )
-
-    elif os.environ['EDITOR'] == "":
-        die(
-            'Your EDITOR environment variable is set to an empty string. It must '
-            'be set to your editor\'s path.'
-        )
-
-    else:
-        return os.environ['EDITOR']
-
-def warn(message):
-    """ Prints a message to stderr """
-    print((message), file=sys.stderr)

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 --exclude=appdirs.py