archimate-diff 0.1.0

data/lib/archimate/diff/cli/conflict_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "highline"
+
+module Archimate
+  module Diff
+    module Cli
+      class ConflictResolver
+        def initialize
+          @config = Config.instance
+          # TODO: pull the stdin/stdout from the app config
+          @hl = HighLine.new(STDIN, STDOUT)
+        end
+
+        # TODO: this implementation has much to be written
+        def resolve(conflict)
+          return [] unless @config.interactive
+          base_local_diffs = conflict.base_local_diffs
+          base_remote_diffs = conflict.base_remote_diffs
+          choice = @hl.choose do |menu|
+            menu.prompt = conflict
+            menu.choice(:local, text: base_local_diffs.map(&:to_s).join("\n\t\t"))
+            menu.choice(:remote, text: base_remote_diffs.map(&:to_s).join("\n\t\t"))
+            # menu.choice(:neither, help: "Don't choose either set of diffs")
+            # menu.choice(:edit, help: "Edit the diffs (coming soon)")
+            # menu.choice(:quit, help: "I'm in over my head. Just stop!")
+            menu.select_by = :index_or_name
+          end
+          case choice
+          when :local
+            base_local_diffs
+          when :remote
+            base_remote_diffs
+          else
+            error "Unexpected choice #{choice.inspect}."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/diff/cli/diff.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    module Cli
+      class Diff
+        attr_reader :local, :remote
+
+        def self.diff(local_file, remote_file)
+          local = Archimate.read(local_file)
+          remote = Archimate.read(remote_file)
+
+          my_diff = Diff.new(local, remote)
+          my_diff.diff
+        end
+
+        def initialize(local, remote)
+          @local = local
+          @remote = remote
+        end
+
+        def diff
+          diffs = Archimate.diff(local, remote)
+
+          diffs.each { |d| puts d }
+
+          puts "\n\n#{diffs.size} Differences"
+
+          diffs
+        end
+      end
+    end
+  end
+end

data/lib/archimate/diff/cli/diff_summary.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+require 'forwardable'
+
+module Archimate
+  module Diff
+    module Cli
+      class DiffSummary
+        using DataModel::DiffableArray
+        using DataModel::DiffablePrimitive
+
+        DIFF_KINDS = %w(Delete Change Insert).freeze
+
+        attr_reader :local, :remote
+
+        def self.diff(local_file, remote_file, options = { verbose: true })
+          logger.info "Reading #{local_file}"
+          local = Archimate.read(local_file)
+          logger.info "Reading #{remote_file}"
+          remote = Archimate.read(remote_file)
+
+          my_diff = DiffSummary.new(local, remote)
+          my_diff.diff
+        end
+
+        def initialize(local, remote)
+          @local = local
+          @remote = remote
+          @summary = Hash.new { |hash, key| hash[key] = Hash.new { |k_hash, k_key| k_hash[k_key] = 0 } }
+        end
+
+        def diff
+          logger.info "Calculating differences"
+          diffs = Archimate.diff(local, remote)
+
+          puts Color.color("Summary of differences", :headline)
+          puts "\n"
+
+          summary_element_diffs = diffs.group_by { |diff| diff.summary_element.class.to_s.split("::").last }
+          summarize_elements summary_element_diffs["Element"]
+          summarize "Organization", summary_element_diffs["Organization"]
+          summarize "Relationship", summary_element_diffs["Relationship"]
+          summarize_diagrams summary_element_diffs["Diagram"]
+
+          puts "Total Diffs: #{diffs.size}"
+        end
+
+        def summarize(title, diffs)
+          return if diffs.nil? || diffs.empty?
+          by_kind = diffs_by_kind(diffs)
+
+          puts color(title)
+          DIFF_KINDS.each do |kind|
+            puts format("  #{color(kind)}: #{by_kind[kind]&.size}") if by_kind.key?(kind)
+          end
+        end
+
+        def diffs_by_kind(diffs)
+          diffs
+            .group_by(&:summary_element)
+            .each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |(summary_element, element_diffs), a|
+            top_level_diff = element_diffs.find { |diff| summary_element == diff.target.value }
+            if top_level_diff
+              a[top_level_diff.kind] << summary_element
+            else
+              a["Change"] << summary_element
+            end
+          end
+        end
+
+        def summarize_elements(diffs)
+          return if diffs.nil? || diffs.empty?
+          puts Color.color("Elements", :headline)
+          by_layer = diffs.group_by { |diff| diff.summary_element.layer }
+          summarize "Business", by_layer["Business"]
+          summarize "Application", by_layer["Application"]
+          summarize "Technology", by_layer["Technology"]
+          summarize "Motivation", by_layer["Motivation"]
+          summarize "Implementation and Migration", by_layer["Implementation and Migration"]
+          summarize "Connectors", by_layer["Connectors"]
+        end
+
+        def summarize_diagrams(diffs)
+          return if diffs.nil? || diffs.empty?
+          puts Color.color("Diagrams", :headline)
+
+          by_kind = diffs_by_kind(diffs)
+          %w(Delete Change Insert).each do |kind|
+            next unless by_kind.key?(kind)
+            diagram_names = by_kind[kind].uniq.map(&:name)
+            puts "  #{color(kind)}"
+            # TODO: make this magic number an option
+            diagram_names[0..14].each { |diagram_name| puts "    #{diagram_name}" }
+            puts "    ... and #{diagram_names.size - 15} more" if diagram_names.size > 15
+          end
+        end
+
+        def color(kind)
+          Color.color(kind, kind)
+        end
+      end
+    end
+  end
+end

