archimate-diff 0.1.0

data/archimate-diff.gemspec

@@ -0,0 +1,51 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'archimate-diff'
+
+Gem::Specification.new do |spec|
+  spec.name          = "archimate-diff"
+  spec.version       = Archimate::Diff::VERSION
+  spec.authors       = ["Mark Morga"]
+  spec.email         = ["markmorga@gmail.com", "mmorga@rackspace.com"]
+
+  spec.summary       = "Archimate-Diff Tools"
+  spec.description   = "A collection of tools to diff and merge ArchiMate files"
+  spec.homepage      = "http://github.com/mmorga/archimate-diff"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.metadata["yard.run"] = "yri" # use "yard" to build full HTML docs.
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_runtime_dependency "archimate", "~> 1.1"
+  spec.add_runtime_dependency "nokogiri", "~> 1.6"
+  spec.add_runtime_dependency "thor", "~> 0.19"
+  spec.add_runtime_dependency "highline", "~> 1.7"
+  spec.add_runtime_dependency "ruby-progressbar", "~>1.8.1"
+  spec.add_runtime_dependency "parallel", "~> 1.11"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-matchers"
+  spec.add_development_dependency "minitest-color"
+  spec.add_development_dependency "minitest-profile"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency "guard-bundler"
+  spec.add_development_dependency "ruby-prof"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-json"
+  spec.add_development_dependency "kramdown"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "guard-ctags-bundler"
+  spec.add_development_dependency "faker"
+  spec.add_development_dependency "rsense"
+  spec.add_development_dependency "awesome_print"
+end

data/exe/archidiff

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+# frozen_string_literal: true
+
+require "rubygems"
+require "archimate-diff"
+
+Archimate::Cli::Diff.diff(ARGV[0], ARGV[1], Archimate::AIO.new)

data/exe/archidiff-summary

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+# frozen_string_literal: true
+
+require "rubygems"
+require "archimate-diff"
+
+Archimate::Cli::DiffSummary.diff(ARGV[0], ARGV[1])

data/exe/archimerge

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+# frozen_string_literal: true
+
+require "rubygems"
+require "archimate-diff"
+
+Archimate::Cli::Merge.merge(ARGV[0], ARGV[1], ARGV[2], ARGV[3])

data/exe/fmtxml

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "archimate-diff"
+
+Archimate::Cli::XmlTextconv.new(ARGV[0])

data/lib/archimate-diff.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "archimate"
+require 'archimate/diff/difference'
+require 'archimate/diff/archimate_node_reference'
+require 'archimate/diff/archimate_identified_node_reference'
+require 'archimate/diff/archimate_array_reference'
+require 'archimate/diff/archimate_node_attribute_reference'
+require 'archimate/diff/change'
+require 'archimate/diff/conflict'
+require 'archimate/diff/conflicts'
+require 'archimate/diff/delete'
+require 'archimate/diff/insert'
+require 'archimate/diff/merge'
+require 'archimate/diff/move'
+require "archimate/diff/version"
+
+module Archimate
+  module Diff
+    module Cli
+      autoload :ConflictResolver, 'archimate/diff/cli/conflict_resolver'
+      autoload :Diff, 'archimate/diff/cli/diff'
+      autoload :DiffSummary, 'archimate/diff/cli/diff_summary'
+      autoload :Merge, 'archimate/diff/cli/merge'
+      autoload :Merger, 'archimate/diff/cli/merger'
+    end
+  end
+
+  # Computes the set of differences between base and remote models
+  def self.diff(base, remote)
+    base.diff(remote)
+  end
+end

