Rotz 👃

Fully cross platform dotfile manager and dev environment bootstrapper written in Rust.

Rust Dotfilemanager Rust Dotfile manager Rust Dotfile s Rust Dot s R ust Dots R ots Rot s Rotz

Rotz is an evolution of Dotted.

Status

This project is still in development.

Linking dotfiles on windows already works but is not very well tested.

Expect more features in the next release which should be ready in a few weeks.

Roadmap

Documentation [in development]

Overview

Rotz has three main functionalities:

1. Linking dotfiles from a common repository to your system
2. Installing the applications you need to start working on an new/empty machine [in development]
3. Full Cross platform functionality See Configuration

Installation

You can install rotz using cargo.

cargo install rotz

Other File Formats

Rotz uses yaml configuration files per default. You can also use toml or json files instead.

To use another format install Rotz using one of the following comands:

• cargo install rotz --no-default-features --features toml
  
  

• cargo install rotz --no-default-features --features json
  
  

Getting Started

If you already have a dotfiles repo you can clone it with the rotz clone command.

To bootstrap your dev environment use rotz install. [in development]

To link your dotfiles use rotz link.

---

Usage

Run rotz --help to see all commands Rotz has.

Configuration

Rotz uses a git repo containing thedotfiles and yaml files for configuration.

Note: To use another file format see Other File Formats.

This git repo should be located at ~/.dotfiles. Different paths can be specified using the --dotfiles cli flag or in the Rotz config file.

Note: The location of the config file can be overridden using the --config cli flag. To get the default location of the config run rotz --help

Each managed application has a subfolder containing its dotfiles and a dot.yaml file.

Example:

└── vscode
    ├── dot.yaml
    ├── keybindings.json
    └── settings.json

The file dot.yaml contains information about how to install and update the application and where to link the dotfiles.

config.yaml

The following settings are configurable in the config file like so:

dotfiles: <path to dotfiles>
link_type: <"symbolic"|"hard">
repo: <git repo url>

Those settings can be overridden in the cli when applicable (see rotz --help and rotz <command> --help to get more information).

dot.yaml

The dot.yaml file consists of four optional keys:

key	requirement	function
links	optional	Defines where to link which dotfile
installs	optional	Defines the install command and install dependencies.
updates	optional	Defines the update command and update dependencies.
depends	optional	Defines dependencies this application needs to work.

links

The links section specifies where the dotfiles should be linked.

It consists of multiple key: value pairs where the key is the filename of the dotfile and the value is the link path.

Example:

vscode/dot.yaml

...
links:
  keybindings.json: ~\AppData\Roaming\Code\User\keybindings.json
  settings.json: ~\AppData\Roaming\Code\User\settings.json

installs

The installs section contains the install command and optional install dependencies.

It can either be a string containing the install command or have two sub keys.

key	requirement	function
cmd	required	Contains the install command.
depends	optional	Contains an array of dependencies.

Examples:

nodejs/dot.yaml

...
installs:
  cmd: scoop install nodejs
  depends: [scoop]

scoop/dot.yaml

...
installs: iex (new-object net.webclient).downloadstring('https://get.scoop.sh')

updates

The updates section contains the update command and optional update dependencies.

It works exactly like the installs key described above.

Example:

nodejs/dot.yaml

...
updates:
  cmd: scoop update nodejs
  depends: [scoop]

depends

The depends section contains an array of dependencies needed for the application to work correctly.

These dependencies will also be installed/updated when the application is installed/updated.

Example:

zsh/dot.yaml

...
depends: [starship]

Defaults

The repo can also contain a default file dots.yaml in the root folder of the repo.

This file contains defaults which are automatically used for empty keys in the dot.yaml files.

You can use template strings ({{ name }}) to substitute the name of the application (the name of the folder the dot.yaml file is located in).

Example:

dots.yaml

installs:
  cmd: scoop install {{ name }}
  depends:
    - scoop
    - extras
updates:
  cmd: scoop update {{ name }}
  depends:
    - scoop

OS Specific Configuration

You can specify different behaviors per OS in all configuration files.

Rotz can differentiate between Windows, Linux and MacOS.

To specify OS Specific behavior you need to add top level keys named linux, windows, darwin (for MacOS) and general (applied to all OSs).

Examples:

dots.yaml

windows:
  installs:
    cmd: scoop install {{ name }}
    depends:
      - scoop
      - extras
  updates:
    cmd: scoop update {{ name }}
    depends:
      - scoop
darwin:
  installs:
    cmd: brew install {{ name }}
    depends:
      - brew
  updates:
    cmd: brew upgrade {{ name }}
    depends:
      - brew

neovim/dot.yaml

windows:
  links:
    ginit.vim: ~\AppData\Local\nvim\ginit.vim
    init.vim: ~\AppData\Local\nvim\init.vim
    
global:
  links:
    ginit.vim: ~/.config/nvim/init.vim
    init.vim: ~/.config/nvim/ginit.vim

You can also combine multiple OSs per key separating them with a |.

Example:

dots.yaml

windows:
  installs:
    cmd: scoop install {{ name }}
    depends:
      - scoop
      - extras
darwin|linux:
  installs:
    cmd: brew install {{ name }}
    depends:
      - brew

Example Repository

You can see all of this functionality used in my own dotfiles repository.

Contribute

Feel free to create pull requests and issues for bugs, features or questions.