Record() will inform about the way it interprets the code.

niprov/commandline.py

@@ -5,13 +5,18 @@
 class Commandline(object):
 
     def fileFound(self, fname, provenance):
-        template = '{0[path]}'
+        template = '[provenance] {0[path]}'
         print(template.format(provenance))
 
     def missingDependencyForImage(self, lib, fpath):
-        template = 'Missing python package "{0}" to read file: {1}'        
+        template = '[provenance] Missing python package "{0}" to read file: {1}'        
         print(template.format(lib, fpath))
 
     def fileError(self, fpath):
-        print('Error opening file: {0}'.format(fpath))
+        print('[provenance] Error opening file: {0}'.format(fpath))
+
+    def interpretedRecording(self, new, transform, parents):
+        template = ('[provenance] Recorded the command [{1}] to create [{0}] '+
+            'based on [{2}]')
+        print(template.format(new, transform, ', '.join(parents)))
 

niprov/recording.py

@@ -2,9 +2,11 @@
 # -*- coding: UTF-8 -*-
 from niprov.externals import Externals
 from niprov.logging import log
+from niprov.commandline import Commandline
 
 
-def record(command, new=None, parents=None, transient=False, externals=Externals()):
+def record(command, new=None, parents=None, transient=False, 
+    externals=Externals(), listener=Commandline()):
     """Execute a command and log it as provenance for the newly created file.
 
     Args:
@@ -21,7 +23,6 @@ def record(command, new=None, parents=None, transient=False, externals=Externals
     Returns:
         dict: New provenance
     """
-    result = externals.run(command)
     transformation = command[0]
     code = ' '.join(command)
     for c in range(len(command)):
@@ -33,5 +34,7 @@ def record(command, new=None, parents=None, transient=False, externals=Externals
         _parents = parents
     if new:
         _new = new
+    listener.interpretedRecording(_new, transformation, _parents)
+    result = externals.run(command)
     return log(_new, transformation, _parents, code=code, transient=transient,
         logtext=result.output)

tests/recording.py

@@ -4,44 +4,43 @@
 
 class RecordingTests(unittest.TestCase):
 
-    def test_Executes_commands(self):
+    def setUp(self):
         import niprov.recording as recording
-        log = Mock()
-        recording.log = log
+        self.log = Mock()
+        self.sub = Mock()
+        self.listener = Mock()
+        recording.log = self.log
+        self.recording = recording
+
+    def record(self, cmd, **kwargs):
+        self.recording.record(cmd, externals=self.sub, listener=self.listener, **kwargs)
+
+    def test_Executes_commands(self):
         cmd = ['mytransform','-out','newfile.f','-in','oldfile.f']
-        sub = Mock()
-        recording.record(cmd, externals=sub)
-        sub.run.assert_any_call(cmd)
+        self.record(cmd)
+        self.sub.run.assert_any_call(cmd)
 
     def test_Extracts_provenance_from_commands(self):
-        import niprov.recording as recording
-        log = Mock()
         cmd = ['mytransform','-out','newfile.f','-in','oldfile.f']
-        sub = Mock()
-        recording.log = log
-        recording.record(cmd, externals=sub)
-        log.assert_called_with('newfile.f','mytransform',['oldfile.f'], 
-            transient=False, code=' '.join(cmd), logtext=sub.run().output)
+        self.record(cmd)
+        self.log.assert_called_with('newfile.f','mytransform',['oldfile.f'], 
+            transient=False, code=' '.join(cmd), logtext=self.sub.run().output)
 
     def test_If_parent_or_new_provided_override_parsed(self):
-        import niprov.recording as recording
-        log = Mock()
         cmd = ['mytransform','-out','newfile.f','-in','oldfile.f']
-        sub = Mock()
-        recording.log = log
-        recording.record(cmd, parents=['customParent'], new='customNew',
-            externals=sub)
-        log.assert_called_with('customNew','mytransform',['customParent'],
-            transient=False, code=' '.join(cmd), logtext=sub.run().output)
+        self.record(cmd, parents=['customParent'], new='customNew')
+        self.log.assert_called_with('customNew','mytransform',['customParent'],
+            transient=False, code=' '.join(cmd), logtext=self.sub.run().output)
 
     def test_Passes_transient_flag(self):
-        import niprov.recording as recording
-        log = Mock()
         cmd = ['mytransform','-out','newfile.f','-in','oldfile.f']
-        sub = Mock()
-        recording.log = log
-        recording.record(cmd, transient=True, externals=sub)
-        log.assert_called_with('newfile.f','mytransform',['oldfile.f'], 
-            transient=True, code=' '.join(cmd), logtext=sub.run().output)
-
+        self.record(cmd, transient=True)
+        self.log.assert_called_with('newfile.f','mytransform',['oldfile.f'], 
+            transient=True, code=' '.join(cmd), logtext=self.sub.run().output)
+
+    def test_Informs_listener_about_interpretation(self):
+        cmd = ['mytransform','-out','newfile.f','-in','oldfile.f']
+        self.record(cmd)
+        self.listener.interpretedRecording.assert_called_with(
+            'newfile.f','mytransform',['oldfile.f'])