data/lib/archimate/diff/archimate_array_reference.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateArrayReference < ArchimateNodeReference
+      using DataModel::DiffableArray
+      using DataModel::DiffablePrimitive
+
+      attr_reader :array_index
+
+      def initialize(array, array_index)
+        unless array.is_a?(Array)
+          raise(
+            TypeError,
+            "array argument must be an Array, was #{array.class}"
+          )
+        end
+        unless array_index.is_a?(Integer)
+          raise(
+            TypeError,
+            "array_index argument must be a Integer, was #{array_index.class} #{array_index.inspect}"
+          )
+        end
+        unless array_index >= 0 && array_index < array.size
+          raise(
+            ArgumentError,
+            "array_index argument a valid index for array #{array_index.inspect}"
+          )
+        end
+        super(array)
+        @array_index = array_index
+      end
+
+      def value
+        archimate_node[array_index]
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def lookup_in_model(model)
+        result = lookup_parent_in_model(model)
+        raise TypeError, "result was #{result.class} expected Array" unless result.is_a?(Array)
+        result[array_index]
+      end
+
+      def path(options = {})
+        @array_ref_path ||= [
+          super,
+          case value
+          when DataModel::Referenceable
+            value.id
+          else
+            array_index
+          end
+        ].map(&:to_s).reject(&:empty?).join("/")
+      end
+
+      # For inserts - we can't be sure of what is available (without an expensive sort)
+      # So lookup the first previous value that exists in to_model and insert it after that
+      # value instead of a fixed index.
+      def find_insert_index_in_ary(ary)
+        return -1 if array_index.zero?
+        my_idx = (array_index - 1).downto(0).find(-1) do |idx|
+          ary.smart_include?(archimate_node[idx])
+        end
+        ary.smart_find(archimate_node[my_idx])
+      end
+
+      def insert(to_model)
+        ary_in_model = lookup_parent_in_model(to_model)
+        insert_idx = find_insert_index_in_ary(ary_in_model) + 1
+        ary_in_model.insert(insert_idx, value)
+      end
+
+      def delete(to_model)
+        ary_in_model = lookup_parent_in_model(to_model)
+        if ary_in_model.nil?
+          $stderr.puts "lookup parent in model failed for path #{path}"
+          return nil
+        end
+        idx = ary_in_model.smart_find(value)
+        if idx
+          ary_in_model.delete_at(idx)
+        else
+          $stderr.puts "Couldn't find item #{value.inspect} in path #{path} to delete in to_model"
+        end
+      end
+
+      def change(to_model, from_value)
+        ary_in_model = lookup_parent_in_model(to_model)
+        idx = ary_in_model.smart_find(from_value)
+        if idx.nil?
+          $stderr.puts "Couldn't find value #{from_value.inspect} in path #{path} to change in to_model, adding to end of list"
+          idx = ary_in_model.size
+        end
+        ary_in_model[idx] = value
+      end
+
+      def move(to_model, _from_ref)
+        ary_in_model = lookup_parent_in_model(to_model)
+        insert_idx = parent.previous_item_index(ary_in_model, value) + 1
+        current_idx = ary_in_model.smart_find(value)
+        deleted_value = ary_in_model.delete_at(current_idx)
+        ary_in_model.insert(
+          insert_idx,
+          deleted_value
+        )
+      end
+    end
+  end
+end

data/lib/archimate/diff/archimate_identified_node_reference.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateReferenceableReference < ArchimateNodeReference
+      using DataModel::DiffableArray
+
+      def initialize(archimate_node)
+        unless archimate_node.is_a?(DataModel::Referenceable)
+          raise(
+            TypeError,
+            "archimate_node is a #{archimate_node.class}, Referenceable was expected"
+          )
+        end
+        super
+      end
+
+      def lookup_in_model(model)
+        raise TypeError unless model.is_a?(DataModel::Model)
+        # There can be only one Model so return the model argument if
+        # this node reference is a Model. This escape is required in case
+        # the Model this is being applied to has a different id than the
+        # model of the attribute this reference refers to.
+        return model if archimate_node.is_a?(DataModel::Model)
+        model.lookup(archimate_node.id)
+      end
+
+      def to_s
+        archimate_node.to_s
+      end
+
+      def value
+        archimate_node
+      end
+
+      def parent
+        archimate_node.parent
+      end
+    end
+  end
+end

data/lib/archimate/diff/archimate_node_attribute_reference.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateNodeAttributeReference < ArchimateNodeReference
+      attr_reader :attribute
+
+      def initialize(archimate_node, attribute)
+        unless archimate_node.is_a?(DataModel::ArchimateNode)
+          raise(
+            TypeError,
+            "archimate_node must be an ArchimateNode, was #{archimate_node.class}"
+          )
+        end
+        unless attribute.is_a?(Symbol)
+          raise(
+            TypeError,
+            "Node #{archimate_node.class} attribute must be a sym, was a #{attribute.class} value #{attribute.inspect}"
+          )
+        end
+        unless archimate_node.class.schema.keys.include?(attribute)
+          raise(
+            ArgumentError,
+            "Attribute #{attribute} invalid for class #{archimate_node.class}"
+          )
+        end
+        super(archimate_node)
+        @attribute = attribute
+      end
+
+      def ==(other)
+        super && attribute == other.attribute
+      end
+
+      def lookup_in_model(model)
+        recurse_lookup_in_model(archimate_node, model)[attribute]
+      end
+
+      def to_s
+        attribute.to_s
+      end
+
+      def value
+        archimate_node[attribute]
+      end
+
+      def path(options = {})
+        @node_attribute_ref_path ||= [
+          super, @attribute
+        ].map(&:to_s).reject(&:empty?).join("/")
+      end
+
+      def insert(to_model)
+        lookup_parent_in_model(to_model).set(attribute, value)
+      end
+
+      def delete(to_model)
+        lookup_parent_in_model(to_model).delete(attribute)
+      end
+
+      def change(to_model, _from_value)
+        lookup_parent_in_model(to_model).set(attribute, value)
+      end
+
+      def move(_to_model)
+        raise "Move is not valid for ArchimateNodes"
+      end
+    end
+  end
+end

