archimate 1.1.0

data/lib/archimate/diff/conflicts/path_conflict.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Conflicts
+      class PathConflict < BaseConflict
+        def initialize(base_local_diffs, base_remote_diffs)
+          super
+          @associative = true
+        end
+
+        def describe
+          "Checking for Differences in one change set that conflict with changes in other change set at the same path"
+        end
+
+        def diff_conflicts(diff1, diff2)
+          same_path_but_diff(diff1, diff2) && in_conflict?(diff1, diff2)
+        end
+
+        private
+
+        def same_path_but_diff(a, b)
+          a.path == b.path && a != b
+        end
+
+        # I'm in conflict if:
+        # 1. ld and rd are both changes to the same path (but not the same change)
+        # 2. one is a change, the other a delete and changed_from is the same
+        # 3. both are inserts of the different identifyable nodes with the same id
+        #
+        # If I'm not an identifyable node and my parent is an array, then two inserts are ok
+        def in_conflict?(local_diff, remote_diff)
+          return true if
+            local_diff.target.parent.is_a?(Array) &&
+            local_diff.target.value.is_a?(DataModel::Referenceable) &&
+            local_diff.target.value.id == remote_diff.target.value.id &&
+            local_diff != remote_diff
+
+          case [local_diff, remote_diff].map { |d| d.class.name.split('::').last }.sort
+          when %w(Change Change)
+            local_diff.changed_from.value == remote_diff.changed_from.value &&
+              local_diff.target.value != remote_diff.target.value
+          when %w(Change Delete)
+            true
+          else
+            false
+          end
+        end
+      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

data/lib/archimate/diff/delete.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Delete < Difference
+      using DataModel::DiffablePrimitive
+      using DataModel::DiffableArray
+
+      # Create a new Delete difference
+      #
+      # @param target [ArchimateNodeReference] Element that was deleted
+      def initialize(target)
+        super
+      end
+
+      def to_s
+        # Note - the explicit to_s is required to access the DiffableArray
+        #        implementation if the parent is an Array.
+        "#{diff_type} #{target} from #{target.parent.to_s}"
+      end
+
+      def apply(el)
+        target.delete(el)
+        el
+      end
+
+      def delete?
+        true
+      end
+
+      def kind
+        "Delete"
+      end
+
+      private
+
+      def diff_type
+        Color.color('DELETE:', :delete)
+      end
+    end
+  end
+end

