bond-spy 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff046742322ed31d8ac6ce9b5145d67072af7593
-  data.tar.gz: 95c911f15617180b17afc73b0812c56225cb8112
+  metadata.gz: c65fb7c7aa4cf11b582ae1620a91b522d88aaee3
+  data.tar.gz: fc50ff99e60d3c387394c886d48196722f056c6c
 SHA512:
-  metadata.gz: e168396ccc1ab5a002be950f5680b26b31a26186ef0e6003b3bd54bc511591973367128683d2da958627ce3ba65e2dfbb1db71c68f66851d19ff174c9b4f5b56
-  data.tar.gz: f6511ca661d7395403668d315dfbc96f47b9578d1757528a8c25b47e1e2dfe56b963590fa237643e870788cc5bb8ed1095bfb8eec8972adec535c42b4acf398b
+  metadata.gz: dfaa6acd7d9c78967231e194b652db630b271d07d6091a0bc7add63b8c598bf253ca97bd9451216d98203e5a896cd51a8789b999b1ceefd2a73928b7f03aba75
+  data.tar.gz: 72e3e53c5616f4948f8a0d0c2bbf0d758fa2df145a16161bf905421143bc49bebd1946c9596fbc4daf14a52b82f20d8edf3416e1018b6320263ea764ed1e6efe

data/bin/bond_reconcile.py

@@ -3,9 +3,11 @@
 from __future__ import print_function
 
 import os
-import re
-import shutil
+import difflib
+import string
+import random
 import sys
+from bond_dialog import OptionDialog
 
 try:
     # Import bond safely
@@ -24,6 +26,8 @@ class ReconcileTool:
     Base class for reconcile tools
     """
 
+    TMP_FILE_BASE_NAME = '/tmp/bond_tmp_'
+
     @staticmethod
     def select(reconcile_tool=None):
 
@@ -36,12 +40,15 @@ class ReconcileTool:
         if reconcile_tool == 'console':
             return ReconcileToolConsole()
 
+        if reconcile_tool == 'dialog':
+            return ReconcileToolDialog()
+
         if reconcile_tool == 'kdiff3':
             return ReconcileToolKdiff3()
 
         if reconcile_tool is None:
             # Look at the environment variable BOND_RECONCILE
-            reconcile_tool = os.environ.get('BOND_RECONCILE', 'abort')
+            reconcile_tool = os.environ.get('BOND_RECONCILE', 'console')
             if reconcile_tool is not None:
                 return ReconcileTool.select(reconcile_tool)
 
@@ -59,16 +66,69 @@ class ReconcileTool:
         """
         return os.system(cmd)
 
+    @staticmethod
+    def _get_user_input_console(prompt, options, single_char_options):
+        """
+        Get input from the user using a console.
+        :param prompt: The main prompt string to display to the user.
+        :param options: A tuple of options to present to the user for them to select; must have
+                        at least one. The last option is the default.
+        :param single_char_options: A tuple of the single-character versions of each of the
+                                    options supplied; this tuple must be the same length as ``options``,
+                                    and each single-character version must appear within the option itself.
+        :return: The user response, which is guaranteed to be one of the supplied ``options`` (if the user
+                 input an invalid response the default option is used).
+        """
+        opts_with_single_char = \
+            [string.replace(opt, char, '[' + char + ']', 1) for opt, char in zip(options, single_char_options)]
+        # Default option, highlight it in bold
+        opts_with_single_char[-1] = '\033[1m' + opts_with_single_char[-1] + '\033[0m'
+        response = raw_input(prompt + ' (' + ' | '.join(opts_with_single_char) + '): ')
+        if len(response) == 0:  # No input; return the default
+            return options[-1]
+        elif len(response) == 1:  # Single-character; find matching option
+            return next((opt for opt, char in zip(options, single_char_options) if char == response), options[-1])
+        else:
+            # Make sure response is a valid option; if not return the default
+            return next((opt for opt in options if opt == response), options[-1])
+
+    @staticmethod
+    def _get_user_input_dialog(prompt, options):
+        """
+        Get input from the user using a dialog box.
+        :param prompt: The main prompt string to display to the user.
+        :param options: A tuple of options to present to the user for them to select; must have
+                        at least one. The last option is the default.
+        :return: The user response, which is guaranteed to be one of the supplied ``options``
+                 (if the user input an invalid response the default option is used).
+        """
+        return OptionDialog.create_dialog_get_value(prompt, options)
+
     @staticmethod
     @spy_point(enabled_for_groups='bond_self_test',
                require_agent_result=True,
+               excluded_keys=('extra_dialog_prompt','single_char_options'),
                spy_result=True)