data/lib/archimate/diff/archimate_node_reference.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Diff
+    class ArchimateNodeReference
+      using DataModel::DiffablePrimitive
+      using DataModel::DiffableArray
+
+      attr_reader :archimate_node
+
+      # There should be only a few things that are valid here:
+      # 1. An archimate node and a attribute name sym
+      # 2. An array and index
+      # Produces a NodeReference instance for the given parameters
+      def self.for_node(node, child_node)
+        case node
+        when DataModel::ArchimateNode
+          ArchimateNodeAttributeReference.new(node, child_node)
+        when Array
+          ArchimateArrayReference.new(node, child_node)
+        else
+          raise TypeError, "Node references need to be either an ArchimateNode or an Array"
+        end
+      end
+
+      def initialize(archimate_node)
+        unless archimate_node.is_a?(DataModel::ArchimateNode) || archimate_node.is_a?(Array)
+          raise(
+            TypeError,
+            "archimate_node must be an ArchimateNode or Array, was #{archimate_node.class}"
+          )
+        end
+        raise "new WTF? parent at path #{archimate_node.path} is a #{archimate_node.class} but isn't assigned a model" if archimate_node.in_model.nil? && !archimate_node.is_a?(DataModel::Model)
+        @archimate_node = archimate_node
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          value == other.value
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def lookup_in_model(model)
+        recurse_lookup_in_model(archimate_node, model)
+      end
+
+      def recurse_lookup_in_model(node, model)
+        return nil if node.nil?
+        raise TypeError, "node argument must be ArchimateNode or Array, was a #{node.class}" unless node.is_a?(Array) || node.is_a?(DataModel::ArchimateNode)
+        raise TypeError, "model argument must be a Model, was a #{model.class}" unless model.is_a?(DataModel::Model)
+        if node.is_a?(DataModel::Model)
+          return model
+        elsif node.is_a?(DataModel::Referenceable)
+          return model.lookup(node.id)
+        else
+          node_parent_in_model = recurse_lookup_in_model(node.parent, model)
+          node_parent_in_model[node.parent_attribute_name] unless node_parent_in_model.nil?
+        end
+      end
+
+      def lookup_parent_in_model(model)
+        raise "WTF? parent at path #{path} is a #{parent.class} but isn't assigned a model" if parent.in_model.nil? && !parent.is_a?(DataModel::Model)
+        result = recurse_lookup_in_model(parent, model)
+        $stderr.puts "Unable to lookup parent with path #{path}" if result.nil?
+        result
+      end
+
+      def parent
+        archimate_node
+      end
+
+      def path(options = {})
+        @node_ref_path ||= archimate_node.path(options)
+      end
+    end
+  end
+end

data/lib/archimate/diff/change.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Change < Difference
+      using DataModel::DiffableArray
+
+      # Create a new Change difference
+      #
+      # @param target [Archimate::Diff::ArchimateNodeReference] reference to
+      #   ArchimateNode that was changed
+      # @param changed_from [Archimate::Diff::ArchimateNodeReference] Element
+      #   that was changed
+      def initialize(target, changed_from)
+        super(target, changed_from)
+      end
+
+      def to_s
+        # Note - the explicit to_s is required to access the DiffableArray
+        #        implementation if the parent is an Array.
+        "#{diff_type} #{changed_from.parent&.to_s} #{Color.color(target.to_s, :change)} changed to #{target.value}"
+      end
+
+      def apply(to_model)
+        unless to_model.is_a?(DataModel::Model)
+          throw(
+            TypeError,
+            "Expected a Archimate::DataModel::Model, was a #{to_model.class}"
+          )
+        end
+        target.change(to_model, changed_from.value)
+        to_model
+      end
+
+      def change?
+        true
+      end
+
+      def kind
+        "Change"
+      end
+
+      private
+
+      def diff_type
+        Color.color('CHANGE:', :change)
+      end
+    end
+  end
+end