archimate 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b8d5f63a78b5e98d3791d8d58ea7474ad874325
-  data.tar.gz: 3cfc66538c6cbaf0792e96ca208712deff1ea194
+  metadata.gz: 37d66a474e8d614dd2ccbbf746511e3c4b769ef7
+  data.tar.gz: 50e1139f2d69beb50da6e702bd0e20d226f615fa
 SHA512:
-  metadata.gz: fe459d02990c355cd440e1460ec8bfac1019a6c3984918d4ee5ea53e9cb8709fd16bcfdf3f29ea3de5b7dbfaca01459143ec6de1294a9d402137e59fafcef1f2
-  data.tar.gz: 1d91a6c7e3cf0f0e0d7aaba0ba1068f0b74c5d08eca30d9e7541e5f15c066b237552eaab001bfa0cc6510459b07d754036bdd18825016213cd55ceca331d10d9
+  metadata.gz: e406c34a0b01b3f839f2ff8e9a688e7a5222ed02203bb0db45fdb03a71f6db5a9d8f9b9c575fa661ae3ce12ed8c7448cc340acea05c042097418eab8bffc498b
+  data.tar.gz: 64c3e07d73f2b053c790fb37a3d8f32129f35da594a03fc4a7fe4b6cb66ed15e4e27d1ef83fcd4d5b0e66bd4ce56962aa82bc567717ddaef4878d52eac109d84

data/.gitignore

@@ -12,6 +12,7 @@
 /tmp/
 /vendor/
 .DS_Store
+*.bak
 *.tags
 tags
 .srclib-cache/

data/archimate.gemspec

@@ -27,7 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "ruby-progressbar", "~>1.8.1"
   spec.add_runtime_dependency "parallel", "~> 1.11"
   spec.add_runtime_dependency "ruby-enum", "~> 0.7.1"
-  # spec.add_runtime_dependency "diff-lcs", "~> 1.3"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/lib/archimate.rb

@@ -66,12 +66,13 @@ module Archimate
   autoload :FileFormat, 'archimate/file_format'
   autoload :MaybeIO, 'archimate/maybe_io'
   autoload :ProgressIndicator, 'archimate/progress_indicator'
+  autoload :DerivedRelations, 'archimate/derived_relations'
 
   require "archimate/version"
   require "archimate/config"
   require "archimate/logging"
   require "archimate/color"
-  require 'archimate/data_model'
+  require "archimate/data_model"
 
   # Reads the given file and returns the Archimate model
   #

data/lib/archimate/data_model/element.rb

@@ -52,6 +52,7 @@ module Archimate
       end
 
       # Diagrams that this element is referenced in.
+      # @todo this implementation is broken - in_model no longer exists
       def diagrams
         @diagrams ||= in_model.diagrams.select do |diagram|
           diagram.element_ids.include?(id)
@@ -59,6 +60,7 @@ module Archimate
       end
 
       # Relationships that this element is referenced in.
+      # @todo this implementation is broken - in_model no longer exists
       def relationships
         @relationships ||= in_model.relationships.select do |relationship|
           relationship.source == id || relationship.target == id
@@ -70,6 +72,7 @@ module Archimate
       #     2. Child `documentation` (and different `xml:lang` attribute values)
       #     3. Child `properties`
       #     4. Any other elements
+      # @todo this implementation is broken - in_model no longer exists
       def merge(element)
         super
         element.diagrams.each { |diagram| diagram.replace(element, self) }

data/lib/archimate/data_model/model.rb

@@ -170,6 +170,12 @@ module Archimate
       #   end
       # end
 
+      def make_unique_id
+        unique_id = random_id
+        unique_id = random_id while @index_hash.key?(unique_id)
+        unique_id
+      end
+
       private
 
       # Only used by [#find_default_organization]
@@ -261,12 +267,6 @@ module Archimate
         ref
       end
 
-      def make_unique_id
-        unique_id = random_id
-        unique_id = random_id while @index_hash.key?(unique_id)
-        unique_id
-      end
-
       def random_id
         @random ||= Random.new
         format("%08x", @random.rand(0xffffffff))

data/lib/archimate/data_model/relationship.rb

@@ -11,6 +11,26 @@ module Archimate
     # by having a tag name of "relationship" and an attribute of xsi:type="AccessRelationship" where AccessRelationship is
     # a derived type from RelationshipType.
     class Relationship
