archimate 1.1.1 → 1.2.1

data/lib/archimate/cli/merge.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "parallel"
-
-module Archimate
-  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

data/lib/archimate/cli/merger.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Archimate
-  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

data/lib/archimate/diff.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-module Archimate
-  module Diff
-    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'
-  end
-end

data/lib/archimate/diff/archimate_array_reference.rb

@@ -1,113 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,70 +0,0 @@
-# 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

@@ -1,80 +0,0 @@
-# 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