data/lib/archimate/diff/difference.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Archimate
+  module Diff
+    class Difference
+      using DataModel::DiffableArray
+      using DataModel::DiffablePrimitive
+      extend Forwardable
+
+      ARRAY_RE = Regexp.compile(/\[(\d+)\]/)
+      PATH_ROOT_SORT_ORDER = %w[elements relationships diagrams organizations].freeze
+
+      # delete: something responds to parent, child attribute (which is thing deleted - and could be sym for archimate nodes or index for array), value
+      # insert: something responds to parent, child attribute (or index), value, after value (to help with inserts)
+      # change: something responds to parent, child attribute (or index), value, changed from value
+      # move: something responds to parent, child index, value, after value) move after a particular value
+      attr_reader :target
+      attr_reader :changed_from
+
+      def_delegator :@target, :path
+
+      # Re-thinking.
+      #
+      # Requirements:
+      #
+      # 1. User friendly display of what is different in context
+      # 2. Able to apply the diff to another model (which was based on the "base" of the diff)
+      #
+      # Delete:                         example
+      #   ArchimateNode                 child.bounds
+      #   ArchimateNode, attribute      model, "name"
+      #   DiffableArray, ArchimateNode  model.elements, element
+      #   bendpoint attributes under connection
+      #                                 documentation
+      #                                 properties
+      #                                 child/style/fill_color
+      #                                 child/style/font/name
+      #
+      # @param target [Dry::Struct with id attribute] the element operated on (why is array treated as a special case?)
+      # @param changed_from [same class as target] (optional) for change this is the previous value
+      # def initialize(changed_from, target)
+      def initialize(target, changed_from = nil)
+        # raise TypeError, "Expected target to be an ArchimateNodeReference" unless target.is_a?(ArchimateNodeReference)
+        @target = target
+        @changed_from = changed_from
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          @target == other.target &&
+          @changed_from == other.changed_from
+      end
+
+      # Difference sorting is based on the path.
+      # Top level components are sorted in this order: (elements, relationships, diagrams, organizations)
+      # Array entries are sorted by numeric order
+      # Others are sorted alphabetically
+      # TODO: this isn't complete
+      def <=>(other)
+        a = path_to_array
+        b = other.path_to_array
+
+        part_a = a.shift
+        part_b = b.shift
+        res = PATH_ROOT_SORT_ORDER.index(part_a) <=> PATH_ROOT_SORT_ORDER.index(part_b)
+        return res unless res.zero?
+
+        until a.empty? || b.empty?
+          part_a = a.shift
+          part_b = b.shift
+
+          return part_a <=> part_b unless (part_a <=> part_b).zero?
+        end
+
+        return -1 if a.empty?
+        return 1 if b.empty?
+        part_a <=> part_b
+      end
+
+      def delete?
+        false
+      end
+
+      def change?
+        false
+      end
+
+      def insert?
+        false
+      end
+
+      def move?
+        false
+      end
+
+      def path_to_array
+        path(force_array_index: :index).split("/").map do |p|
+          md = ARRAY_RE.match(p)
+          md ? md[1].to_i : p
+        end
+      end
+
+      def summary_element
+        summary_elements = [DataModel::Element, DataModel::Organization, DataModel::Relationship, DataModel::Diagram, DataModel::Model]
+        se = target.value.primitive? ? target.parent : target.value
+        se = se.parent while summary_elements.none? { |c| se.is_a?(c) }
+        se
+      end
+    end
+  end
+end

data/lib/archimate/diff/insert.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Insert < Difference
+      using DataModel::DiffableArray
+
+      # Create a new Insert difference
+      #
+      # @param inserted_element [Archimate::DataModel::ArchimateNode] Element
+      #   that was inserted
+      # @param sub_path [str] Path under inserted_element for primitive values
+      def initialize(target)
+        super
+      end
+
+      def to_s
+        # Note - the explicit to_s is required to access the DiffableArray
+        #        implementation if the parent is an Array.
+        "#{diff_type} #{target} into #{target.parent.to_s}"
+      end
+
+      def apply(to_model)
+        throw TypeError, "Expected a Archimate::DataModel::Model, was a #{to_model.class}" unless to_model.is_a?(DataModel::Model)
+        target.insert(to_model)
+        to_model
+      end
+
+      def insert?
+        true
+      end
+
+      def kind
+        "Insert"
+      end
+
+      private
+
+      def diff_type
+        Color.color('INSERT:', :insert)
+      end
+    end
+  end
+end