+      # @todo: this should be removed once concrete Relationships are used.
+      # @deprecated
+      WEIGHTS = {
+        'GroupingRelationship' => 0,
+        'JunctionRelationship' => 0,
+        'AssociationRelationship' => 0,
+        'SpecialisationRelationship' => 1,
+        'FlowRelationship' => 2,
+        'TriggeringRelationship' => 3,
+        'InfluenceRelationship' => 4,
+        'AccessRelationship' => 5,
+        'ServingRelationship' => 6,
+        'UsedByRelationship' => 6,
+        'RealizationRelationship' => 7,
+        'RealisationRelationship' => 7,
+        'AssignmentRelationship' => 8,
+        'AggregationRelationship' => 9,
+        'CompositionRelationship' => 10
+      }
+
       include Comparison
 
       # @!attribute [r] id
@@ -44,9 +64,13 @@ module Archimate
       # @!attribute [r] access_type
       #   @return [AccessTypeEnum, NilClass]
       model_attr :access_type
+      # @!attribute [r] derived
+      #   @return [Boolean] this is a derived relation if true
+      model_attr :derived
 
       def initialize(id:, name: nil, documentation: nil, type: nil,
-                     properties: [], source:, target:, access_type: nil)
+                     properties: [], source:, target:, access_type: nil,
+                     derived: false)
         @id = id
         @name = name
         @documentation = documentation
@@ -55,6 +79,7 @@ module Archimate
         @source = source
         @target = target
         @access_type = access_type
+        @derived = derived
       end
 
       def replace(entity, with_entity)
@@ -99,6 +124,90 @@ module Archimate
         super
         access_type ||= relationship.access_type
       end
+
+      def weight
+        WEIGHTS.fetch(type, 0)
+      end
+    end
+
+    # Relationship Classifications: Structural, Dynamic, Dependency, Other
+    # •  No relationships are allowed between two relationships
+    # •  All relationships connected with relationship connectors must be of
+    #    the same type
+    # •  A chain of relationships of the same type that connects two elements,
+    #    and is in turn connected via relationship connectors, is valid only if
+    #    a direct relationship of that same type between those two elements is
+    #    valid
+    # •  A relationship connecting an element with a second relationship can
+    #    only be an aggregation, composition, or association; aggregation or
+    #    composition are valid only from a composite element to that second
+    #    relationship
+    #
+    # Aggregation, composition, and specialization relationships are always
+    # permitted between two elements of the same type, and association is
+    # always allowed between any two elements, and between any element and
+    # relationship.
+
+    class Composition < Relationship
+      CLASSIFICATION = :structural
+      WEIGHT = 10
+    end
+
+    class Aggregation < Relationship
+      CLASSIFICATION = :structural
+      WEIGHT = 9
+    end
+
+    class Assignment < Relationship
+      CLASSIFICATION = :structural
+      WEIGHT = 8
+    end
+
+    class Realization < Relationship
+      CLASSIFICATION = :structural
+      WEIGHT = 7
+    end
+
+    class Serving < Relationship
+      CLASSIFICATION = :dependency
+      WEIGHT = 6
+    end
+
+    class Access < Relationship
+      CLASSIFICATION = :dependency
+      WEIGHT = 5
+    end
+
+    class Influence < Relationship
+      CLASSIFICATION = :dependency
+      WEIGHT = 4
+    end
+
+    class Triggering < Relationship
+      CLASSIFICATION = :dynamic
+      WEIGHT = 3
+    end
+
+    class Flow < Relationship
+      CLASSIFICATION = :dynamic
+      WEIGHT = 2
+    end
+
+    class Specialization < Relationship
+      CLASSIFICATION = :other
+      WEIGHT = 1
+    end
+
+    class Association < Relationship
+      CLASSIFICATION = :other
+      WEIGHT = 0
+    end
+
+    # Junction is a relationship connector
+    # •  All relationships connected with relationship connectors must be of the same type
+    class Junction < Relationship
+      CLASSIFICATION = :other
+      WEIGHT = 0
     end
   end
 end

data/lib/archimate/data_model/relationship_type.rb

@@ -12,6 +12,7 @@ module Archimate
       "FlowRelationship" => "flows to",
       "InfluenceRelationship" => "influenecs",
       "RealisationRelationship" => "realizes",
