.gitignore

@@ -1 +1,2 @@
 __pycache__
+test

TODO.md

@@ -1,49 +1,49 @@
 How this must work.
 
-1. On first launch themere reads ~/.config/themer/config and aquires list of apps it should manage
-2. Themer backs up whole config directories to ~/.config/themer  so further manipulations are safe
-Default name is themer/original, but user can provide a different name from command line.
+1. On first launch userctx reads ~/.config/userctx/config and aquires list of apps it should manage
+2. userctx backs up whole config directories to ~/.config/userctx  so further manipulations are safe
+Default name is userctx/original, but user can provide a different name from command line.
 
 example:
-themer backup [--name <name>] [--apps TODO]
+userctx backup [--name <name>] [--apps TODO]
 default name is "original"
 default apps list is read from config. command line overrides config completely, no merging.
 
 Backup algorithm:
 - If directory ~/.config/sway does not exist or is empty will do nothing
-- if directory exists AND not empty then create directory ~/.config/themer/original/sway
-- copy contents of all files AND direcotries in it to ~/.config/themer/original/sway
-- if any file failed to copy - rollback and remove ~/.config/themer/original/sway
+- if directory exists AND not empty then create directory ~/.config/userctx/original/sway
+- copy contents of all files AND direcotries in it to ~/.config/userctx/original/sway
+- if any file failed to copy - rollback and remove ~/.config/userctx/original/sway
 - remove original files (and directories) from ~/.config/sway
 - create symlinks to copied files in ~/.config/sway  
 
 3. Swithing algorithm:
 User requests theme change with:
-themer apply <theme>
+userctx apply <theme>
 
-Themer tries to apply configs as follows:
+userctx tries to apply configs as follows:
 - looks up a list of apps it should manage; if list is empty - return non-zero
-- looks up requested theme name in ~/.config/themer/<name>; if not found - return non-zero
-- looks up config dir ~/.config/themer/<theme>/<app>; if none found - return non-zero
-- for each <filename> in ~/.config/themer/<theme>/<app> themer does
+- looks up requested theme name in ~/.config/userctx/<name>; if not found - return non-zero
+- looks up config dir ~/.config/userctx/<theme>/<app>; if none found - return non-zero
+- for each <filename> in ~/.config/userctx/<theme>/<app> userctx does
 ```
 mkdir -p ~/.config/<app> # creates app config directory if it does not exist (else no-op)
 rm -f ~/.config/<app>/<filename> # tries to delete the config if it exists (else no-op)
-ln -s ~/.config/themer/<theme>/<app>/<filename> ~/.config/<app>/<filename> # symlinks the file from requested theme user dir
+ln -s ~/.config/userctx/<theme>/<app>/<filename> ~/.config/<app>/<filename> # symlinks the file from requested theme user dir
 ```
-- after creating symlinks themer tries to let the app know that config changed
+- after creating symlinks userctx tries to let the app know that config changed
 - if app has hot-reload (niri, alacritty, hyprland) - do nothing
 - if app re-reads configs on start (fuzzel, wofi) - do nothing
 - if app obeys USR1/URS2 - issue the signal
 - if app is a systemd service - exec systemctl --user restart <app>
 
-This way a single copy of config files are kept in ~/.config/themer.
-This way user can choose which files to manage themselves and which themer
+This way a single copy of config files are kept in ~/.config/userctx.
+This way user can choose which files to manage themselves and which userctx
 should manage.
 
 4. cli interface 
-themer list - returns newline-separated list (suitable for dmenu)
-themer apply $(themer list | fuzzel -d) - a usable way to select theme with dmenu-like apps
+userctx list - returns newline-separated list (suitable for dmenu)
+userctx apply $(userctx list | fuzzel -d) - a usable way to select theme with dmenu-like apps
 
 TODO:
 

config.toml

@@ -5,85 +5,87 @@
 # tasks
 dry_run = true
 