data/lib/archimate/diff/merge.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "parallel"
+
+module Archimate
+  module Diff
+    class Merge
+      include Archimate::Logging
+      using DataModel::DiffableArray
+
+      def three_way(base, local, remote)
+        debug { "Computing base:local & base:remote diffs" }
+        base_local_diffs, base_remote_diffs = Parallel.map([[base, local], [base, remote]],
+          in_processes: 2) do |base_model, other_model|
+          base_model.diff(other_model)
+        end
+
+        debug "Finding Conflicts in #{base_local_diffs.size + base_remote_diffs.size} diffs"
+        conflicts = Conflicts.new(base_local_diffs, base_remote_diffs)
+        resolved_diffs = conflicts.resolve
+
+        [apply_diffs(resolved_diffs, base.clone), conflicts]
+      end
+
+      # Applies the set of diffs to the model returning a
+      # new model with the diffs applied.
+      def apply_diffs(diffs, model)
+        debug { "Applying #{diffs.size} diffs" }
+        progressbar = ProgressIndicator.new(total: diffs.size, title: "Applying diffs")
+        diffs
+          .inject(model) do |model_a, diff|
+            progressbar.increment
+            diff.apply(model_a)
+          end
+          .rebuild_index
+          .organize
+      ensure
+        progressbar&.finish
+      end
+
+      # # TODO: not currently used
+      # def find_merged_duplicates
+      #   [@base_local_diffs, @base_remote_diffs].map do |diffs|
+      #     deleted_element_diffs = diffs.select(&:delete?).select(&:element?)
+      #     deleted_element_diffs.each_with_object({}) do |diff, a|
+      #       element = diff.from_model.elements[diff.element_idx]
+      #       found = diff.from_model.elements.select do |el|
+      #         el != element && el.type == element.type && el.name == element.name
+      #       end
+      #       next if found.empty?
+      #       a[diff] = found
+      #       debug { "\nFound potential de-duplication:" }
+      #       debug { "\t#{diff}" }
+      #       debug { "Might be replaced with:\n\t#{found.map(&:to_s).join(" }\n\t")}\n\n"
+      #     end
+      #   end
+      # end
+
+      # # TODO: not currently used
+      # def filter_path_conflicts(diffs)
+      #   diffs.sort { |a, b| a.path_to_array.size <=> b.path_to_array.size }.each_with_object([]) do |i, e|
+      #     diffs.delete(i)
+      #     path_conflicts = diffs.select { |d| d.path.start_with?(i.path) }
+      #     path_conflicts.each { |d| diffs.delete(d) }
+      #     e << i
+      #   end
+      # end
+    end
+  end
+end

data/lib/archimate/diff/move.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Archimate
+  module Diff
+    class Move < Difference
+      using DataModel::DiffablePrimitive
+      using DataModel::DiffableArray
+
+      # Create a new Move 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)} moved to #{target.array_index}"
+      end
+
+      # TODO: patch is a better name than apply
+      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.move(to_model, changed_from)
+        to_model
+      end
+
+      def move?
+        true
+      end
+
+      def kind
+        "Move"
+      end
+
+      private
+
+      def diff_type
+        Color.color('MOVE:', :move)
+      end
+    end
+  end
+end

data/lib/archimate/diff.rb

@@ -0,0 +1,17 @@
+# 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/export/csv_export.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require "csv"
+
+# This module takes an ArchiMate model and builds a set of CSV files representing it.
+module Archimate
+  module Export
+    class CSVExport
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def to_csv(output_dir: ".")
+        (model.relationships + model.elements)
+          .group_by(&:type).each do |type, elements|
+          CSV.open(
+            File.join(output_dir, "#{type}.csv"),
+            "wb",
+            force_quotes: true
+          ) do |csv|
+            headers = elements.first.struct_instance_variables
+            csv << headers.map(&:to_s)
+            elements.each do |element|
+              csv << headers.map { |attr| element[attr] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/export/cypher.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# This module takes an ArchiMate model and builds GraphML representation of it.
+#
+# Node Schema:
+#   Properties:
+#     name: Element.name
+#     nodelId: Element.id
+#     layer: Element.layer
+#     documentation: Element.documentation
+#     Element.properties
+#      ("prop:#{Property.key}"): Property.value
+#   Labels:
+#     Element.type
+#
+# Edge Schema:
+#   Properties:
+#     weight (of Relationship Type as in table below)
+#     relationshipId: Relationship.id
+#     name: Relationship.name
+#     documentation: Relationship.documentation
+#     accessType: Relationship.access_type
+#   Labels:
+#     Relationship.type
+#
+# | Weight | Name           |
+# |--------+----------------|
+# |      1 | Association    |
+# |      2 | Access         |
+# |      3 | Used by        |
+# |      4 | Realization    |
+# |      5 | Assignment     |
+# |      6 | Aggregation    |
+# |      7 | Composition    |
+# |      8 | Flow           |
+# |      9 | Triggering     |
+# |     10 | Grouping       |
+# |     11 | Junction       |
+# |     12 | Specialization |
+# Structural stronger than Dependency Relationships
+# ServingRelationship == UsedByRelationship
+
+
+module Archimate
+  module Export
+    class Cypher
+      attr_reader :output_io
+
+      WEIGHTS = {
+        'GroupingRelationship' => 0,
+        'JunctionRelationship' => 0,
+        'AssociationRelationship' => 0,
+        'SpecialisationRelationship' => 1,
+        'FlowRelationship' => 2,
+        'TriggeringRelationship' => 3,
+        'InfluenceRelationship' => 4,
+        'AccessRelationship' => 5,
+        'UsedByRelationship' => 6,
+        'RealisationRelationship' => 7,
+        'AssignmentRelationship' => 8,
+        'AggregationRelationship' => 9,
+        'CompositionRelationship' => 10
+      }
+
+      def initialize(output_io)
+        @output_io = output_io
+      end
+
+      def to_cypher(model)
+        write_cypher_header(model)
+        write_nodes(model.elements)
+        create_indexes(model.elements)
+        write_relationships(model.relationships)
+        # TODO: write properties
+      end
+
+      def write_cypher_header(model)
+        write "// Cypher import script of ArchiMate model #{model.name}. Produced #{DateTime.now}\n"
+      end
+
+      def write_nodes(elements)
+        write "\n// Nodes\n"
+        elements.each do |element|
+          props = add_docs(
+            {
+              layer: element.layer.delete(" "),
+              name: element.name,
+              nodeId: element.id
+            }.merge(
+              element.properties.each_with_object({}) do |prop, memo|
+                memo["prop:#{prop.key}"] = prop.value unless prop.value.nil?
+              end
+            ), element.documentation
+          )
+
+          write(
+            node(
+              element.type,
+              props
+            )
+          )
+        end
+      end
+
+      def create_indexes(elements)
+        write "\n// Indexes\n"
+        elements.map(&:type).uniq.each do |label|
+          write "CREATE INDEX ON :#{label}(name);"
+          write "CREATE INDEX ON :#{label}(nodeId);"
+        end
+      end
+
+      def write_relationships(relationships)
+        write "\n// Relationships\n"
+        relationships.each do |rel|
+          write relationship(rel)
+        end
+      end
+
+      private
+
+      def node(label, properties = {})
+        "CREATE (n:#{label} #{props(properties)});"
+      end
+
+      def relationship(rel)
+        "MATCH #{source(rel)},#{target(rel)} " \
+        "CREATE (s)-#{relationship_def(rel)}->(t);"
+      end
+
+      def props(properties)
+        "{ #{properties.reject { |_k, v| v.nil? }.map { |k, v| "`#{k}`: #{v.inspect}" }.join(', ')} }"
+      end
+
+      def source(rel)
+        "(s #{props(nodeId: rel.source)})"
+      end
+
+      def weight(t)
+        return 0 unless WEIGHTS.include?(t)
+        WEIGHTS[t]
+      end
+
+      def add_docs(h, l)
+        t = l.map(&:text).join("\n").strip
+        return h if t.empty?
+        h.merge(documentation: t)
+      end
+
+      def relationship_def(rel)
+        h = add_docs(
+          {
+            name: rel.name,
+            relationshipId: rel.id,
+            accessType: rel.access_type,
+            weight: weight(rel.type)
+          }, rel.documentation
+        )
+        "[r:#{rel.type} #{props(h)}]"
+      end
+
+      def target(rel)
+        "(t #{props(nodeId: rel.target)})"
+      end
+
+      def write(str)
+        @output_io.puts(str)
+      end
+    end
+  end
+end