+      "RealizationRelationship" => "realizes",
       "SpecialisationRelationship" => "specializes",
       "TriggeringRelationship" => "triggers",
       "UsedByRelationship" => "is used by"
@@ -28,6 +29,7 @@ module Archimate
       define :FlowRelationship, "FlowRelationship"
       define :InfluenceRelationship, "InfluenceRelationship"
       define :RealisationRelationship, "RealisationRelationship"
+      define :RealizationRelationship, "RealizationRelationship"
       define :SpecialisationRelationship, "SpecialisationRelationship"
       define :SpecializationRelationship, "SpecializationRelationship"
       define :TriggeringRelationship, "TriggeringRelationship"

data/lib/archimate/derived_relations.rb

@@ -0,0 +1,95 @@
+module Archimate
+  class DerivedRelations
+    PASS_ALL = lambda { |_item| true }
+    FAIL_ALL = lambda { |_item| false }
+
+    def initialize(model)
+      @model = model
+    end
+
+    # This returns a set of derived relationships in this model between the
+    # elements in the `start_elements` argument, including relationships that
+    # pass the `relationship_filter` recursively until either a target_filter
+    # is matched and/or the stop_filter is matched.
+    #
+    # TODO: Rules for derived relations
+    #
+    # Assumptions:
+    #
+    # 1. If an existing relation exists for found "derived" relation, it shouldn't
+    #    be included in the results.
+    # 2. Any path of length 1 inherently identifies an instance of #1 so they can
+    #    be skipped.
+    #
+    # @param start_elements [Array<Element>] collection of starting nodes
+    # @param relationship_filter [Boolean, lambda(Relationship) => Boolean]
+    #        filter for the kinds of relationships to follow.
+    # @param target_filter [lambda(Element) => Boolean] if true, then a derived
+    #        relationship is added to the results
+    # @param stop_filter [lambda(Element) => Boolean] if true, then relationships
+    #        below this element are not followed
+    def derived_relations(start_elements, relationship_filter, target_filter, stop_filter = FAIL_ALL)
+      traverse(start_elements, relationship_filter, stop_filter)
+        .reject { |path| Array(path).size <= 1 } # See #2 above
+        .select { |path| target_filter.call(path.last.target) }
+        .map { |path|
+          DataModel::Relationship.new(
+            id: @model.make_unique_id,
+            type: derived_relationship_type(path),
+            source: path.first.source,
+            target: path.last.target,
+            derived: true
+          )
+        }
+        .uniq { |rel| [rel.type, rel.source, rel.target] }
+    end
+
+    def derived_relationship_type(path)
+      DataModel::Relationship::WEIGHTS.rassoc(
+        path
+          .map(&:weight)
+          .min
+      ).first
+    end
+
+    # traverse returns an Array of paths (Array<Relationship>)
+    # between each of the start elements and elements that pass the
+    # relation_filter.
+    #
+    # @param start_elements [Array<Element>] initial elements to start the
+    #        model traversal
+    # @param relation_filter [Proc(Relationship) => Boolean] only relationships
+    #        that pass the relation_filter will be followed
+    # @param stop_filter [Proc(Element) => Boolean] the traversal will not
+    #        proceed further than relationship targets that the stop_filter
+    #        returns true for.
+    def traverse(start_elements, relation_filter, stop_filter, from_path = [])
+      return [] if from_path.size > 100
+      start_elements.each_with_object([]) do |el, result|
+        immediate_rels = element_relationships(el)
+          .select(&relation_filter)
+          .reject { |rel| from_path.include?(rel) }
+
+        result.concat(immediate_rels)
+        result.concat(
+          *immediate_rels
+            .reject { |rel| rel.target.nil? || (stop_filter && stop_filter.call(rel)) }
+            .map { |rel|
+              traverse([rel.target], relation_filter, stop_filter, from_path + [rel])
+                .map { |path| Array(path).unshift(rel) }
+            }
+        )
+      end
+    end
+
+    def element_by_name(name)
+      @model.elements.find { |el| el.name.to_s == name.to_s }
+    end
+
+    def element_relationships(el)
+      @model
+        .relationships
+        .select { |rel| rel.source.id == el.id }
+    end
+  end
+end

data/lib/archimate/export/cypher.rb

@@ -46,22 +46,6 @@ module Archimate
     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
@@ -136,11 +120,6 @@ module Archimate
         "(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?