data/lib/archimate/diff/cli/merge.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "parallel"
+
+module Archimate
+  module Diff
+    module Cli
+      class Merge
+        include Logging
+
+        attr_reader :base, :local, :remote, :merged_file
+
+        def self.merge(base_file, remote_file, local_file, merged_file)
+          Logging.debug { "Reading base file: #{base_file}, local file: #{local_file}, remote file: #{remote_file}" }
+          base, local, remote = Parallel.map([base_file, local_file, remote_file], in_processes: 3) do |file|
+            Archimate.read(file)
+          end
+          Logging.debug { "Merged file is #{merged_file}" }
+
+          Merge.new(base, local, remote, merged_file).run_merge
+        end
+
+        def initialize(base, local, remote, merged_file)
+          @base = base
+          @local = local
+          @remote = remote
+          @merged_file = merged_file
+          @merge = Archimate::Diff::Merge.new
+        end
+
+        def run_merge
+          debug { "Starting merging" }
+          merged, conflicts = @merge.three_way(base, local, remote)
+          # TODO: there should be no conflicts here
+          debug do
+            <<~MSG
+              Done merging
+              #{conflicts}
+            MSG
+          end
+
+          File.open(merged_file, "w") do |file|
+            # TODO: this should be controlled by the options and the defaulted to the read format
+            debug { "Serializing" }
+            Archimate::FileFormats::ArchiFileWriter.write(merged, file)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/diff/cli/merger.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    module Cli
+      # Merger is a class that is a decorator on Archimate::DataModel::Model
+      # to provide the capability to merge another model into itself
+      #
+      # TODO: provide for a conflict resolver instance
+      # TODO: provide an option to determine if potential matches are merged
+      #       or if the conflict resolver should be asked.
+      class Merger # < SimpleDelegator
+        # def initialize(primary_model, conflict_resolver)
+        #   super(primary_model)
+        #   @resolver = conflict_resolver
+        # end
+
+        # What merge does:
+        # For all entities: (other than Model...):
+        #   - PropertyDefinition
+        #   - View
+        #   - Viewpoint
+        # Entity:
+        #   look for a matching entity: with result
+        #     1. Found a matching entity: goto entity merge
+        #     2. Found no matching entity, but id conflicts: gen new id, goto add entity
+        #     3. Found no matching entity: goto add entity
+        #   entity merge:
+        #     1. merge (with func from deduper)
+        #   add entity:
+        #     1. add entity to model
+        #   add remapping entry to map from entities other model id to id in this model
+        # Relationship:
+        # def merge(other_model)
+        #   other_model.entities.each do |entity|
+        #     # TODO: matching entity should use the same criteria that DuplicateEntities uses.
+        #     my_entity = find_matching_entity(entity)
+        #     if my_entity
+        #   end
+        # end
+
+        # TODO: handle inner text of elements
+        # TODO: handle merging by element type
+
+        def hash_to_attr(h)
+          h.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+        end
+
+        def e_to_s(e)
+          "#{e.name} #{hash_to_attr(e.attributes)}"
+        end
+
+        # Merge node1, node2
+        # For node
+        #   For each child
+        #     If has a matching child
+        def merge(doc1, doc2)
+          doc2.children.each do |e|
+            next if e.name == "text" && e.text.strip.empty?
+            # p = e.path
+            # if p =~ /\[\d+\]$/
+            #   p = p.gsub(/\[\d+\]$/, "[@name=\"#{e.attr("name")}\"]")
+            # end
+            # puts "Looking for #{p}"``
+            # matches = doc1.xpath(p)
+            css = ">#{e.name}"
+            # puts css
+            css += "[name=\"#{e.attr('name')}\"]" if e.attributes.include?("name")
+            css += "[xsi|type=\"#{e.attr('xsi:type')}\"]" if e.attributes.include?("xsi:type")
+            matches = doc1.css(css)
+            if !matches.empty? # We have a potential match
+              # puts "Match?"
+              # puts "  Doc2: #{e_to_s(e)}"
+              # matches.each do |e1|
+              #   puts "  Doc1: #{e_to_s(e1)}"
+              # end
+              merge(matches[0], e) unless matches.size > 1
+            else # No match insert the node into the tree TODO: handle id conflicts
+              doc1.add_child(e)
+            end
+          end
+          doc1
+        end
+
+        def id_hash_for(doc)
+          doc.css("[id]").each_with_object({}) do |obj, memo|
+            memo[obj["id"]] = obj
+            memo
+          end
+        end
+
+        def conflicting_ids(doc1, doc2)
+          doc_id_hash1 = id_hash_for(doc1)
+          doc_id_hash2 = id_hash_for(doc2)
+          cids = Set.new(doc_id_hash1.keys) & doc_id_hash2.keys
+          # puts "ID Conflicts:"
+          # puts cids.to_a.join(",")
+          cids
+        end
+
+        def merge_files(file1, file2)
+          doc1 = Nokogiri::XML(File.open(file1))
+          doc2 = Nokogiri::XML(File.open(file2))
+
+          # cids = conflicting_ids(doc1, doc2)
+          merge(doc1.root, doc2.root).document
+        end
+      end
+    end
+  end
+end