-# "tasks" array must not be empty
-# it tells userctx what to do (which apps
-# should be actually managed)
-tasks = [
-  "sway",
-  "gtk",
-  "helix",
-  "foot",
-  "wofi",
-  "mako",
+# "apps" array tells userctx what to do (which apps
+# should be actually managed). If it is empty or not
+# set, then userctx will do nothing.
+apps = [
+  #"sway",
+  #"gtk",
+  #"helix",
+  #"foot",
+  #"wofi",
+  #"mako",
+  "myapp",
 ]
 
 # target directory where managed configs
 # are located 
 # defaults to $XDG_CONFIG_HOME if specifically set
 # or ~/.config if $XGD_CONFIG_HOME is not set
-managed_directory = "~/.config"
+target_path = "~/.config"
 
 # directory where contexts are stored
 # default is "~/.config/userctx"
-contexts_path = "~/.config/userctx" 
+source_path = "~/code/userctx/test"
 
-# This section of config is intended to document
-# what userctx can do. Assume we are 
-# building a config for app "example"
-[task.example]
-# the default path to apply your context to is
+[apps]
+example2.scripts = ["s1", "s2"]
+myapp.symlink."*" = "*"
+myapp.exec = """echo "hello world""""
+myapp.actions = {}
+myapp.script = []
+
+# section that demonstrates all the available
+# features of userctx
+[apps.example]
+# Path to appliaction configs is read from
+# general.source_path. The default source path is 
+# ~/.config/userctx/<context_name>/example for this
+# app. 
+# Individual path for app can be provided via
+# "source_path" for particular app. Then userctx will try to lookup
+# app settings in /source_path/<context_name>
+# Default is general.source_path/<context_name>/<app_name>.
+# For this example it will expand to
+# ~/.config/userctx/<context_name/example.
+# TODO: do we really need this? 
+source_path = "~/tmp/contexts"
+
+# The default path to apply your context to is
 # ~/.config/example (for app name "example")
-# "target_path" overrides this.
-# If set then $CONTEXT_DST env will hold this value and
+# if not overridden with general.target_path.
+# Setting "target_path" overrides this.
+# $CONTEXT_DST env will hold  the actual destination path.
 # symlinks will be created relative to this specified 
 # path.
 target_path = "~/.config/example/configs"
 
-# "actions" array defines which steps should be 
-# executed to apply content from 
-# context directory to users home 
-# directory. If actions array is empty the default
-# behaviour is to just symlink everything from
-# $CONTEXT_SRC to $CONTEXT_DST
-actions = [
-  "symlinks", # do the symlinking as specified in "symlinks array below"
-  "code", # execute shell script from object "code" below
-  "commands", # run commands from "commands array below"
-  "scripts", # run scripts from "scripts" array below
-]
-
-# "symlinks" array of mappings (inline tables of TOML) defines
+# "symlink" map defines
 # which files will be symlinked to users home
-# directory. If "symlinks" key is present in
-# "actions" above but this "symlinks" array is omitted
-# then userctx treats all files in the context directory as 
-# files that must be symlinked to users home.
-symlinks = [
-  # names of files in these mapping are relative to 
-  # context directory and target directory
-  # by default source is ~/.config/userctx/<context_name>/example for
-  # task (app) named "example" 
-  # default target directory is ~/.config/example for 
-  # task (app) named "example" 
-  #
-  # this will link file from context dir to destination dir
-  # $CONTEXT_SRC/context_file.conf -> $CONTEXT_DST/symlink_to_context_file.conf
-  {"context_file.conf" = "symlink_to_context_file.conf"},
+# directory.
+# Names of files in thes mapping are relative to 
+# context directory and target directory
+# by default source is ~/.config/userctx/<context_name>/example 
+# and target directory is ~/.config/example
+# for app named "example" 
+#
+# this will link file from context dir to destination dir
+# $CONTEXT_SRC/context_file.conf -> $CONTEXT_DST/symlink_to_context_file.conf
+symlink."context_file.conf" = "symlink_to_context_file.conf"
 
-  # this will link file to subdirectory inside destination dir
-  # directory must be created beforehand 
-  # $CONTEXT_SRC/other_file.conf -> $CONTEXT_DST/subdir/other_file.conf
-  {"other_file.conf" = "subdir/other_file.conf" },
-  # also possible option
-  {"subdir/yet_another_file.conf" = "yet_another_file.conf" },
-]
+# this will link file to subdirectory inside destination dir
+# Note that destination subdir must be created beforehand.
+# $CONTEXT_SRC/other_file.conf -> $CONTEXT_DST/subdir/other_file.conf
+symlink."other_file.conf" = "subdir/other_file.conf"
+symlink."subdir/yet_another_file.conf" = "yet_another_file.conf" 
 
-# "code" object let's you write
-# a custom script that will apply contents of
-# your context. Note that string is a multiline string
-# strating and ending with three double-qoutes. 
-# This string will be passed as is to $SHELL -c <string>
-code = """
+
+# "exec" let's you write a reload command or
+# even a bigger custom script that will apply contents of
+# your context. Note the triple double-qoutes for multiline
+# strings (see TOML spec). 
+# This string will be passed as is to $SHELL for execution.
+exec = """
   # this is a normal shell script which will
   # be executed by user's $SHELL or 'bash' binary
   # if users $SHELL is empty
@@ -97,13 +99,6 @@ code = """
   echo "$CONTEXT_NAME"
 """
 
-# Another way in run something when applying context
-# is to define "commands" array.
-commands = [
-  ['first_command', '--arg1', 'value', '--arg2', 'value2'],
-  ['second_command', '--arg1', 'value', '--arg2', 'value2'],
-]
-
 # scripts array will try to find
 # named files in $CONTEXT_SRC and 
 # execute them with $SHELL <script>
@@ -111,26 +106,23 @@ commands = [
 # and action "scripts" is present in 
 # "actions" array above then all files
 # in $CONTEXT_SRC will be treated as scripts
-# (note the "task.gtk section below")
+# (note the "apps.gtk section below")
 scripts = [
   "script1.sh",
   "script2.sh",
 ]
 
-# reload command (if set) will be executed after
-# all actions
-reload = ['echo', 'this is my reload command']
+reload = "pkill -USR1 example"
 
 #########################
 # settings for some
 # commonly used apps
 #########################
 
-[task.niri]
+[apps.niri]
 target_path = "~/.config/niri/configs"
 actions = [
-  "symlinks",
-  "code",
+  "symlink",
 ]
 
 # The snippet below is needed for niri 25.8 which did not
@@ -141,50 +133,49 @@ actions = [
 # symlink configs found in the context dir to 
 # ~/.config/niri/configs, which then get concatenated.
 # For niri since 25.11 you can just put your includes
-# into the context dir and omit [task.niri] altogether.
-code = """
+# into the context dir and omit [apps.niri] altogether.
+exec = """
   cat ~/.config/niri/configs/* > ~/.config/niri/config.kdl
 """
 
-[task.helix]
+[apps.helix]
 actions = [
-  "symlinks",
-  "code",
+  "exec",
+  "symlink",
 ]
 # context must contain file named "helix.toml" which describes a theme.
-symlinks = [
   # $CONTEXT_SRC/helix.toml -> $CONTEXT_DST/themes/current_theme.toml
-  {"helix.toml" = "themes/current_theme.toml"}
-]
-code = """
+symlink."helix.toml" = "themes/current_theme.toml"
+
+exec = """
   sed -i -E 's/^theme = (.+)/theme = "current_theme"/' ~/.config/helix/config.toml
 """
-reload = ['pkill', '-USR1', 'hx']
+reload = "pkill -USR1 hx"
 
-[task.gtk]
+[apps.gtk]
 # To setup the look of GTK you may put a simple shell script
 # into ~/.userctx/<context_name>/gtk/theme.sh with contents similar to: 
 # gsettings set org.gnome.desktop.interface color-scheme 'default'
 # gsettings set org.gnome.desktop.interface gtk-theme 'Yaru'
 # gsettings set org.gnome.desktop.interface icon-theme 'Yaru'
-actions = ["scripts"]
+actions = ["script"]
 
-[task.mako]
-reload = ["makoctl", "reload"]
+[apps.mako]
+reload = "makoctl reload"
 
-[task.sway]
-reload = ["swaymsg", "reload"]
+[apps.sway]
+reload = "swaymsg reload"
 
-[task.kitty]
-reload = ['pkill', '-USR1', 'kitty']
+[apps.kitty]
+reload = 'pkill -USR1 kitty'
 
-[task.waybar]
-reload = ['pkill', '-USR2', 'waybar']
+[apps.waybar]
+reload = 'pkill -USR2 waybar'
 
-[task.swaybg]
+[apps.swaybg]
 # This config is for swaybg setup as s systemd service.
 # Unit runs "swaybg -m fill -i "%h/.config/swaybg/wallpaper".
 # ~/.config/userctx/<context>/swaybg/ contains single file 
 # called "wallpaper" which gets symlinked to ~/.config/swaybg/wallpaper
 target_path = '~/.config/swaybg'
-reload = ['systemctl', '--user', 'restart', 'swaybg.service']
+reload = 'systemctl --user restart swaybg.service'

config_reimagined.toml

@@ -1,189 +0,0 @@
-[general]
-# if dry run is set to true
-# userctx will only validate config 
-# and tell you what it will do to execute
-# tasks
-dry_run = true
-
-# "apps" array tells userctx what to do (which apps
-# should be actually managed). If it is empty or not
-# set, then userctx will do nothing.
-apps = [
-  "sway",
-  "gtk",
-  "helix",
-  "foot",
-  "wofi",
-  "mako",
-]
-
-# target directory where managed configs
-# are located 
-# defaults to $XDG_CONFIG_HOME if specifically set
-# or ~/.config if $XGD_CONFIG_HOME is not set
-target_path = "~/.config"
-
-# directory where contexts are stored
-# default is "~/.config/userctx"
-source_path = "~/.config/userctx" 
-
-[apps]
-helix.symlink."*" = "themes/theme.toml"
-helix.exec = "pkill -USR1 hx"
-
-example2.scripts = ["s1", "s2"]
-
-[apps.example]
-symlink."this.file" = "that.file"
-symlink."*" = "theme.conf" # TODO: handle any file to particular name
-exec = 'echo "this simulates reload command"'
-
-[apps.niri]
-exec = "this simulates code for niri restart"
-
-[apps.niri.symlink]
-"another.file" = "another.link"
-
-# section that demonstrates all the available
-# features of userctx
-[apps.example]
-# Path to appliaction configs is read from
-# general.soucre_path. The default source path is 
-# ~/.config/userctx/<context_name>/example for this
-# app. 
-# Individual path for app can be provided via
-# "source_path" for particular app. Then userctx will try to lookup
-# app settings in /source_path/<context_name>
-# Default is general.source_path/<context_name>/<app_name>.
-# For this example it will expand to
-# ~/.config/userctx/<context_name/example.
-# TODO: do we really need this? 
-source_path = "~/tmp/contexts"
-
-# The default path to apply your context to is
-# ~/.config/example (for app name "example")
-# if not overridden with general.target_path.
-# Setting "target_path" overrides this.
-# $CONTEXT_DST env will hold  the actual destination path.
-# symlinks will be created relative to this specified 
-# path.
-target_path = "~/.config/example/configs"
-
-# "symlink" map defines
-# which files will be symlinked to users home
-# directory.
-# Names of files in thes mapping are relative to 
-# context directory and target directory
-# by default source is ~/.config/userctx/<context_name>/example 
-# and target directory is ~/.config/example
-# for app named "example" 
-#
-# this will link file from context dir to destination dir
-# $CONTEXT_SRC/context_file.conf -> $CONTEXT_DST/symlink_to_context_file.conf
-symlink."context_file.conf" = "symlink_to_context_file.conf"
-
-# this will link file to subdirectory inside destination dir
-# Note that destination subdir must be created beforehand.
-# $CONTEXT_SRC/other_file.conf -> $CONTEXT_DST/subdir/other_file.conf
-symlink."other_file.conf" = "subdir/other_file.conf"
-symlink."subdir/yet_another_file.conf" = "yet_another_file.conf" 
-
-
-# "exec" let's you write a reload command or
-# even a bigger custom script that will apply contents of
-# your context. Note the triple double-qoutes for multiline
-# strings (see TOML spec). 
-# This string will be passed as is to $SHELL for execution.
-exec = """
-  # this is a normal shell script which will
-  # be executed by user's $SHELL or 'bash' binary
-  # if users $SHELL is empty
-
-  # users envs are available
-  echo "$HOME" 
-
-  # additional envs are available 
-  echo "$CONTEXT_SRC"
-  echo "$CONTEXT_DST"
-  echo "$CONTEXT_NAME"
-"""
-
-# scripts array will try to find
-# named files in $CONTEXT_SRC and 
-# execute them with $SHELL <script>
-# IMPORTANT: if array is empty
-# and action "scripts" is present in 
-# "actions" array above then all files
-# in $CONTEXT_SRC will be treated as scripts
-# (note the "apps.gtk section below")
-scripts = [
-  "script1.sh",
-  "script2.sh",
-]
-
-#########################
-settings for some
-commonly used apps
-#########################
-
-[apps.niri]
-target_path = "~/.config/niri/configs"
-actions = [
-  "symlinks",
-  "code",
-]
-
-# The snippet below is needed for niri 25.8 which did not
-# support imports/includes in the config. I'm splitting
-# config into several parts and them concatenating them 
-# after applying changes to theme. The other parts are left intact.
-# Also note the custom target path above. It instructs userctx to
-# symlink configs found in the context dir to 
-# ~/.config/niri/configs, which then get concatenated.
-# For niri since 25.11 you can just put your includes
-# into the context dir and omit [apps.niri] altogether.
-exec = """
-  cat ~/.config/niri/configs/* > ~/.config/niri/config.kdl
-"""
-
-[apps.helix]
-actions = [
-  "symlinks",
-  "code",
-]
-# context must contain file named "helix.toml" which describes a theme.
-  # $CONTEXT_SRC/helix.toml -> $CONTEXT_DST/themes/current_theme.toml
-symlink."helix.toml" = "themes/current_theme.toml"
-
-exec = """
-  sed -i -E 's/^theme = (.+)/theme = "current_theme"/' ~/.config/helix/config.toml
-  pkill -USR1 hx
-"""
-
-[apps.gtk]
-# To setup the look of GTK you may put a simple shell script
-# into ~/.userctx/<context_name>/gtk/theme.sh with contents similar to: 
-# gsettings set org.gnome.desktop.interface color-scheme 'default'
-# gsettings set org.gnome.desktop.interface gtk-theme 'Yaru'
-# gsettings set org.gnome.desktop.interface icon-theme 'Yaru'
-actions = ["scripts"]
-
-[apps.mako]
-exec = "makoctl reload"
-
-[apps.sway]
-exec = "swaymsg reload"
-
-[apps.kitty]
-exec = 'pkill -USR1 kitty'
-
-[apps.waybar]
-exec = 'pkill -USR2 waybar'
-
-[apps.swaybg]
-# This config is for swaybg setup as s systemd service.
-# Unit runs "swaybg -m fill -i "%h/.config/swaybg/wallpaper".
-# ~/.config/userctx/<context>/swaybg/ contains single file 
-# called "wallpaper" which gets symlinked to ~/.config/swaybg/wallpaper
-target_path = '~/.config/swaybg'
-reload = ['systemctl', '--user', 'restart', 'swaybg.service']

userctx.py

@@ -8,21 +8,19 @@ COMMAND_CTX_NAME = 'context_name'
 COMMANDS_ALL = [COMMAND_LIST, COMMAND_LOAD, COMMAND_SAVE]
 
 SECTION_GENERAL = 'general'
-KEY_CONTEXTS_PATH = 'contexts_path'
-KEY_TASKS = 'tasks'
+KEY_APPS = 'apps'
 KEY_DRY_RUN = 'dry_run'
-KEY_MANAGED_DIR = 'managed_directory'
 
-SECTION_TASK = 'task'
+SECTION_APPS = 'apps'
 KEY_SRC_PATH = 'source_path'
 KEY_DST_PATH = 'target_path'
 KEY_RELOAD = 'reload'
 KEY_ACTIONS = 'actions'
-KEY_SYMLINK = 'symlinks'
-KEY_COMMAND = 'commands'
-KEY_SCRIPT = 'scripts'
-KEY_CODE = 'code'
-ACTIONS_ALL = [KEY_SYMLINK, KEY_COMMAND, KEY_SCRIPT, KEY_CODE]
+KEY_SYMLINK = 'symlink'
+KEY_SCRIPT = 'script'
+KEY_EXEC = 'exec'
+ACTIONS_ALL = [KEY_SYMLINK, KEY_SCRIPT, KEY_EXEC, KEY_RELOAD]
+APPS_VALID_KEYS = [KEY_ACTIONS, KEY_SYMLINK, KEY_SCRIPT, KEY_EXEC, KEY_RELOAD, KEY_SRC_PATH, KEY_DST_PATH]
 
 ENV_CONTEXT_NAME = 'CONTEXT_NAME'
 ENV_CONTEXT_SRC = 'CONTEXT_SRC'
@@ -48,71 +46,93 @@ class OS(object):
     def exec_snippet(self, code: str) -> None:
         return self.exec_command([self.shell, "-c", code])
         
+    def scan_dir(self, path: str) -> list[str]:
+        out = []
+        def scan(dir: str, prefix: str):
+            entries = list(os.scandir(dir)) # extract values from iterator
+            out.extend([os.path.join(prefix, e.name) for e in entries if e.is_file()])
+            for d in [e.name for e in entries if e.is_dir()]:
+                scan(os.path.join(dir, d), os.path.join(prefix, d))
+        scan(path, '')
+        return out
+
 
 class Task(object):
     def __init__(self, name: str, src: str, dst: str, conf: dict, dry_run=True):
         self.name = name
         self.src = conf.get(KEY_SRC_PATH) or src # default is ~/.config/userctx/<context>/<task>
         self.dst = conf.get(KEY_DST_PATH) or dst # default is ~/.config/<task>
-        self.actions = conf.get(KEY_ACTIONS) or [KEY_SYMLINK] # default is to just symlink all
         self.symlinks = conf.get(KEY_SYMLINK)
-        self.commands = conf.get(KEY_COMMAND)
         self.scripts = conf.get(KEY_SCRIPT)
-        self.code = conf.get(KEY_CODE)
-        self.reload_command = conf.get(KEY_RELOAD)
+        self.code = conf.get(KEY_EXEC)
+        self.reload = conf.get(KEY_RELOAD)
+        self.actions = conf.get(KEY_ACTIONS)
+        if self.actions is None: # not set, actions = [] is a no-op conf for app
+            self.actions = [KEY_SYMLINK]
+            if self.scripts is not None: # may be an empty array
+                self.actions.append(KEY_SCRIPT)
+            if self.code is not None:
+                self.actions.append(KEY_EXEC)
+            if self.reload is not None:
+                self.actions.append(KEY_RELOAD)
         self.shell = OS(env={ENV_CONTEXT_NAME: self.name, ENV_CONTEXT_SRC: self.src, ENV_CONTEXT_DST: self.dst})
         self.dry_run = dry_run
         
     def execute(self) -> None:
+        if self.dry_run:
+            print("Configured actions:", self.actions)
         for a in self.actions:
             if a == KEY_SYMLINK:
                 self._symlink()
-            elif a == KEY_COMMAND:
-                self._run_commands()
             elif a == KEY_SCRIPT:
                 self._run_scripts()
-            elif a == KEY_CODE:
-                self._run_code()
-        if self.reload_command and not self.dry_run:
-            self.shell.exec_command(self.reload_command)
+            elif a == KEY_EXEC:
+                self._run_code(self.code)
+            elif a == KEY_RELOAD:
+                self._run_code(self.reload)
 
     def _symlink(self) -> None:
-        if not self.symlinks: # will symlink everything we have then
-            self.symlinks = [{entry.name: entry.name} for entry in os.scandir(self.src)]
-        for l in self.symlinks:
-            for k, v in l.items():
+        entries = self.shell.scan_dir(self.src)
+        if not entries:
+            return
+        if self.symlinks is None: # will symlink everything we have then
+            self.symlinks = {'*': '*'}
+        not_included = [e for e in entries if e not in self.symlinks]
+
+        if '*' in self.symlinks:
+            target = self.symlinks['*']
+            if target == '*': # symlink."*" = "*" in config
+                self.symlinks.update(dict(zip(not_included, not_included)))
+            else: # symlink."*" = "some/path/target.file"
+                self.symlinks[not_included[0]] = target
+            del self.symlinks['*']
+
+        for k, v in self.symlinks.items():
             src, dst = os.path.join(self.src, k), os.path.join(self.dst, v)
             if self.dry_run:
-                    print("will remove:", dst, "will symlink:", src, "to", dst)
+                print("will remove:", dst)
+                print("will symlink:", src, "to", dst)
                 continue
             if os.path.lexists(dst): os.remove(dst)
             os.symlink(src, dst)
 
     def _run_scripts(self) -> None:
         if not self.scripts: # nothing provided explicitly
-            self.scripts = [entry.name for entry in os.scandir(self.src) if entry.is_file()]
+            self.scripts = [e for e in self.shell.scan_dir(self.src) if e.endswith('.sh')]
         if self.dry_run:
             print(f'will execute scripts from {self.src}:', self.scripts)
             return
         for s in self.scripts:
             self.shell.exec_script(os.path.join(self.src, s))
 
-    def _run_code(self) -> None:
+    def _run_code(self, snippet: str) -> None:
         if self.dry_run:
-            print("will execute code:", self.code)
+            print("will execute script:", snippet)
             return
-        self.shell.exec_snippet(self.code)
-
-    def _run_commands(self) -> None:
-        if self.dry_run:
-            print("will execute:", self.commands)
-            return
-        for cmd in self.commands:
-            self.shell.exec_command(cmd)
-
+        self.shell.exec_snippet(snippet)
 
 class ContextManagerConfig(object):
-    def __init__(self, conf_file_path: str):
+    def __init__(self, conf_file_path: str, dry_run: bool):
         try:
             with open(conf_file_path, 'rb') as f: self.config = tomllib.load(f)
         except Exception as e:
@@ -127,73 +147,69 @@ class ContextManagerConfig(object):
         def user_path(s: str) -> str:
             return os.path.expanduser(s)
 
-        if SECTION_GENERAL not in self.config:
-            raise ValueError(f'section "{SECTION_GENERAL}" not found in the config')
+        if SECTION_GENERAL not in self.config or not isinstance(self.config[SECTION_GENERAL], dict):
+            raise ValueError(f'section "{SECTION_GENERAL}" must be present in the config and must be a valid mapping (table)')
 
-        # Will extnsively check what's inside config.toml without additinal imports.
+        # Will extensively check what's inside config.toml without additinal imports.
         # Also, fuck dynamic typing!
-        self.tasks = self.config[SECTION_GENERAL].get(KEY_TASKS)
+        self.tasks = self.config[SECTION_GENERAL].get(KEY_APPS)
         if not self.tasks or not is_arr_of_str(self.tasks):
-            raise ValueError(f'invalid config: key "{KEY_TASKS}" in section "{SECTION_GENERAL}" must be a non-empty array of strings')
-
-        if SECTION_TASK not in self.config: # valid case with all defaults
-            self.config[SECTION_TASK] = dict()
+            raise ValueError(f'invalid config: key "{KEY_APPS}" in section "{SECTION_GENERAL}" must be a non-empty array of strings')
 
         errors, err_count = list(), 0 # fuck it again
-        self.dry_run = self.config[SECTION_GENERAL].get(KEY_DRY_RUN) or False
+        self.dry_run = (self.config[SECTION_GENERAL].get(KEY_DRY_RUN) or False) or dry_run
         if not isinstance(self.dry_run, bool):
             err_count += 1
             errors.append(f'{err_count}. key "{KEY_DRY_RUN}" in section "{SECTION_GENERAL} of the config must be bool"')
         
-        self.home = user_path(self.config[SECTION_GENERAL].get(KEY_CONTEXTS_PATH) or os.path.join(XDG_CONFIG_HOME, 'userctx'))
+        self.home = user_path(self.config[SECTION_GENERAL].get(KEY_SRC_PATH) or os.path.join(XDG_CONFIG_HOME, 'userctx'))
         if not os.path.isabs(self.home):
-            err_count +=1
-            errors.append(f'{err_count}. path "{self.home}" in key "{KEY_CONTEXTS_PATH}" of section "{SECTION_GENERAL}" must be absolute or relative to home: "~/{self.home}"')
+            err_count += 1
+            errors.append(f'{err_count}. path "{self.home}" in key "{KEY_SRC_PATH}" of section "{SECTION_GENERAL}" must be absolute or relative to home: "~/{self.home}"')
 
-        self.managed_path = user_path(self.config[SECTION_GENERAL].get(KEY_MANAGED_DIR) or XDG_CONFIG_HOME)
+        self.managed_path = user_path(self.config[SECTION_GENERAL].get(KEY_DST_PATH) or XDG_CONFIG_HOME)
         if not os.path.isabs(self.managed_path):
-            err_count +=1
-            errors.append(f'{err_count}. path "{self.managed_path}" in key "{KEY_MANAGED_DIR}" of section "{SECTION_GENERAL}" must be absolute or relative to home: "~/{self.managed_path}"')
+            err_count += 1
+            errors.append(f'{err_count}. path "{self.managed_path}" in key "{KEY_DST_PATH}" of section "{SECTION_GENERAL}" must be absolute or relative to home: "~/{self.managed_path}"')
         
-        tasks = self.config.get(SECTION_TASK)
+        if SECTION_APPS not in self.config: # valid case with all defaults
+            self.config[SECTION_APPS] = dict()
+
+        tasks = self.config.get(SECTION_APPS)
         for name, t in tasks.items():
-            errstr = f'for task "{name}"' 
+            errstr = f'for app "{name}"' 
             for k in list(t.keys()): # we might change t
                 v = t[k]
-                if k in [KEY_SRC_PATH, KEY_DST_PATH, KEY_CODE] and not isinstance(v, str):
-                    err_count +=1
+                if k not in APPS_VALID_KEYS:
+                    err_count += 1
+                    errors.append(f'{err_count}. {errstr} unknown key "{k}"')
+                    continue
+                if k == KEY_EXEC and not isinstance(v, str):
+                    err_count += 1
                     errors.append(f'{err_count}. {errstr} key "{k}" must be a string') 
-                    continue
-                elif k in [KEY_COMMAND, KEY_SCRIPT, KEY_RELOAD, KEY_ACTIONS, KEY_SYMLINK] and not isinstance(v, list):
-                    err_count +=1
-                    errors.append(f'{err_count}. {errstr} key "{k}" must be an array')
-                    continue
-                if k == KEY_COMMAND and not all(is_arr_of_str(elem) for elem in v):
-                    err_count +=1
-                    errors.append(f'{err_count}. {errstr} all elements of "{KEY_COMMAND}" must be arrays of strings')
-                if k == KEY_SCRIPT and not is_arr_of_str(v):
-                    err_count +=1
-                    errors.append(f'{err_count}. {errstr} "{KEY_SCRIPT}" must be array of strings')
-                if k == KEY_SYMLINK and not all(is_dict_of_str(elem) for elem in v):
-                    err_count +=1
-                    errors.append(f'{err_count}. {errstr} all elements of "{KEY_SYMLINK}" array must be mappings (inline tables) of strings')
-                if k == KEY_ACTIONS and not is_arr_of_str(v):
-                    err_count +=1
-                    errors.append(f'{err_count}. {errstr} "{KEY_ACTIONS}" must be array if strings')
-                if k == KEY_ACTIONS and not all(a in ACTIONS_ALL for a in v):
-                    err_count +=1
-                    errors.append(f'{err_count}. {errstr} found invalid actions: {[a for a in v if a not in ACTIONS_ALL]} in key "{KEY_ACTIONS}", valid actions are: {ACTIONS_ALL}')
-                if k == KEY_RELOAD and not is_arr_of_str(v):
-                    err_count +=1
-                    errors.append(f'{err_count}. {errstr} "{KEY_RELOAD}" must be array of strings')
-                if k in [KEY_SRC_PATH, KEY_DST_PATH]:
+                elif k == KEY_SYMLINK and not is_dict_of_str(v):
+                    err_count += 1
+                    errors.append(f'{err_count}. {errstr} key "{k}" must be a table (mapping)')
+                elif k in [KEY_SCRIPT, KEY_ACTIONS] and not is_arr_of_str(v):
+                    err_count += 1
+                    errors.append(f'{err_count}. {errstr} key "{k}" must be array of strings')
+                elif k == KEY_ACTIONS and not all(a in ACTIONS_ALL for a in v):
+                    err_count += 1
+                    errors.append(f'{err_count}. {errstr} invalid actions found: {[a for a in v if a not in ACTIONS_ALL]} in key "{k}", valid actions are: {ACTIONS_ALL}')
+                elif k == KEY_RELOAD and not isinstance(v, str):
+                    err_count += 1
+                    errors.append(f'{err_count}. {errstr} "{KEY_RELOAD}" must ba a string')
+                elif k in [KEY_SRC_PATH, KEY_DST_PATH] and not isinstance(v, str):
+                    err_count += 1
+                    errors.append(f'{err_count}. {errstr}  key "{k}" must contain a string')  
+                elif k in [KEY_SRC_PATH, KEY_DST_PATH]: 
                     p = user_path(v)
                     if not os.path.isabs(p):
-                        err_count +=1
+                        err_count += 1
                         errors.append(f'{err_count}. {errstr} path "{v}" in key "{k}" must be either absolute or relative to home: "~/{v}"')
                     t[k] = p # substituting path (e.g. "~/somedir" -> "/home/user/somedir")
         if errors:
-            print(f'{err_count} errors found in the config ({conf_file_path}):')
+            print(f'{err_count} errors found in the config "{conf_file_path}":')
             print('\n'.join(errors))
             raise ValueError('invalid config')
 
@@ -206,9 +222,9 @@ class ContextManagerConfig(object):
             raise ValueError(f'context directory "{context_name}" not found in "{self.home}"')
         out = list()
         for name in self.tasks:
-            task_path = os.path.join(ctx_path, name) 
-            target_path = os.path.join(self.managed_path, name)
-            t = Task(name, task_path, target_path, self.config[SECTION_TASK].get(name) or dict(), dry_run=self.dry_run) 
+            src_path = os.path.join(ctx_path, name) 
+            dst_path = os.path.join(self.managed_path, name)
+            t = Task(name, src_path, dst_path, self.config[SECTION_APPS].get(name) or dict(), dry_run=self.dry_run) 
             out.append(t)
         return out
 
@@ -217,10 +233,10 @@ class ContextManager(object):
     def __init__(self, config: ContextManagerConfig):
         self.config = config
 
-    def print_contexts_list(self) -> str:
+    def print_contexts_list(self) -> None:
         print('\n'.join(self.config.get_contexts_list()))
 
-    def apply_context(self, context_name: str) -> None:
+    def load_context(self, context_name: str) -> None:
         print(f'loading and applying context: "{context_name}"')
         try:
             tasks = self.config.get_tasks_for_context(context_name)
@@ -250,6 +266,8 @@ class Runner(object):
         p = argparse.ArgumentParser(prog=APP_NAME, description=APP_DESC)
         p.add_argument('-c', '--config', help='path to config file, default: %(default)s',
                        default=os.path.join(XDG_CONFIG_HOME, 'userctx', 'config.toml'))
+        p.add_argument('-n', '--nop', action='store_true', default=False, 
+                       help='do nothing, just print out what userctx will do')
         subp = p.add_subparsers(help='command to execute', dest='command')
         loadp = subp.add_parser(COMMAND_LOAD, help='load context (provide name of context)')
         loadp.add_argument(COMMAND_CTX_NAME, help='name of context to load')
@@ -262,7 +280,7 @@ class Runner(object):
             print("error parsing command-line arguments:", e)
             return 1
         try:
-            config = ContextManagerConfig(args.config)
+            config = ContextManagerConfig(args.config, args.nop)
         except Exception as e:
             print("error loading config:", e)
             return 2
@@ -271,7 +289,7 @@ class Runner(object):
             if args.command == COMMAND_LIST:
                 ctxmgr.print_contexts_list()
             elif args.command == COMMAND_LOAD:
-                ctxmgr.apply_context(args.__dict__[COMMAND_CTX_NAME]) # guaranteed to be present by argparse
+                ctxmgr.load_context(args.__dict__[COMMAND_CTX_NAME]) # guaranteed to be present by argparse
             elif args.command == COMMAND_SAVE:
                 raise Exception('"save" not implemented')
         except Exception as e: