adding default_actions and dotfile src/dst paths to template these (for #125)

dotdrop/action.py

@@ -68,13 +68,16 @@ class Action(Cmd):
     def __repr__(self):
         return 'action({})'.format(self.__str__())
 
-    def execute(self):
+    def execute(self, templater=None, newvars={}):
         """execute the action in the shell"""
         ret = 1
+        action = self.action
+        if templater:
+            action = templater.generate_string(self.action, tmpvars=newvars)
         try:
-            cmd = self.action.format(*self.args)
+            cmd = action.format(*self.args)
         except IndexError:
-            err = 'bad action: \"{}\"'.format(self.action)
+            err = 'bad action: \"{}\"'.format(action)
             err += ' with \"{}\"'.format(self.args)
             self.log.warn(err)
             return False

dotdrop/config.py

@@ -40,6 +40,7 @@ class Cfg:
     key_workdir = 'workdir'
     key_cmpignore = 'cmpignore'
     key_upignore = 'upignore'
+    key_defactions = 'default_actions'
 
     # import keys
     key_import_vars = 'import_variables'
@@ -148,14 +149,22 @@ class Cfg:
         self.prodots = {}
 
         # represents all variables from external files
+        # NOT linked inside the yaml dict (self.content)
         self.ext_variables = {}
         self.ext_dynvariables = {}
 
         # cmpignore patterns
+        # NOT linked inside the yaml dict (self.content)
         self.cmpignores = []
+
         # upignore patterns
+        # NOT linked inside the yaml dict (self.content)
         self.upignores = []
 
+        # default actions
+        # NOT linked inside the yaml dict (self.content)
+        self.defactions = {}
+
         if not self._load_config(profile=profile):
             raise ValueError('config is not valid')
 
@@ -171,13 +180,16 @@ class Cfg:
             d.src = t.generate_string(d.src)
             d.dst = t.generate_string(d.dst)
             # pre actions
+            var = d.get_vars()
             if self.key_actions_pre in d.actions:
                 for action in d.actions[self.key_actions_pre]:
-                    action.action = t.generate_string(action.action)
+                    action.action = t.generate_string(action.action,
+                                                      tmpvars=var)
             # post actions
             if self.key_actions_post in d.actions:
                 for action in d.actions[self.key_actions_post]:
-                    action.action = t.generate_string(action.action)
+                    action.action = t.generate_string(action.action,
+                                                      tmpvars=var)
         return dotfiles
 
     def _load_config(self, profile=None):
@@ -263,11 +275,13 @@ class Cfg:
 
         # load global upignore
         if self.key_upignore in self.lnk_settings:
-            self.upignores = self.lnk_settings[self.key_upignore] or []
+            key = self.key_upignore
+            self.upignores = self.lnk_settings[key].copy() or []
 
         # load global cmpignore
         if self.key_cmpignore in self.lnk_settings:
-            self.cmpignores = self.lnk_settings[self.key_cmpignore] or []
+            key = self.key_cmpignore
+            self.cmpignores = self.lnk_settings[key].copy() or []
 
         # parse external actions
         try:
@@ -324,6 +338,17 @@ class Cfg:
         except KeyError:
             pass
 
+        # load default actions
+        try:
+            dactions = self.lnk_settings[self.key_defactions].copy() or []
+            self.defactions = self._parse_actions_list(dactions,
+                                                       profile=profile)
+        except KeyError:
+            self.defactions = {
+                self.key_actions_pre: [],
+                self.key_actions_post: [],
+            }
+
         # parse read transformations
         # If read transformations are None, replaces them with empty dict
         try:
@@ -385,7 +410,7 @@ class Cfg:
 
             # parse actions
             itsactions = v.get(self.key_dotfiles_actions, [])
-            actions = self._parse_actions(itsactions, profile=profile)
+            actions = self._parse_actions_list(itsactions, profile=profile)
             if self.debug:
                 self.log.dbg('action for {}'.format(k))
                 for t in [self.key_actions_pre, self.key_actions_post]:
@@ -722,7 +747,7 @@ class Cfg:
             dotfiles.extend(self.prodots[other])
         return True, dotfiles
 
-    def _parse_actions(self, entries, profile=None):
+    def _parse_actions_list(self, entries, profile=None):
         """parse actions specified for an element
         where entries are the ones defined for this dotfile"""
         res = {
@@ -1052,6 +1077,9 @@ class Cfg:
         settings[key] = self._string_to_linktype(settings[key])
         key = self.key_dotfile_link
         settings[key] = self._string_to_linktype(settings[key])
+        # patch defactions
+        key = self.key_defactions
+        settings[key] = self.defactions
         return settings
 
     def get_variables(self, profile, debug=False):

dotdrop/dotdrop.py

@@ -27,6 +27,48 @@ TRANS_SUFFIX = 'trans'
 ###########################################################
 
 
+def action_executor(o, dotfile, actions, defactions, templater, post=False):
+    """closure for action execution"""
+    def execute():
+        """
+        execute actions and return
+        True, None if ok
+        False, errstring if issue
+        """
+        s = 'pre' if not post else 'post'
+
+        # execute default actions
+        for action in defactions:
+            if o.dry:
+                LOG.dry('would execute def-{}-action: {}'.format(s,
+                                                                 action))
+                continue
+            if o.debug:
+                LOG.dbg('executing def-{}-action {}'.format(s, action))
+            newvars = dotfile.get_vars()
+            ret = action.execute(templater=templater, newvars=newvars)
+            if not ret:
+                err = 'def-{}-action \"{}\" failed'.format(s, action.key)
+                LOG.err(err)
+                return False, err
+
+        # execute actions
+        for action in actions:
+            if o.dry:
+                LOG.dry('would execute {}-action: {}'.format(s, action))
+                continue
+            if o.debug:
+                LOG.dbg('executing {}-action {}'.format(s, action))
+            newvars = dotfile.get_vars()
+            ret = action.execute(templater=templater, newvars=newvars)
+            if not ret:
+                err = '{}-action \"{}\" failed'.format(s, action.key)
+                LOG.err(err)
+                return False, err
+        return True, None
+    return execute
+
+
 def cmd_install(o):
     """install dotfiles for this profile"""
     dotfiles = o.dotfiles
@@ -57,14 +99,19 @@ def cmd_install(o):
                 and Cfg.key_actions_pre in dotfile.actions:
             for action in dotfile.actions[Cfg.key_actions_pre]:
                 preactions.append(action)
+        defactions = o.install_default_actions[Cfg.key_actions_pre]
+        pre_actions_exec = action_executor(o, dotfile, preactions,
+                                           defactions, t, post=False)
+
         if o.debug:
             LOG.dbg('installing {}'.format(dotfile))
         if hasattr(dotfile, 'link') and dotfile.link == LinkTypes.LINK:
-            r = inst.link(t, dotfile.src, dotfile.dst, actions=preactions)
+            r = inst.link(t, dotfile.src, dotfile.dst,
+                          actionexec=pre_actions_exec)
         elif hasattr(dotfile, 'link') and \
                 dotfile.link == LinkTypes.LINK_CHILDREN:
             r = inst.link_children(t, dotfile.src, dotfile.dst,
-                                   actions=preactions)
+                                   actionexec=pre_actions_exec)
         else:
             src = dotfile.src
             tmp = None
@@ -73,7 +120,8 @@ def cmd_install(o):
                 if not tmp:
                     continue
                 src = tmp
-            r, err = inst.install(t, src, dotfile.dst, actions=preactions,
+            r, err = inst.install(t, src, dotfile.dst,
+                                  actionexec=pre_actions_exec,
                                   noempty=dotfile.noempty)
             if tmp:
                 tmp = os.path.join(o.dotpath, tmp)
@@ -82,15 +130,11 @@ def cmd_install(o):
         if r:
             if not o.install_temporary and \
                     Cfg.key_actions_post in dotfile.actions:
-                actions = dotfile.actions[Cfg.key_actions_post]
-                # execute post action
-                for action in actions:
-                    if o.dry:
-                        LOG.dry('would execute action: {}'.format(action))
-                    else:
-                        if o.debug:
-                            LOG.dbg('executing post action {}'.format(action))
-                        action.execute()
+                defactions = o.install_default_actions[Cfg.key_actions_post]
+                postactions = dotfile.actions[Cfg.key_actions_post]
+                post_actions_exec = action_executor(o, dotfile, postactions,
+                                                    defactions, t, post=True)
+                post_actions_exec()
             installed += 1
         elif not r and err:
             LOG.err('installing \"{}\" failed: {}'.format(dotfile.key, err))

dotdrop/dotfile.py

@@ -40,6 +40,13 @@ class Dotfile:
         self.noempty = noempty
         self.upignore = upignore
 
+    def get_vars(self):
+        """return this dotfile templating vars"""
+        _vars = {}
+        _vars['_dotfile_src'] = self.src
+        _vars['_dotfile_dst'] = self.dst
+        return _vars
+
     def __str__(self):
         msg = 'key:\"{}\", src:\"{}\", dst:\"{}\", link:\"{}\"'
         return msg.format(self.key, self.src, self.dst, self.link.name.lower())

dotdrop/installer.py

@@ -49,13 +49,19 @@ class Installer:
         self.action_executed = False
         self.log = Logger()
 
-    def install(self, templater, src, dst, actions=[], noempty=False):
+    def install(self, templater, src, dst, actionexec=None, noempty=False):
         """
         install src to dst using a template
+        @templater: the templater object
+        @src: dotfile source path in dotpath
+        @dst: dotfile destination path in the FS
+        @actionexec: action executor callback
+        @noempty: render empty template flag
+
         return
-        - True, None: success
-        - False, error_msg: error
-        - False, None, ignored
+        - True, None        : success
+        - False, error_msg  : error
+        - False, None       : ignored
         """
         if self.debug:
             self.log.dbg('install {} to {}'.format(src, dst))
@@ -76,18 +82,24 @@ class Installer:
             self.log.dbg('install {} to {}'.format(src, dst))
             self.log.dbg('is \"{}\" a directory: {}'.format(src, isdir))
         if isdir:
-            return self._handle_dir(templater, src, dst, actions=actions,
+            return self._handle_dir(templater, src, dst,
+                                    actionexec=actionexec,
                                     noempty=noempty)
         return self._handle_file(templater, src, dst,
-                                 actions=actions, noempty=noempty)
+                                 actionexec=actionexec, noempty=noempty)
 
-    def link(self, templater, src, dst, actions=[]):
+    def link(self, templater, src, dst, actionexec=None):
         """
         set src as the link target of dst
+        @templater: the templater
+        @src: dotfile source path in dotpath
+        @dst: dotfile destination path in the FS
+        @actionexec: action executor callback
+
         return
-        - True, None: success
-        - False, error_msg: error
-        - False, None, ignored
+        - True, None        : success
+        - False, error_msg  : error
+        - False, None       : ignored
         """
         if self.debug:
             self.log.dbg('link {} to {}'.format(src, dst))
@@ -100,22 +112,27 @@ class Installer:
         dst = os.path.normpath(os.path.expanduser(dst))
         if self.totemp:
             # ignore actions
-            return self.install(templater, src, dst, actions=[])
+            return self.install(templater, src, dst, actionexec=None)
 
         if Templategen.is_template(src):
             if self.debug:
                 self.log.dbg('dotfile is a template')
                 self.log.dbg('install to {} and symlink'.format(self.workdir))
             tmp = self._pivot_path(dst, self.workdir, striphome=True)
-            i, err = self.install(templater, src, tmp, actions=actions)
+            i, err = self.install(templater, src, tmp, actionexec=actionexec)
             if not i and not os.path.exists(tmp):
                 return i, err
             src = tmp
-        return self._link(src, dst, actions=actions)
+        return self._link(src, dst, actionexec=actionexec)
 
-    def link_children(self, templater, src, dst, actions=[]):
+    def link_children(self, templater, src, dst, actionexec=None):
         """
         link all dotfiles in a given directory
+        @templater: the templater
+        @src: dotfile source path in dotpath
+        @dst: dotfile destination path in the FS
+        @actionexec: action executor callback
+
         return
         - True, None: success
         - False, error_msg: error
@@ -175,21 +192,21 @@ class Installer:
                     self.log.dbg('install to {} and symlink'
                                  .format(self.workdir))
                 tmp = self._pivot_path(dst, self.workdir, striphome=True)
-                r, e = self.install(templater, src, tmp, actions=actions)
+                r, e = self.install(templater, src, tmp, actionexec=actionexec)
                 if not r and e and not os.path.exists(tmp):
                     continue
                 src = tmp
 
-            result = self._link(src, dst, actions)
+            result = self._link(src, dst, actionexec=actionexec)
 
-            # Empty actions if dotfile installed
-            # This prevents from running actions multiple times
+            # void actionexec if dotfile installed
+            # to prevent from running actions multiple times
             if len(result):
-                actions = []
+                actionexec = None
 
         return True, None
 
-    def _link(self, src, dst, actions=[]):
+    def _link(self, src, dst, actionexec=None):
         """set src as a link target of dst"""
         overwrite = not self.safe
         if os.path.lexists(dst):
@@ -216,7 +233,7 @@ class Installer:
         if not self._create_dirs(base):
             err = 'creating directory for {}'.format(dst)
             return False, err
-        r, e = self._exec_pre_actions(actions)
+        r, e = self._exec_pre_actions(actionexec)
         if not r:
             return False, e
         # re-check in case action created the file
@@ -234,7 +251,8 @@ class Installer:
         self.log.sub('linked {} to {}'.format(dst, src))
         return True, None
 
-    def _handle_file(self, templater, src, dst, actions=[], noempty=False):
+    def _handle_file(self, templater, src, dst,
+                     actionexec=None, noempty=False):
         """install src to dst when is a file"""
         if self.debug:
             self.log.dbg('generate template for {}'.format(src))
@@ -254,7 +272,8 @@ class Installer:
             err = 'source dotfile does not exist: {}'.format(src)
             return False, err
         st = os.stat(src)
-        ret, err = self._write(src, dst, content, st.st_mode, actions=actions)
+        ret, err = self._write(src, dst, content,
+                               st.st_mode, actionexec=actionexec)
         if ret < 0:
             return False, err
         if ret > 0:
@@ -268,7 +287,7 @@ class Installer:
         err = 'installing {} to {}'.format(src, dst)
         return False, err
 
-    def _handle_dir(self, templater, src, dst, actions=[], noempty=False):
+    def _handle_dir(self, templater, src, dst, actionexec=None, noempty=False):
         """install src to dst when is a directory"""
         if self.debug:
             self.log.dbg('install dir {}'.format(src))
@@ -285,7 +304,7 @@ class Installer:
                 # is file
                 res, err = self._handle_file(templater, f,
                                              os.path.join(dst, entry),
-                                             actions=actions,
+                                             actionexec=actionexec,
                                              noempty=noempty)
                 if not res and err:
                     # error occured
@@ -298,7 +317,7 @@ class Installer:
                 # is directory
                 res, err = self._handle_dir(templater, f,
                                             os.path.join(dst, entry),
-                                            actions=actions,
+                                            actionexec=actionexec,
                                             noempty=noempty)
                 if not res and err:
                     # error occured
@@ -316,7 +335,7 @@ class Installer:
             cur = f.read()
         return cur == content
 
-    def _write(self, src, dst, content, rights, actions=[]):
+    def _write(self, src, dst, content, rights, actionexec=None):
         """write content to file
         return  0, None:  for success,
                 1, None:  when already exists
@@ -353,7 +372,7 @@ class Installer:
         if not self._create_dirs(base):
             err = 'creating directory for {}'.format(dst)
             return -1, err
-        r, e = self._exec_pre_actions(actions)
+        r, e = self._exec_pre_actions(actionexec)
         if not r:
             return -1, e
         if self.debug:
@@ -422,21 +441,15 @@ class Installer:
             self.log.dbg('pivot \"{}\" to \"{}\"'.format(path, new))
         return new
 
-    def _exec_pre_actions(self, actions):
-        """execute pre-actions if any"""
+    def _exec_pre_actions(self, actionexec):
+        """execute action executor"""
         if self.action_executed:
             return True, None
-        for action in actions:
-            if self.dry:
-                self.log.dry('would execute action: {}'.format(action))
-            else:
-                if self.debug:
-                    self.log.dbg('executing pre action {}'.format(action))
-                if not action.execute():
-                    err = 'pre-action \"{}\" failed'.format(action.key)
-                    return False, err
+        if not actionexec:
+            return True, None
+        ret, err = actionexec()
         self.action_executed = True
-        return True, None
+        return ret, err
 
     def _install_to_temp(self, templater, src, dst, tmpdir):
         """install a dotfile to a tempdir"""

dotdrop/options.py

@@ -182,7 +182,7 @@ class Options(AttrMonitor):
     def _read_config(self, profile=None):
         """read the config file"""
         self.conf = Cfg(self.confpath, profile=profile, debug=self.debug)
-        # transform the configs in attribute
+        # transform the config settings to self attribute
         for k, v in self.conf.get_settings().items():
             if self.debug:
                 self.log.dbg('setting: {}={}'.format(k, v))
@@ -223,6 +223,7 @@ class Options(AttrMonitor):
         self.install_diff = not self.args['--nodiff']
         self.install_showdiff = self.showdiff or self.args['--showdiff']
         self.install_backup_suffix = BACKUP_SUFFIX
+        self.install_default_actions = self.default_actions
         # "compare" specifics
         self.compare_dopts = self.args['--dopts']
         self.compare_focus = self.args['--file']

dotdrop/templategen.py

@@ -51,17 +51,37 @@ class Templategen:
         self.env.globals['exists'] = jhelpers.exists
         self.env.globals['exists_in_path'] = jhelpers.exists_in_path
 
-    def generate(self, src):
+    def generate(self, src, tmpvars={}):
         """render template from path"""
         if not os.path.exists(src):
             return ''
-        return self._handle_file(src)
+        saved = self._patch_globals(tmpvars)
+        ret = self._handle_file(src)
+        self._restore_globals(saved)
+        return ret
 
-    def generate_string(self, string):
+    def generate_string(self, string, tmpvars={}):
         """render template from string"""
         if not string:
             return ''
-        return self.env.from_string(string).render()
+        saved = self._patch_globals(tmpvars)
+        if self.debug:
+            self.log.dbg('new vars: {}'.format(tmpvars))
+        ret = self.env.from_string(string).render()
+        self._restore_globals(saved)
+        return ret
+
+    def _patch_globals(self, newvars={}):
+        """add vars to the globals, make sure to call _restore_globals"""
+        saved_globals = self.env.globals.copy()
+        if not newvars:
+            return saved_globals
+        self.env.globals.update(newvars)
+        return saved_globals
+
+    def _restore_globals(self, saved_globals):
+        """restore globals from _patch_globals"""
+        self.env.globals = saved_globals.copy()
 
     def update_variables(self, variables):
         """update variables"""