compare instances and add ability to choose between csv and markdown format

Author: lindt

Rakefile

@@ -14,7 +14,7 @@ end
 desc 'Checks style'
 task audit: :rubocop
 task :audit do
-  ignores = %w(D100 D101 D102 D103 D104 E501 I201)
+  ignores = %w(D100 D101 D102 D103 D104 E501 I201 N806)
 
   FILES = FileList[%w(bin/compose_diff compose_diff/*.py setup.py)]
   sh "flake8 --ignore='#{ignores * ','}' #{FILES}"

bin/compose_diff

@@ -9,21 +9,32 @@ if __name__ == '__main__':
 
     parser = argparse.ArgumentParser()
     parser.add_argument(
-        '--images', action='store_const', const=True,
-        help='diffs the images', default=False)
+        '--versions', action='store_const', const=True,
+        help='diffs the image versions', default=False)
     parser.add_argument(
-        '--filter', action='store',
+        '--instances', action='store_const', const=True,
+        help='diffs the instances', default=False)
+    parser.add_argument(
+        '--filter', action='append',
         help='just consider specific items', default=None)
+    parser.add_argument(
+        '--format', action='store',
+        help='format (csv,markdown)', default='markdown')
     parser.add_argument('files', nargs=argparse.REMAINDER)
     args = parser.parse_args()
 
-    if args.images:
+    if args.versions or args.instances:
         if len(args.files) != 2:
             print('please diff exactly two files. You provided {0} files.'.format(len(args.files)))
             sys.exit(1)
 
         old, new = args.files[0], args.files[1]
 
-        ComposeDiff().diff_images(old, new, args.filter)
+        diff = ComposeDiff(
+            filter=args.filter,
+            diff_versions=args.versions,
+            diff_instances=args.instances,
+        )
+        print(diff.format(diff.diff(old, new), format=args.format))
     else:
         parser.print_help()

compose_diff/__init__.py

@@ -1,33 +1,86 @@
 #!/usr/bin/env python3
+import itertools
 from yaml import load
 
 
 class ComposeDiff:
 
-    def __init__(self):
-        pass
+    def __init__(self, filter=[], diff_versions=False, diff_instances=False):
+        self.filter = filter
+        self.diff_versions = diff_versions
+        self.diff_instances = diff_instances
 
-    def diff_images(self, old, new, filter):
-        old = self.images(self.read(old))
-        new = self.images(self.read(new))
+    def format(self, result, format='markdown'):
+        columns = ['name']
+        if self.diff_versions:
+            columns.append('version')
+        if self.diff_instances:
+            columns.append('instances')
+        CAPTIONS = {'name': 'Name', 'version': 'Version', 'instances': 'Instances'}
+        res = []
 
-        print('| {0} | {1} |'.format('Name', 'Version'))
-        print('| - | - |')
-        for key in sorted(set(list(old.keys()) + list(new.keys()))):
-            if filter is not None:
-                if filter not in key:
+        res.append([CAPTIONS[column] for column in columns])
+        if format == 'markdown':
+            res.append(['-' for _ in columns])
+        for item in result:
+
+            def escape(data):
+                data = str(data)
+
+                if format == 'markdown':
+                    data = data.replace('_', '\_')
+                    data = data.replace('|', '\|')
+                if format == 'csv':
+                    data = data.replace(';', '\;')
+                return data
+
+            res.append(list(escape(item[column]) for column in columns))
+
+        def format_table(res):
+            string = ''
+
+            for item in res:
+                if format == 'csv':
+                    string += ';'.join(item)
+                elif format == 'markdown':
+                    string += '| {0} |'.format(' | '.join(item))
+                string += '\n'
+            return string
+        return format_table(res)
+
+    def diff(self, old, new):
+        old, new = self.read(old), self.read(new)
+
+        old_versions, new_versions = self.image_versions(old), self.image_versions(new)
+        old_instances, new_instances = self.image_instances(old), self.image_instances(new)
+
+        keys = set(itertools.chain(old_versions.keys(), new_versions.keys(), old_instances.keys(), new_instances.keys()))
+        result = []
+
+        for key in sorted(keys):
+            if self.filter is not None:
+                skip = True
+
+                for filter in self.filter:
+                    if filter in key:
+                        skip = False
+                if skip:
                     continue
-            version = self.format_version(
-                old=old[key] if key in old else None,
-                new=new[key] if key in new else None)
+            version = self.format_diff(
+                old=old_versions[key] if key in old_versions else None,
+                new=new_versions[key] if key in new_versions else None)
+            instances = self.format_diff(
+                old=old_instances[key] if key in old_instances else None,
+                new=new_instances[key] if key in new_instances else None)
 
-            key = key.replace('_', '\_')
-            version = version.replace('_', '\_')
-            print('| {0} | {1} |'.format(key.split('/')[-1], version))
+            result.append({'name': key.split('/')[-1], 'version': version, 'instances': instances})  # TODO: named tuple
+        return result
 
     @staticmethod
-    def format_version(old, new):
+    def format_diff(old, new):
         if old is None:
+            if new is None:
+                return ''
             return '{0} (new)'.format(new)
         elif new is None:
             return '{0} (deleted)'.format(old)
@@ -41,20 +94,39 @@ def read(path):
             return load(file.read())
 
     @staticmethod
-    def images(data):
+    def image_versions(data):
         result = {}
 
-        if 'services' in data:
-            data = data['services']
-        for name, content in data.items():
+        for name, content in ComposeDiff.services(data).items():
             if content is None:
                 continue
             if 'image' not in content:
                 continue
             image_name, tag = ComposeDiff.split_image(content['image'])
+
             result[image_name] = tag
         return result
 
+    @staticmethod
+    def image_instances(data):
+        result = {}
+
+        for name, content in ComposeDiff.services(data).items():
+            if content is None:
+                continue
+            if 'image' not in content:
+                continue
+            image_name, _ = ComposeDiff.split_image(content['image'])
+
+            if image_name not in result:
+                result[image_name] = 0
+            result[image_name] += 1
+        return result
+
+    @staticmethod
+    def services(data):
+        return data['services'] if 'services' in data else data
+
     @staticmethod
     def split_image(data):
         if ':' not in data.split('/')[-1]:

features/format.feature

@@ -0,0 +1,49 @@
+Feature: Format
+  As a DevOps
+  I want to specify the format
+  so that I can combine the tool with other tools
+
+  Scenario: CSV
+    Given a file named "A.yml" with:
+      """
+      version: "2"
+      services:
+        one:
+          image: one:1
+      """
+    And a file named "B.yml" with:
+      """
+      version: "2"
+      services:
+        one:
+          image: one:2
+      """
+    When I run `bin/compose_diff --versions --format=csv A.yml B.yml`
+    Then it should pass with exactly:
+      """
+      Name;Version
+      one;2 (1)
+      """
+
+  Scenario: Markdown
+    Given a file named "A.yml" with:
+      """
+      version: "2"
+      services:
+        one:
+          image: one:1
+      """
+    And a file named "B.yml" with:
+      """
+      version: "2"
+      services:
+        one:
+          image: one:2
+      """
+    When I run `bin/compose_diff --versions --format=markdown A.yml B.yml`
+    Then it should pass with exactly:
+      """
+      | Name | Version |
+      | - | - |
+      | one | 2 (1) |
+      """

features/instances.feature

@@ -0,0 +1,29 @@
+Feature: Instances
+  As an Operations Manager
+  I want to see how many instances are deployed
+  so that I know where the scalling happens
+
+  Scenario: Instances
+    Given a file named "A.yml" with:
+      """
+      version: "2"
+      services:
+        one:
+          image: one:1
+      """
+    And a file named "B.yml" with:
+      """
+      version: "2"
+      services:
+        one:
+          image: one:1
+        one_2:
+          image: one:1
+      """
+    When I run `bin/compose_diff --instances A.yml B.yml`
+    Then it should pass with exactly:
+      """
+      | Name | Instances |
+      | - | - |
+      | one | 2 (1) |
+      """

features/images.feature renamed to features/versions.feature

@@ -1,6 +1,6 @@
-Feature: Images
+Feature: Versions
   As a Tester
-  I want to see which images have changed
+  I want to see which image versions have changed
   so that I know where to test especially
 
   Scenario: Diff Images
@@ -26,7 +26,7 @@ Feature: Images
         three:
           image: three:1
       """
-    When I run `bin/compose_diff --images A.yml B.yml`
+    When I run `bin/compose_diff --versions A.yml B.yml`
     Then it should pass with exactly:
       """
       | Name | Version |
@@ -56,10 +56,10 @@ Feature: Images
         two:
           image: two:2
       """
-    When I run `bin/compose_diff --images --filter one A.yml B.yml`
+    When I run `bin/compose_diff --version --filter one A.yml B.yml`
     Then it should pass with exactly:
       """
       | Name | Version |
       | - | - |
       | one | 2 (1) |
-      """
+      """

setup.py

@@ -8,7 +8,7 @@ def readme():
 
 setup(
     name='compose_diff',
-    version='0.2.0',
+    version='0.3.0',
     description='diff docker-compose files',
     long_description=readme(),
     url='http://github.com/funkwerk/compose_diff',