********
Examples
********

This is an example of a more complex configuration that tries to show of
most features of uberdot and what you could achieve with inheritance.
It’s a variation of a setup I’m using for over a half year now. The tags
that I defined have the following semantics:

- **arch:** An Arch linux based distribution is installed
- **antergos:** An Antergos based distribution is installed
- **debian:** An Debian based distribution is installed

- **master:** The device is powerful and should be fullfeatured
- **minimal:** The device is a low-end-device and most features should be
  disabled

- **small:** This device has a small monitor
- **laptop:** This device is a laptop

- **private:** This my own device with private data and access to my local
  network
- **office:** A device used for work

- **asus:** An asus laptop of mine
- **thinkpad:** A thinkpad laptop of mine

First I created some profiles that represent my current setup. Any
device that I want to use this setup on inherits from it. These profiles
define the programs that should be configured and link some platform
specific configs.

.. code:: python

   # This profile is the base for all devices that use my current setup
   class Main(Profile):
       def generate(self):
           tags("arch", "master")
           if info.distribution() == "Antergos":
               tags("antergos")
           subprof("Git", "I3", "Bash", "Zsh", "Vim")

           link("pacman.conf", directory="/etc")


   # This profile contains configs that I only want on my private devices. It inherits from the Main profile.
   class Private(Main):
       def generate(self):
           tags("private")
           super().generate()

           # File synchronisation
           link("unison_data.prf", name=".unison/data.prf")

           cd("/etc")
           # Custom hosts file and udev rules
           link("hosts", "mkinitcpio.conf")
           links("\d{2}-\w+\.rules", directory="udev/rules.d")


Then there are profiles for each of my devices. ``Pi`` and ``Server``
don’t inherit from ``Main`` so they will define subprofiles as well.
The other profiles are used to link configs that configure hardware.
These profiles (except for ``Laptop``) are the only profiles that I
install as a root profile.

.. code:: python

   # This profile contains configs that I use on all of my laptops
   class Laptop(Profile):
       def generate(self):
           # Automate multimonitor if hdmi is plugged in
           link("hdmi_plugin.sh")
           # Start ssh server if connect to my own private network
           cd("/etc/NetworkManager")
           link("sshOnConnect.sh", directory="dispatcher.d")

           # Wifi profiles
           cd("system-connections")
           opt(permission=600)
           links("wifi-(.+).gpg", replace=r"\1", encrypted=True)


   # This is an asus laptop of mine
   class Asus(Private):
       def generate(self):
           tags("asus", "small", "laptop")
           super().generate()
           subprof("Laptop")


   # This is an thinkpad laptop of mine
   class Thinkpad(Private):
       def generate(self):
           tags("thinkpad", "small", "laptop")
           super().generate()
           subprof("Laptop")
           # Fixes sound
           link("alsa-base.conf", directory="/etc/modprobe.d/")


   # This is my device at the office
   class Office(Main):
       def generate(self):
           tags("office")
           super().generate()


   # A raspberry pi I use as mini server
   class Pi(Profile):
       def generate(self):
           tags("pi", "debian", "minimal")
           subprof("Git", "Bash", "Vim", "Radicale")


   # A more powerful webserver
   class Server(Profile):
       def generate(self):
           tags("debian", "master")
           subprof("Git", "Bash", "Vim")


At last there are the profiles for the individual programs that I called
as subprofiles above. Most of the links are defined here.

.. code:: python

   class Bash(Profile):
       def generate(self):
           opt(prefix=".")
           link("bashrc", "inputrc")
           link("bashrc", "inputrc", directory="/root")
           link("bash_profile", name=".bash_profile")
           opt(prefix=".bash_")
           link("sensitiverc", "basicrc", "systemrc")
           link("sensitiverc", "basicrc", "systemrc", directory="/root")
           link("customrc", optional=True)


   class Zsh(Profile):
       def generate(self):
           link("zshrc", prefix=".")
           link("zsh_profile", name=".zprofile")
           opt(prefix=".zsh_")
           link("sensitiverc", "basicrc", "systemrc")
           link("customrc", optional=True)


   class Git(Profile):
       def generate(self):
           link("gitconfig", prefix=".")
           link("gitconfig_system", name="/etc/gitconfig")


   class I3(Profile):
       def generate(self):
           subprof("Rofi", "Polybar")

           cd(".config/i3")
           link(merge("i3config", ["i3-keybindings", "i3-settings", "i3-autostart"]), name="config")
           link("lock.sh", "lock.png")

           link("dunstrc", directory="../dunst")

           cd("$HOME")
           link("wallpaper.sh")
           link("compton.conf", prefix=".")


   class Rofi(Profile):
       def generate(self):
           # Fing all configs with the naming schema "rofi-*.rasi" and link all of them
           # but strip away "rofi-" of each filename
           cd(".config/rofi")
           links("rofi-(.+\.rasi)", replace=r"\1")


   class Polybar(Profile):
       def generate(self):
           cd(".config/polybar")
           # Strip away "polybar" from each filename
           link("polybarconfig", "polybarlaunch.sh", replace_pattern="polybar(.+)", replace=r"\1")
           link("pkg.sh")


   class Vim(Profile):
       def generate(self):
           # Link all vim configs
           links("g?vimrc", prefix=".")
           cd(".vim")
           links("\w+\.vim")

           # Documentation
           link("mydoc.txt", directory="doc")

           # Link all Snippets
           links(".+\.snippets", directory="UltiSnips")

           # Link all Spellfiles
           links(".+\..+\.add(\.spl)?", directory="spell")

           # Configs loaded after plugins
           link("vim-gitgutter.vim", directory="after/plugin")
           link("vim-illuminate.vim", directory="after/plugin")


   class Radicale(Profile):
       def generate(self):
           cd(".config")
           link("radicale.conf", name="radicale/config")
           link("radicale_log.conf", name="radicale/log_config")
           link("radicale.service", directory="systemd/user")


You could argue that some programs doesn’t need an extra profile like
``Polybar`` and ``Rofi`` because those would have fit in ``I3`` as well.
It’s fine to do so, however by encapsulating their configs in their own
profile you increase the re-usability of a configuration.