implement transformation parameters (#177)

dotdrop/action.py

@@ -15,6 +15,7 @@ from dotdrop.dictparser import DictParser
 
 class Cmd(DictParser):
     eq_ignore = ('log',)
+    descr = 'command'
 
     def __init__(self, key, action):
         """constructor
@@ -24,6 +25,43 @@ class Cmd(DictParser):
         self.key = key
         self.action = action
 
+    def execute(self, templater=None, debug=False):
+        """execute the command in the shell"""
+        ret = 1
+        action = self.action
+        if templater:
+            action = templater.generate_string(self.action)
+            if debug:
+                self.log.dbg('{} \"{}\" -> \"{}\"'.format(self.descr,
+                                                          self.action,
+                                                          action))
+        cmd = action
+        args = []
+        if self.args:
+            args = self.args
+            if templater:
+                args = [templater.generate_string(a) for a in args]
+        try:
+            cmd = action.format(*args)
+        except IndexError:
+            err = 'bad {}: \"{}\"'.format(self.descr, action)
+            err += ' with \"{}\"'.format(args)
+            self.log.warn(err)
+            return False
+        except KeyError:
+            err = 'bad {}: \"{}\"'.format(self.descr, action)
+            err += ' with \"{}\"'.format(args)
+            self.log.warn(err)
+            return False
+        self.log.sub('executing \"{}\"'.format(cmd))
+        try:
+            ret = subprocess.call(cmd, shell=True)
+        except KeyboardInterrupt:
+            self.log.warn('{} interrupted'.format(self.descr))
+        if ret != 0:
+            self.log.warn('{} returned code {}'.format(self.descr, ret))
+        return ret == 0
+
     @classmethod
     def _adjust_yaml_keys(cls, value):
         return {'action': value}
@@ -55,6 +93,7 @@ class Action(Cmd):
 
     pre = 'pre'
     post = 'post'
+    descr = 'action'
 
     def __init__(self, key, kind, action):
         """constructor
@@ -66,6 +105,12 @@ class Action(Cmd):
         self.kind = kind
         self.args = []
 
+    def copy(self, args):
+        """return a copy of this object with arguments"""
+        action = Action(self.key, self.kind, self.action)
+        action.args = args
+        return action
+
     @classmethod
     def parse(cls, key, value):
         """parse key value into object"""
@@ -73,12 +118,6 @@ class Action(Cmd):
         v['kind'], v['action'] = value
         return cls(key=key, **v)
 
-    def copy(self, args):
-        """return a copy of this object with arguments"""
-        action = Action(self.key, self.kind, self.action)
-        action.args = args
-        return action
-
     def __str__(self):
         out = '{}: \"{}\" ({})'
         return out.format(self.key, self.action, self.kind)
@@ -86,40 +125,23 @@ class Action(Cmd):
     def __repr__(self):
         return 'action({})'.format(self.__str__())
 
-    def execute(self, templater=None, debug=False):
-        """execute the action in the shell"""
-        ret = 1
-        action = self.action
-        if templater:
-            action = templater.generate_string(self.action)
-            if debug:
-                self.log.dbg('action \"{}\" -> \"{}\"'.format(self.action,
-                                                              action))
-        cmd = action
-        args = [templater.generate_string(a) for a in self.args]
-        try:
-            cmd = action.format(*args)
-        except IndexError:
-            err = 'bad action: \"{}\"'.format(action)
-            err += ' with \"{}\"'.format(args)
-            self.log.warn(err)
-            return False
-        except KeyError:
-            err = 'bad action: \"{}\"'.format(action)
-            err += ' with \"{}\"'.format(args)
-            self.log.warn(err)
-            return False
-        self.log.sub('executing \"{}\"'.format(cmd))
-        try:
-            ret = subprocess.call(cmd, shell=True)
-        except KeyboardInterrupt:
-            self.log.warn('action interrupted')
-        if ret != 0:
-            self.log.warn('action returned code {}'.format(ret))
-        return ret == 0
-
 
 class Transform(Cmd):
+    descr = 'transformation'
+
+    def __init__(self, key, action):
+        """constructor
+        @key: action key
+        @trans: action string
+        """
+        super(Transform, self).__init__(key, action)
+        self.args = []
+
+    def copy(self, args):
+        """return a copy of this object with arguments"""
+        trans = Transform(self.key, self.action)
+        trans.args = args
+        return trans
 
     def transform(self, arg0, arg1, templater=None, debug=False):
         """
@@ -127,23 +149,13 @@ class Transform(Cmd):
         where {0} is the file to transform
         and {1} is the result file
         """
-        ret = 1
-        action = self.action
-        if templater:
-            action = templater.generate_string(action)
-            if debug:
-                self.log.dbg('trans \"{}\" -> \"{}\"'.format(self.action,
-                                                             action))
-        cmd = action.format(arg0, arg1)
         if os.path.exists(arg1):
             msg = 'transformation \"{}\": destination exists: {}'
-            self.log.warn(msg.format(cmd, arg1))
+            self.log.warn(msg.format(self.key, arg1))
             return False
-        self.log.sub('transforming with \"{}\"'.format(cmd))
-        try:
-            ret = subprocess.call(cmd, shell=True)
-        except KeyboardInterrupt:
-            self.log.warn('transformation interrupted')
-        if ret != 0:
-            self.log.warn('transformation returned code {}'.format(ret))
-        return ret == 0
+
+        if not self.args:
+            self.args = []
+        self.args.insert(0, arg1)
+        self.args.insert(0, arg0)
+        return self.execute(templater=templater, debug=debug)