-    def _read_console(prompt):
+    def _get_user_input(prompt, options, single_char_options, extra_dialog_prompt=''):
         """
-        A function to read from the console
+        Acquire input from the user. Defaults to using the console to ask for input. If
+        a console is not available, falls back to using a popup dialog window.
+        :param prompt: The main prompt string to display to the user.
+        :param options: A tuple of options to present to the user for them to select; must have
+                        at least one. The last option is the default.
+        :param single_char_options: A tuple of the single-character versions of each of the
+                                    options supplied; this tuple must be the same length as ``options``,
+                                    and each single-character version must appear within the option itself.
+        :param extra_dialog_prompt: An extra message to display before the prompt only if the fallback
+                                    dialog box is used.
+        :return: The user response, which is guaranteed to be one of the supplied ``options`` (if the user
+                 input an invalid response the default option is used).
         """
-        return raw_input(prompt)
-
+        if sys.stdin.isatty():  # We use the console to retrieve input
+            return ReconcileTool._get_user_input_console(prompt, options, single_char_options)
+        else:  # We use a dialog box to retrieve input
+            print('System console not found; using a dialog box to retrieve input instead.')
+            return ReconcileTool._get_user_input_dialog(extra_dialog_prompt + '\n' + prompt, options)
 
     @staticmethod
     @spy_point(enabled_for_groups='bond_self_test')
@@ -81,23 +141,26 @@ class ReconcileTool:
         print(what)
 
     @staticmethod
-    def _quick_diff(reference_file, current_file, diff_file):
+    @spy_point(enabled_for_groups='bond_self_test', mock_only=True)
+    def _random_string():
         """
-        Compute a diff between files and save it into a diff_file.
-        Return True if there are no diffs
+        Generate a short random string
         """
-        # TODO: implicit dependency on a 'diff' command line tool with the same usage syntax that you're expecting
-        return (0 == ReconcileTool._invoke_command('diff -u -b "{0}" "{1}" >"{2}"'.format(reference_file,
-                                                                                      current_file,
-                                                                                      diff_file)))
+        return ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(8))
 
     @staticmethod
-    def _aux_file_name(current_file,
-                       flavor):
+    def _tmp_file_name(flavor):
         """
-        The name of the auxiliary (e.g., diff, merged) file to use
+        The name of the temporary file to use with a flavor-specific
+        (e.g. diff, curr, ref) ending.
         """
-        return current_file + "." + flavor
+        # We include a short random string to avoid potential collisions
+        return ReconcileTool.TMP_FILE_BASE_NAME + ReconcileTool._random_string() + "." + flavor
+
+    @staticmethod
+    @spy_point(enabled_for_groups='bond_self_test')
+    def _compute_diff(reference_lines, current_lines):
+        return list(difflib.unified_diff(reference_lines, current_lines, 'reference', 'current'))
 
     def __init__(self):
         pass
@@ -105,66 +168,60 @@ class ReconcileTool:
     def reconcile(self,
                   test_name,
                   reference_file,
-                  current_file,
+                  current_lines,
                   no_save=None):
         """
         Reconcile the differences
         @param test_name: the name of the test (for messages)
         @param reference_file: the name of the reference observation file
-        @param current_file: the name of the current observation file
+        @param current_lines: a list of the lines which make up the current set of observations
         :param no_save: if present, then disallows saving a new reference file.
                This parameter should be a string explaining why saving is disallowed.
         """
 
-        if not os.path.isfile(reference_file):
+        if os.path.isfile(reference_file):
+            with open(reference_file, 'r') as f:
+                reference_lines = f.readlines()
+        else:
             # if we do not have the reference file, pretend we have an empty one
             ReconcileTool._print('WARNING: No reference observation file found for {}: {}'.format(test_name, reference_file))