@@ -153,7 +132,7 @@ module Archimate
             name: rel.name.to_s,
             relationshipId: rel.id,
             accessType: rel.access_type,
-            weight: weight(rel.type)
+            weight: rel.weight
           }, rel.documentation
         )
         "[r:#{rel.type} #{props(h)}]"

data/lib/archimate/export/n_quads.rb

@@ -115,6 +115,7 @@ module Archimate
         "UsedByRelationship" => %w(used_by uses),
         "ServingRelationship" => %w(serving served_by),
         "RealisationRelationship" => %w(realizes realized_by),
+        "RealizationRelationship" => %w(realizes realized_by),
         "AssignmentRelationship" => %w(assigned_to assigned_from),
         "AggregationRelationship" => %w(aggregates aggregated_by),
         "CompositionRelationship" => %w(composes composed_by),

data/lib/archimate/file_formats/sax/archi/connection.rb

@@ -32,7 +32,7 @@ module Archimate
               event(:on_referenceable, connection),
               event(:on_future, Sax::FutureReference.new(connection, :source, @attrs["source"])),
               event(:on_future, Sax::FutureReference.new(connection, :target, @attrs["target"])),
-              event(:on_future, Sax::FutureReference.new(connection, :relationship, @attrs["relationship"]))
+              event(:on_future, Sax::FutureReference.new(connection, :relationship, @attrs["relationship"] || @attrs["archimateRelationship"]))
             ]
           end
 

data/lib/archimate/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Archimate
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: archimate
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Mark Morga
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-19 00:00:00.000000000 Z
+date: 2017-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -445,7 +445,6 @@ files:
 - lib/archimate/data_model/property.rb
 - lib/archimate/data_model/property_definition.rb
 - lib/archimate/data_model/referenceable.rb
-- lib/archimate/data_model/referenceable_collection.rb
 - lib/archimate/data_model/relationship.rb
 - lib/archimate/data_model/relationship_type.rb
 - lib/archimate/data_model/schema_info.rb
@@ -453,6 +452,7 @@ files:
 - lib/archimate/data_model/view_node.rb
 - lib/archimate/data_model/viewpoint.rb
 - lib/archimate/data_model/viewpoint_type.rb
+- lib/archimate/derived_relations.rb
 - lib/archimate/export/csv_export.rb
 - lib/archimate/export/cypher.rb
 - lib/archimate/export/graph_ml.rb

