Documentation

Directory Tags for Lazy Programmers

Package Version Python Versions Issues Open MIT License

Features

dtags is a lightweight command line tool which lets you:

  • Tag directories and jump between them quickly by tag names
  • Run commands inside tagged directories in parallel
  • Easily manage git repositories, vagrant machines etc.

Installation

Check requirements:

  • Python 2.7, 3.4, 3.5, 3.6 or 3.7
  • Supported operating systems: Linux, OS X, Ubuntu on Windows
  • Recent version of pip
  • Recent version of Bash, Zsh or Fish with tab-completion enabled

Install the package:

# You may need to sudo depending on your environment setup
~$ pip install dtags

Add the following line at the end of your shell runtime configuration and reload the shell:

# For zsh, place in ~/.zshrc:
command -v dtags-activate > /dev/null 2>&1 && eval "`dtags-activate zsh`"

# For bash, place in ~/.bashrc (or ~/.bash_profile for OS X):
command -v dtags-activate > /dev/null 2>&1 && eval "`dtags-activate bash`"

# For fish, place in ~/.config/fish/config.fish:
command -v dtags-activate > /dev/null 2>&1; and dtags-activate fish | source

Once installed, you will have the following at your disposal:

  • Utility commands t, u, d, e, p
  • Main command dtags

All commands come with tab-completion.

Usage

Tag directories with t:

~$ t ~/app dev work     # tag ~/app with 'dev' and 'work'
~$ t ~/app              # tag ~/app with its basename, 'app'

Un-tag directories with u:

~$ u ~/app dev          # remove tag 'dev' from ~/app
~$ u ~/app              # remove all tags from ~/app

Change directories with d (designed to fully replace cd!):

~$ d                    # go to the user's home directory
~$ d -                  # go to the last directory
~$ d app                # go to the directory tagged 'app'
~$ d ~/app              # go to directory ~/app

Execute commands in one or more directories with e:

~$ e app git status     # execute 'git status' in all directories tagged 'app'
~$ e ~/vm vagrant halt  # regular directory paths are accepted as well
~$ e app,~/vm,~/foo ls  # multiple tags and/or paths can be specified using commas
~$ e -i app myalias     # use -i (interactive shell) to use functions, aliases etc.

Execute commands in parallel with p (same interface as e):

~$ p app git pull       # execute 'git pull' in all directories tagged 'app' in parallel
~$ p -i app myalias     # again, use -i for interactive shell (read below for caveats)

Display, search and manage tags with dtags:

~$ dtags                # display the directories-to-tags mapping
~$ dtags list ~ ~/vm    # list the tags and directories associated with ~ and ~/vm
~$ dtags list foo bar   # list the tags and directories associated with 'foo' or 'bar'
~$ dtags reverse        # list the tags-to-directories (reverse) mapping
~$ dtags edit           # edit tags and directories via editor
~$ dtags clean          # remove invalid or stale tags and directories
~$ dtags commands       # display all available dtags commands (e.g. t, u, d, e, p)

If a tag points to a single directory, shell variables are automatically created:

~$ t ~/some/dir foo     # shell variable '$foo' is automatically created
~$ ls $foo/sub/dir      # $foo can now be used to denote the tagged directory ~/some/dir
~$ rm $foo/file.sh      # $foo can now be used to denote the tagged directory ~/some/dir

You can always use the --help option to find out more about each command!

More Examples

Streamline your Git workflows:

# Tag your git directories
~$ t ~/project/mobile app
~$ t ~/project/backend app
~$ t ~/project/frontend app
~$ t ~/project/config app

# Save yourself some time!
~$ e app git status
~$ p app git pull
~$ e app git checkout v1.7.2

Control multiple vagrant machines at the same time:

# Tag all the things
~$ t ~/machines/web vm
~$ t ~/machines/redis vm
~$ t ~/machines/mysql vm
~$ t ~/machines/compute vm

# Profit!
~$ p vm vagrant status
~$ p vm vagrant up

Technical Notes

  • dtags is currently not supported on Windows (only Ubuntu on Windows)
  • The directory-to-tags mapping is stored in ~/.dtags/mapping
  • Tags are also stored on their own in ~/.dtags/tags for tab-completion
  • p cannot execute interactive commands that wait on input
  • p spawns child processes and redirects all output to temp files and then to stdout
  • p does not retain font colors due to shell limitations
  • p sends sigterm to its child processes when killed
  • e (or p) uses environment variable $SHELL to guess which shell is in use
  • e (or p) redirects stderr to stdout and always returns an exit status of 0
  • Using -i (interactive shell) has caveats:
    • The shell runtime configuration must be "sourced" for every command execution
    • The performance is affected by the shell startup time (beware oh-my-zsh users)
    • Any errors thrown during the "sourcing" will be displayed in the output
  • dtags edit uses environment variable $EDITOR
  • d prefers tags over subdirectories when there are name conflicts
    • To go to the subdirectory, put / after the directory name
  • d expects ~/.dtags/mapping to be correctly formatted:
    • Refrain from editing ~/.dtags/mapping directly.
    • Instead, use dtags edit which does the validation and formatting for you
  • Tab-completion expects ~/.dtags/tags to be correctly formatted:
    • Refrain from touching this file
    • This file is auto-generated whenever a dtags command is run.
  • A shell variable is created only if its name does not conflict with environment variables
  • When shell variables are created, any disallowed characters in the name are replaced with underscores