-
-            with open(reference_file, 'w') as f:
-                pass
-            # We continue
+            reference_lines = list()
 
         # Compute a quick difference
-        diff_file = self._aux_file_name(current_file, "diff")
-        try:
-            if self._quick_diff(reference_file, current_file, diff_file):
-                # There are no differences
-                return True
-
-            # There are differences
-            merged_file = self.invoke_tool(test_name,
-                                           reference_file,
-                                           current_file,
-                                           diff_file,
-                                           no_save=no_save)
-            if merged_file is not None:
-                # Accepted differences
-                if no_save:
-                    ReconcileTool._print("Not saving reference observation file for {}: {}".format(test_name,
-                                                                                                   no_save))
-                else:
-                    ReconcileTool._print('Saving updated reference observation file for {}'.format(test_name))
-                    shutil.move(merged_file, reference_file)
-                return True
+        unified_diff = self._compute_diff(reference_lines, current_lines)
+
+        if len(unified_diff) == 0:
+            # There are no differences
+            return True
+
+        # There are differences
+        merged_lines = self.invoke_tool(test_name,
+                                        reference_lines,
+                                        current_lines,
+                                        unified_diff,
+                                        no_save=no_save)
+        if merged_lines is not None:
+            # Accepted differences
+            if no_save:
+                ReconcileTool._print("Not saving reference observation file for {}: {}".format(test_name,
+                                                                                               no_save))
             else:
-                return False
-
-        finally:
-            # Delete the files
-            if os.path.isfile(diff_file):
-                os.unlink(diff_file)
-            if os.path.isfile(current_file):
-                os.unlink(current_file)
+                ReconcileTool._print('Saving updated reference observation file for {}'.format(test_name))
+                if os.path.isfile(reference_file):
+                    os.unlink(reference_file)
+                with open(reference_file, 'w') as f:
+                    f.writelines(merged_lines)
+            return True
+        else:
+            return False
 
     def show_diff(self,
                   test_name,
-                  diff_file):
+                  unified_diff):
         """
-        Show the diff, and return it
+        Show the lines of the diff, and return it as a string
         """
-        diffs = ''
-        with open(diff_file, 'r') as f:
-            diffs = f.read()
+        diffs = ''.join(unified_diff)
         if diffs:
             ReconcileTool._print('There were differences in observations for {}: '.format(test_name))
             ReconcileTool._print(diffs)
@@ -175,14 +232,14 @@ class ReconcileTool:
         return diffs
 
     def invoke_tool(self, test_name,
-                    reference_file,
-                    current_file,
-                    diff_file,
+                    reference_lines,
+                    current_lines,
+                    unified_diff,
                     no_save=None):
         """
         Invoke the actual tool
         @param
-        @return either False, for a failed merge, or the name of the file to use as the new reference
+        @return either False, for a failed merge, or a list of the new lines to use as the reference
         """
         assert False, 'Must override'
 
@@ -194,12 +251,12 @@ class ReconcileToolAbort(ReconcileTool):
 
     def invoke_tool(self,
                     test_name,
-                    reference_file,
-                    current_file,
-                    diff_file,
+                    reference_lines,
+                    current_lines,
+                    unified_diff,
                     no_save=None):
         if not no_save:
-            self.show_diff(test_name, diff_file)
+            self.show_diff(test_name, unified_diff)
         ReconcileTool._print('Aborting (reconcile=abort) due to differences for test {}'.format(test_name))
         return None
 
@@ -211,60 +268,70 @@ class ReconcileToolAccept(ReconcileTool):
 
     def invoke_tool(self,
                     test_name,
-                    reference_file,
-                    current_file,
-                    diff_file,
+                    reference_lines,
+                    current_lines,
+                    unified_diff,
                     no_save=None):
-        diffs = self.show_diff(test_name, diff_file)
+        self.show_diff(test_name, unified_diff)
         if not no_save:
             ReconcileTool._print('Accepting (reconcile=accept) differences for test {}'.format(test_name))
-        return current_file
+        return current_lines
 
 
 class ReconcileToolConsole(ReconcileTool):
     """
-    Uses diff and console prompts to accept the changes
+    Uses diff and console prompts to accept the changes. Falls back to a dialog window
+    if no console is available for input.
     """
 
     def invoke_tool(self,
                     test_name,
-                    reference_file,
-                    current_file,
-                    diff_file,
+                    reference_lines,
+                    current_lines,
+                    unified_diff,
                     no_save=None):
 