data/lib/archimate/diff/conflict.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Conflict
+      attr_reader :base_local_diffs
+      attr_reader :base_remote_diffs
+      attr_reader :reason
+      attr_reader :diffs
+
+      def initialize(base_local_diffs, base_remote_diffs, reason)
+        @base_local_diffs = Array(base_local_diffs)
+        @base_remote_diffs = Array(base_remote_diffs)
+        @diffs = @base_local_diffs + @base_remote_diffs
+        @reason = reason
+      end
+
+      def to_s
+        "#{Color.color('CONFLICT:', [:black, :on_red])} #{reason}\n" \
+          "\tBase->Local Diff(s):\n\t\t#{base_local_diffs.map(&:to_s).join("\n\t\t")}" \
+          "\n\tBase->Remote Diffs(s):\n\t\t#{base_remote_diffs.map(&:to_s).join("\n\t\t")}"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          base_local_diffs == other.base_local_diffs &&
+          base_remote_diffs == other.base_remote_diffs &&
+          reason == other.reason
+      end
+    end
+  end
+end

data/lib/archimate/diff/conflicts.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'parallel'
+require 'archimate/diff/conflicts/base_conflict'
+require 'archimate/diff/conflicts/deleted_items_child_updated_conflict'
+require 'archimate/diff/conflicts/deleted_items_referenced_conflict'
+require 'archimate/diff/conflicts/path_conflict'
+
+module Archimate
+  module Diff
+    class Conflicts
+      extend Forwardable
+
+      attr_reader :base_local_diffs
+      attr_reader :base_remote_diffs
+
+      def_delegator :@conflicts, :empty?
+      def_delegator :@conflicts, :size
+      def_delegator :@conflicts, :first
+      def_delegator :@conflicts, :map
+      def_delegator :@conflicts, :each
+
+      include Archimate::Logging
+
+      def initialize(base_local_diffs, base_remote_diffs)
+        @base_local_diffs = base_local_diffs
+        @base_remote_diffs = base_remote_diffs
+        @conflict_finders = [PathConflict, DeletedItemsChildUpdatedConflict, DeletedItemsReferencedConflict]
+        @conflicts = nil
+        @conflicting_diffs = nil
+        @unconflicted_diffs = nil
+        # TODO: consider making this an argument
+        @conflict_resolver = Cli::ConflictResolver.new
+      end
+
+      # TODO: refactor this method elsewhere
+      # resolve iterates through the set of conflicting diffs asking the user
+      # (if running interactively) and return the set of diffs that can be applied.
+      #
+      # To keep diffs reasonably human readable in logs, the local diffs should
+      # be applied first followed by the remote diffs.
+      def resolve
+        debug do
+          <<~MSG
+            Filtering out #{conflicts.size} conflicts from #{base_local_diffs.size + base_remote_diffs.size} diffs
+            Remaining diffs #{unconflicted_diffs.size}
+          MSG
+        end
+
+        conflicts.each_with_object(unconflicted_diffs) do |conflict, diffs|
+          # TODO: this will result in diffs being out of order from their
+          # original order. diffs should be flagged as conflicted and
+          # this method should instead remove the conflicted flag.
+          diffs.concat(@conflict_resolver.resolve(conflict))
+          # TODO: if the conflict is resolved, it should be removed from the
+          # @conflicts array.
+        end
+      end
+
+      def conflicts
+        @conflicts ||= find_conflicts
+      end
+
+      def conflicting_diffs
+        @conflicting_diffs ||= conflicts.map(&:diffs).flatten
+      end
+
+      def unconflicted_diffs
+        @unconflicted_diffs ||=
+          (base_local_diffs + base_remote_diffs) - conflicting_diffs
+      end
+
+      def to_s
+        "Conflicts:\n\n#{conflicts.map(&:to_s).join("\n\n")}\n"
+      end
+
+      private
+
+      def find_conflicts
+        # TODO: Running this in parallel breaks currently.
+        # @conflicts = Parallel.map(@conflict_finders, in_processes: 3) { |cf_class|
+        @conflicts = @conflict_finders.map { |cf_class|
+          cf_class.new(base_local_diffs, base_remote_diffs).conflicts
+        }.flatten
+      end
+    end
+  end
+end