data/lib/archimate/data_model/referenceable_collection.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-module Archimate
-  module DataModel
-    # This class represents a collection of referenceable objects (i.e. have an `id`)
-    class ReferenceableCollection
-      attr_writer :parent_attribute_name
-
-      def in_model
-        @in_model if defined?(@in_model)
-      end
-
-      def parent
-        @parent if defined?(@parent)
-      end
-
-      def id
-        object_id.to_s
-      end
-
-      def primitive?
-        false
-      end
-
-      def diff(other)
-        raise TypeError, "Expected other #{other.class} to be of type #{self.class}" unless other.is_a?(self.class)
-        raise "Well Hell other #{other.path} in_model is nil" if other.in_model.nil?
-        raise "Well Hell my path `#{path}` in_model is nil" if in_model.nil?
-
-        result = []
-        remaining_content = Array.new(self) # @todo I want a copy of the array, not a deep clone
-        other_enum = other.each_with_index
-
-        loop do
-          if other_enum.peek[0] == remaining_content[0]
-            other_enum.next
-            remaining_content.shift
-          elsif items_are_changed?(other, other_enum, remaining_content)
-            result.concat(compute_item_changes(other, other_enum, self, remaining_content[0]))
-            remaining_content.shift
-            other_enum.next
-          elsif !remaining_content.empty? && !other.smart_include?(remaining_content[0])
-            result << Diff::Delete.new(Diff::ArchimateArrayReference.new(self, smart_find(remaining_content[0])))
-            remaining_content.shift
-          elsif !smart_include?(other_enum.peek[0])
-            result << Diff::Insert.new(Diff::ArchimateArrayReference.new(other, other_enum.next[1]))
-          elsif smart_include?(other_enum.peek[0])
-            result << Diff::Move.new(
-              Diff::ArchimateArrayReference.new(other, other_enum.peek[1]),
-              Diff::ArchimateArrayReference.new(self, smart_find(other_enum.peek[0]))
-            )
-            remaining_item_idx = remaining_content.smart_find(other_enum.peek[0])
-            if remaining_item_idx
-              result.concat(compute_item_changes(other, other_enum, self, remaining_content[remaining_item_idx]))
-              remaining_content.delete_at(remaining_item_idx) if remaining_content.smart_include?(other_enum.peek[0])
-            end
-            other_enum.next
-          else
-            raise "Unhandled diff case for remaining_content: #{remaining_content[0]} and #{other_enum.peek[0]}"
-          end
-        end
-
-        result.concat(
-          remaining_content
-            .reject { |item| other.include?(item) }
-            .map do |item|
-              Diff::Delete.new(Diff::ArchimateArrayReference.new(self, find_index(item)))
-            end
-        )
-      end
-
-      # @todo This may not continue to live here. Only used by testing.
-      def patch(diffs)
-        # @todo Beware, order of diffs could break patching at the moment.
-        Array(diffs).each do |diff|
-          case diff
-          when Diff::Delete
-            delete_at(smart_find(diff.target.value))
-          when Diff::Insert
-            insert(diff.target.array_index, diff.target.value)
-          when Diff::Change
-            self[smart_find(diff.changed_from.value)] = diff.target.value
-          when Diff::Move
-            insert(diff.target.array_index, delete_at(smart_find(diff.target.value)))
-          else
-            raise "Unexpected diff type: #{diff.class}"
-          end
-        end
-        self
-      end
-
-      def items_are_changed?(other, other_enum, remaining)
-        !remaining.empty? &&
-          case remaining[0]
-          when DataModel::Referenceable
-            remaining[0].id == other_enum.peek[0].id
-          when String, DataModel::ArchimateNode
-            !other.include?(remaining[0]) && !include?(other_enum.peek[0])
-          else
-            raise "Unhandled type for #{remaining[0].class}"
-          end
-      end
-
-      def compute_item_changes(other, other_enum, _myself, my_item)
-        case my_item
-        when DataModel::ArchimateNode
-          my_item.diff(other_enum.peek[0])
-        else
-          my_item.diff(other_enum.peek[0], self, other, other_enum.peek[1], find_index(my_item))
-        end
-      end
-
-      def in_model=(model)
-        puts "#{self.inspect} is frozen" if self.frozen?
-        @in_model = model
-        each { |item| item.in_model = model }
-      end
-
-      def parent=(par)
-        @parent = par
-        each { |i| i.parent = self }
-      end
-
-      def parent_attribute_name
-        @parent_attribute_name if defined?(@parent_attribute_name)
-      end
-
-      def build_index(hash_index = {})
-        reduce(hash_index) { |hi, array_item| array_item.build_index(hi) }
-      end
-
-      def path(options = {})
-        [
-          parent&.path(options),
-          parent_attribute_name
-        ].compact.reject(&:empty?).join("/")
-      end
-
-      def clone
-        map(&:clone)
-      end
-
-      def dup
-        map(&:dup)
-      end
-
-      def to_s
-        "#{parent}/#{parent_attribute_name}"
-      end
-
-      def referenced_identified_nodes
-        reduce([]) do |a, e|
-          a.concat(e.referenced_identified_nodes)
-        end
-      end
-
-      def find_by_id(an_id)
-        find { |el| el.id == an_id }
-      end
-
-      def smart_find(val = nil)
-        case val
-        when Referenceable
-          lazy.map(&:id).find_index(val.id)
-        else
-          find_index(val)
-        end
-      end
-
-      def smart_include?(val)
-        case val
-        when Referenceable
-          lazy.map(&:id).include?(val.id)
-        else
-          include?(val)
-        end
-      end
-
-      def smart_intersection(ary)
-        select { |item| ary.smart_include?(item) }
-      end
-
-      def after(idx)
-        return [] if idx >= size - 1
-        self[idx + 1..-1]
-      end
-
-      # Given a node in self and ary,
-      # return the idx of first node p in self that exists in both self and ary
-      # and is previous to node in self
-      def previous_item_index(ary, node)
-        return -1 unless ary.smart_include?(node)
-        initial_idx = smart_find(node)
-        return -1 if initial_idx.nil?
-
-        (initial_idx - 1).downto(0).find(-> { -1 }) do |idx|
-          ary.smart_include?(at(idx))
-        end
-      end
-    end
-  end
-end