+        extra_msg = None
         while True:
             if no_save:
-                prompt = 'Observations are shown for {}. Saving them not allowed because test failed.'.format(
-                    test_name,
-                ) + ' Use the diff option to show the differences. ([k]diff3 | [d]iff | [e] errors | *): '
+                prompt = 'Observations are shown for {}. Saving them not allowed because test failed. ' \
+                         'Use the diff option to show the differences.'.format(test_name)
+                response = self._input(prompt, ('kdiff3', 'diff', 'errors', 'continue'),
+                                       ('k', 'd', 'e', 'c'),
+                                       extra_msg if extra_msg else '\n'.join(current_lines))
             else:
                 # Show the diff
-                self.show_diff(test_name, diff_file)
-                prompt = 'Do you want to accept the changes ({}) ? ( [y]es | [k]diff3 | *): '.format(test_name)
-
-            response = ReconcileTool._read_console(prompt)
+                diff = self.show_diff(test_name, unified_diff)
+                prompt = 'Do you want to accept the changes ({})?'.format(test_name)
+                response = self._input(prompt, ('kdiff3', 'yes', 'no'), ('k', 'y', 'n'), diff)
 
-            if response == 'k':
-                return ReconcileToolKdiff3().invoke_tool(test_name, reference_file, current_file, diff_file,
+            if response == 'kdiff3':
+                return ReconcileToolKdiff3().invoke_tool(test_name, reference_lines, current_lines, unified_diff,
                                                          no_save=no_save)
-
-            if response == 'd' and no_save:
-                self.show_diff(test_name, diff_file)
+            elif response == 'diff':
+                extra_msg = self.show_diff(test_name, unified_diff)
                 continue
-
-            if response == 'e' and no_save:
-                ReconcileTool._print("Test {} had errors:\n{}".format(test_name, no_save))
+            elif response == 'errors':
+                extra_msg = "Test {} had errors:\n{}".format(test_name, no_save)
+                ReconcileTool._print('\033[91m' + extra_msg + '\033[0m')
                 continue
-
-            if response == 'y' and not no_save:
+            elif response == 'yes' and not no_save:
                 ReconcileTool._print('Accepting differences for test {}'.format(test_name))
-                return current_file
-
-            if not no_save:
+                return current_lines
+            elif not no_save:
                 ReconcileTool._print('Rejecting differences for test {}'.format(test_name))
             return None
 
+    def _input(self, prompt, options, single_char_options, extra_dialog_prompt=None):
+        return ReconcileTool._get_user_input(prompt, options, single_char_options, extra_dialog_prompt)
+
+
+class ReconcileToolDialog(ReconcileToolConsole):
+    """
+    Merge with a dialog window.
+    """
+    def _input(self, prompt, options, single_char_options, extra_dialog_prompt=None):
+        return ReconcileTool._get_user_input_dialog(extra_dialog_prompt + '\n' + prompt, options)
 
 
 class ReconcileToolKdiff3(ReconcileTool):
@@ -274,57 +341,77 @@ class ReconcileToolKdiff3(ReconcileTool):
 
     def invoke_tool(self,
                     test_name,
-                    reference_file,
-                    current_file,
-                    diff_file,
+                    reference_lines,
+                    current_lines,
+                    unified_diff,
                     no_save=None):
 
-        if no_save:
-            response = ReconcileTool._read_console(
-                "\n!!! MERGING NOT ALLOWED for {}: {}. Want to start kdiff3? ([y] | *): ".format(test_name,
-                                                                                                 no_save))
-            if response != "y":
+        # Save the current lines out to a temporary file to use with kdiff3
+        current_file = self._tmp_file_name('curr')
+        reference_file = self._tmp_file_name('ref')
+        try:
+            with open(current_file, 'w') as f:
+                f.writelines(current_lines)
+            with open(reference_file, 'w') as f:
+                f.writelines(reference_lines)
+
+            merged_file = None
+            if no_save:
+                response = ReconcileTool._get_user_input(
+                    "\n!!! MERGING NOT ALLOWED for {}: {}. Want to start kdiff3?".format(test_name, no_save),
+                    ('yes', 'no'), ('y', 'n'))
+                if response != 'yes':
+                    return None
+
+                cmd = ('kdiff3 "{reference_file}" --L1 "{test_name}_REFERENCE" '
+                       '"{current_file}" --L2 "{test_name}_CURRENT" ').format(
+                    reference_file=reference_file,
+                    current_file=current_file,
+                    test_name=test_name)
+                ReconcileTool._invoke_command(cmd)
                 return None
 
-            cmd = ('kdiff3 "{reference_file}" --L1 "{test_name}_REFERENCE" '
-                   '"{current_file}" --L2 "{test_name}_CURRENT" ').format(
-                reference_file=reference_file,
-                current_file=current_file,
-                test_name=test_name)
-        else:
-            merged_file = self._aux_file_name(current_file, 'merged')
-
-            cmd = ('kdiff3 -m "{reference_file}" --L1 "{test_name}_REFERENCE" '
-                   '"{current_file}" --L2 "{test_name}_CURRENT" '
-                   ' -o "{merged_file}"').format(reference_file=reference_file,
-                                                 current_file=current_file,
-                                                 merged_file=merged_file,
-                                                 test_name=test_name)
-
-        print(cmd)
-        code = ReconcileTool._invoke_command(cmd)
-        if no_save:
-            return None
-        else:
-            if code == 0 :
-                # Merged ok
-                return merged_file
             else:
-                if os.path.isfile(merged_file):
-                    os.unlink(merged_file)
-                return None
+                merged_file = self._tmp_file_name('merged')
+                cmd = ('kdiff3 -m "{reference_file}" --L1 "{test_name}_REFERENCE" '
+                       '"{current_file}" --L2 "{test_name}_CURRENT" '
+                       ' -o "{merged_file}"').format(reference_file=reference_file,
+                                                     current_file=current_file,
+                                                     merged_file=merged_file,
+                                                     test_name=test_name)
+
+                code = ReconcileTool._invoke_command(cmd)
+                if code == 0:
+                    # Merged ok
+                    with open(merged_file, 'r') as f:
+                        merged_lines = f.readlines()
+                    message = 'Merge successful; saving a new reference file. '
+                    ret = merged_lines
+                else:
+                    message = 'Merge unsuccessful; not saving a new reference file. '
+                    ret = None
+
+                ReconcileTool._get_user_input(message, ('continue',), ('c',))
+                return ret
+        finally:
+            if os.path.isfile(current_file):
+                os.unlink(current_file)
+            if os.path.isfile(reference_file):
+                os.unlink(reference_file)
+            if merged_file is not None and os.path.isfile(merged_file):
+                os.unlink(merged_file)
 
 
 def reconcile_observations(settings,
                            test_name,
                            reference_file,
-                           current_file,
+                           current_lines,
                            no_save=None):
     """
     Reconcile the observations
     :param settings: a settings object
     :param reference_file: the reference file
-    :param current_file: the current file with observations
+    :param current_lines: a list of all of the lines in the current set of observations
     :param no_save: If present, then saving of new references is not allowed. This parameter
             should be a short string explaining why saving is not allowed.
     :return:
@@ -333,7 +420,7 @@ def reconcile_observations(settings,
     reconcile_tool = ReconcileTool.select(settings.get('reconcile'))
     return reconcile_tool.reconcile(test_name,
                                     reference_file,
-                                    current_file,
+                                    current_lines,
                                     no_save=no_save)
 
 
@@ -361,6 +448,9 @@ if __name__ == '__main__':
         print('The current file does not exist: {}'.format(opts.current), file=sys.stderr)
         sys.exit(1)
 
+    with open(opts.current, 'r') as f:
+        current_lines = f.readlines()
+    os.unlink(opts.current)
 
     # Guess the test name from the current file
     if opts.test:
@@ -378,7 +468,7 @@ if __name__ == '__main__':
     if reconcile_observations(main_settings,
                               main_test_name,
                               opts.reference,
-                              opts.current,
+                              current_lines,
                               no_save=opts.no_save):
         sys.exit(0)
     else: