archimate 2.0.1 → 2.0.2

data/lib/archimate/data_model/referenceable_list.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Archimate
+  module DataModel
+    # A list of things that can be referenced by another entity.
+    class ReferenceableList
+      extend Forwardable
+
+      def_delegators :@list,
+                     :[],
+                     :all?,
+                     :dig,
+                     :each_with_object,
+                     :find,
+                     :hash,
+                     :include?,
+                     :map,
+                     :none?,
+                     :select,
+                     :==,
+                     :each,
+                     :empty?,
+                     :first,
+                     :reduce,
+                     :size
+
+      attr_reader :parent
+
+      def initialize(parent, contents = [], parent_attr_references = [])
+        @parent = parent
+        @parent_attr_references = parent_attr_references
+        @list = contents || []
+        add_references
+      end
+
+      def replace_with(contents)
+        remove_references
+        @list = contents
+        add_references
+      end
+
+      def to_ary
+        Array.new(@list).freeze
+      end
+
+      def push(item)
+        return if @list.include?(item)
+        add_item_references(item)
+        @list << item
+      end
+
+      def inspect
+        vals = @list.first(3).map(&:brief_inspect)
+        "[#{vals.join(', ')}#{"...#{@list.size}" if @list.size > 3}]"
+      end
+
+      private
+
+      def add_references
+        @list.each { |item| add_item_references(item) }
+      end
+
+      def add_item_references(item)
+        item.add_reference(parent)
+        @parent_attr_references.each do |attr|
+          item.add_reference(parent.send(attr)) if parent.send(attr)
+        end
+      end
+
+      def remove_references
+        @list.each do |item|
+          item.remove_reference(parent)
+          @parent_attr_references.each do |attr|
+            item.remove_reference(parent.send(attr)) if parent.send(attr)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/data_model/relationship.rb

@@ -3,90 +3,70 @@
 module Archimate
   module DataModel
     ACCESS_TYPE = %w[Access Read Write ReadWrite].freeze
-    AccessTypeEnum = String #String.enum(*ACCESS_TYPE)
+    AccessTypeEnum = String # String.enum(*ACCESS_TYPE)
 
     # A base relationship type that can be extended by concrete ArchiMate types.
     #
-    # Note that RelationshipType is abstract, so one must have derived types of this type. this is indicated in xml
-    # by having a tag name of "relationship" and an attribute of xsi:type="AccessRelationship" where AccessRelationship is
-    # a derived type from RelationshipType.
+    # Note that RelationshipType is abstract, so one must have derived types of
+    # this type. this is indicated in xml 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
+      include Referenceable
 
       # @!attribute [r] id
-      #   @return [String]
+      # @return [String]
       model_attr :id
       # @!attribute [r] name
-      #   @return [LangString, NilClass]
-      model_attr :name
+      # @return [LangString, NilClass]
+      model_attr :name, default: nil
       # @!attribute [r] documentation
-      #   @return [PreservedLangString, NilClass]
-      model_attr :documentation
-      # # @return [Array<AnyElement>]
+      # @return [PreservedLangString, NilClass]
+      model_attr :documentation, default: nil
+      # @return [Array<AnyElement>]
       # model_attr :other_elements
-      # # @return [Array<AnyAttribute>]
+      # @return [Array<AnyAttribute>]
       # model_attr :other_attributes
-      # @note type here was used for the Element/Relationship/Diagram type
-      # @!attribute [r] type
-      #   @return [String, NilClass]
-      model_attr :type
       # @!attribute [r] properties
-      #   @return [Array<Property>]
-      model_attr :properties
+      # @return [Array<Property>]
+      model_attr :properties, default: []
       # @todo is this optional?
       # @!attribute [rw] source
-      #   @return [Element, Relationship]
-      model_attr :source, comparison_attr: :id, writable: true
+      # @return [Element, Relationship]
+      model_attr :source, comparison_attr: :id, writable: true, default: nil
       # @todo is this optional?
       # @!attribute [rw] target
-      #   @return [Element, Relationship]
-      model_attr :target, comparison_attr: :id, writable: true
+      # @return [Element, Relationship]
+      model_attr :target, comparison_attr: :id, writable: true, default: nil
       # @!attribute [r] access_type
-      #   @return [AccessTypeEnum, NilClass]
-      model_attr :access_type
+      # @return [AccessTypeEnum, NilClass]
+      model_attr :access_type, default: nil
       # @!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,
-                     derived: false)
-        @id = id
-        @name = name
-        @documentation = documentation
-        @type = type
-        @properties = properties
-        @source = source
-        @target = target
-        @access_type = access_type
-        @derived = derived
-      end
+      # @return [Boolean] this is a derived relation if true
+      model_attr :derived, default: false
 
       def replace(entity, with_entity)
         @source = with_entity.id if source == entity.id
         @target = with_entity.id if target == entity.id
       end
 
+      def type
+        self.class.name.split("::").last
+      end
+
+      def weight
+        self.class::WEIGHT
+      end
+
+      def classification
+        self.class::CLASSIFICATION
+      end
+
+      def verb
+        self.class::VERB
+      end
+
       def to_s
         Archimate::Color.color(
           "#{Archimate::Color.data_model(type)}<#{id}>[#{Archimate::Color.color(name&.strip || '', %i[black underline])}]",
@@ -97,7 +77,7 @@ module Archimate
       def description
         [
           name.nil? ? nil : "#{name}:",
-          RELATION_VERBS.fetch(type, nil)
+          verb
         ].compact.join(" ")
       end
 
@@ -107,13 +87,6 @@ module Archimate
         [@source, @target].compact
       end
 
-      # Diagrams that this element is referenced in.
-      def diagrams
-        @diagrams ||= in_model.diagrams.select do |diagram|
-          diagram.relationship_ids.include?(id)
-        end
-      end
-
       # Copy any attributes/docs, etc. from each of the others into the original.
       #     1. Child `label`s with different `xml:lang` attribute values
       #     2. Child `documentation` (and different `xml:lang` attribute values)
@@ -122,92 +95,8 @@ module Archimate
       # source and target don't change on a merge
       def merge(relationship)
         super
-        access_type ||= relationship.access_type
+        @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_references.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # RelationshipReferences provides a means to allow a class that is referenced
+    # by Relationship objects to get the set of:
+    # * All relationships
+    # * All relationships by:
+    #   - a particular type
+    #   - if this object is the source of target of the relationship
+    module RelationshipReferences
+      def relationships
+        references.select { |ref| ref.is_a?(DataModel::Relationship) }
+      end
+
+      def self.included(_base)
+        Relationships.classes.each do |rel_cls|
+          define_method(rel_cls::VERB.tr(' ', '_').to_sym) do
+            references.select { |ref| ref.is_a?(rel_cls) && ref.source == self }
+          end
+
+          define_method(rel_cls::OBJECT_VERB.tr(' ', '_').to_sym) do
+            references.select { |ref| ref.is_a?(rel_cls) && ref.target == self }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/data_model/relationships.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # 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.
+    module Relationships
+      class Composition < Relationship
+        WEIGHT = 10
+        CLASSIFICATION = :structural
+        VERB = "composes"
+        OBJECT_VERB = "composed by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Aggregation < Relationship
+        WEIGHT = 9
+        CLASSIFICATION = :structural
+        VERB = "aggregates"
+        OBJECT_VERB = "aggregated by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Assignment < Relationship
+        WEIGHT = 8
+        CLASSIFICATION = :structural
+        VERB = "assigned to"
+        OBJECT_VERB = "assigned from"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Realization < Relationship
+        WEIGHT = 7
+        CLASSIFICATION = :structural
+        VERB = "realizes"
+        OBJECT_VERB = "realized by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Serving < Relationship
+        WEIGHT = 6
+        CLASSIFICATION = :dependency
+        VERB = "serves"
+        OBJECT_VERB = "served by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Access < Relationship
+        WEIGHT = 5
+        CLASSIFICATION = :dependency
+        VERB = "accesses"
+        OBJECT_VERB = "accessed by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Influence < Relationship
+        WEIGHT = 4
+        CLASSIFICATION = :dependency
+        VERB = "influences"
+        OBJECT_VERB = "influenced by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Triggering < Relationship
+        WEIGHT = 3
+        CLASSIFICATION = :dynamic
+        VERB = "triggers"
+        OBJECT_VERB = "triggered by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Flow < Relationship
+        WEIGHT = 2
+        CLASSIFICATION = :dynamic
+        VERB = "flows to"
+        OBJECT_VERB = "flows from"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Specialization < Relationship
+        WEIGHT = 1
+        CLASSIFICATION = :other
+        VERB = "specializes"
+        OBJECT_VERB = "specialized by"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      class Association < Relationship
+        WEIGHT = 0
+        CLASSIFICATION = :other
+        VERB = "associated with"
+        OBJECT_VERB = "associated from"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      # Junction is a relationship connector
+      # *  All relationships connected with relationship connectors must be of the same type
+      class Junction < Relationship
+        WEIGHT = 0
+        CLASSIFICATION = :other
+        VERB = "junction to"
+        OBJECT_VERB = "junction from"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      # Junction is a relationship connector
+      # *  All relationships connected with relationship connectors must be of the same type
+      class AndJunction < Relationship
+        WEIGHT = 0
+        CLASSIFICATION = :other
+        VERB = "and junction to"
+        OBJECT_VERB = "and junction from"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      # Junction is a relationship connector
+      # *  All relationships connected with relationship connectors must be of the same type
+      class OrJunction < Relationship
+        WEIGHT = 0
+        CLASSIFICATION = :other
+        VERB = "or junction to"
+        OBJECT_VERB = "or junction from"
+
+        def initialize(args)
+          super
+        end
+      end
+
+      def self.create(*args)
+        # type = args[0].delete(:type)
+        # cls_name = type.strip.sub(/Relationship$/, '')
+        # cls_name = RELATIONSHIP_SUBSTITUTIONS.fetch(cls_name, cls_name)
+        cls_name = str_filter(args[0].delete(:type))
+        Relationships.const_get(cls_name).new(*args)
+      rescue NameError => err
+        Archimate::Logging.error "An invalid relationship type '#{cls_name}' was used to create a Relationship"
+        raise err
+      end
+
+      def self.===(other)
+        constants.map(&:to_s).include?(str_filter(other))
+      end
+
+      def self.str_filter(str)
+        relationship_substitutions = {
+          "Realisation" => "Realization",
+          "Specialisation" => "Specialization",
+          "UsedBy" => "Serving"
+        }.freeze
+
+        cls_name = str.strip.sub(/Relationship$/, '')
+        relationship_substitutions.fetch(cls_name, cls_name)
+      end
+
+      def self.classes
+        constants.map { |cls_name| const_get(cls_name) }
+      end
+    end
+  end
+end

data/lib/archimate/data_model/schema_info.rb

@@ -6,20 +6,14 @@ module Archimate
       include Comparison
 
       # @!attribute [r] schema
-      #   @return [String, NilClass]
-      model_attr :schema
+      # @return [String, NilClass]
+      model_attr :schema, default: nil
       # @!attribute [r] schemaversion
-      #   @return [String, NilClass]
-      model_attr :schemaversion
+      # @return [String, NilClass]
+      model_attr :schemaversion, default: nil
       # @!attribute [r] elements
-      #   @return [Array<AnyElement>]
-      model_attr :elements
-
-      def initialize(schema: nil, schemaversion: nil, elements: [])
-        @schema = schema
-        @schemaversion = schemaversion
-        @elements = elements
-      end
+      # @return [Array<AnyElement>]
+      model_attr :elements, default: []
 
       def to_s
         "#{type.light_black}[#{schema} #{schemaversion}]"

data/lib/archimate/data_model/style.rb

@@ -7,39 +7,28 @@ module Archimate
 
       # @todo make this an enum
       # @!attribute [r] text_alignment
-      #   @return [Int, NilClass]
-      model_attr :text_alignment
+      # @return [Int, NilClass]
+      model_attr :text_alignment, default: nil
       # @!attribute [r] fill_color
-      #   @return [Color, NilClass]
-      model_attr :fill_color
+      # @return [Color, NilClass]
+      model_attr :fill_color, default: nil
       # @!attribute [r] line_color
-      #   @return [Color, NilClass]
-      model_attr :line_color
+      # @return [Color, NilClass]
+      model_attr :line_color, default: nil
       # @todo move this to font
       # @!attribute [r] font_color
-      #   @return [Color, NilClass]
-      model_attr :font_color
+      # @return [Color, NilClass]
+      model_attr :font_color, default: nil
       # @!attribute [r] line_width
-      #   @return [Int, NilClass]
-      model_attr :line_width
+      # @return [Int, NilClass]
+      model_attr :line_width, default: nil
       # @!attribute [r] font
-      #   @return [Font, NilClass]
-      model_attr :font
+      # @return [Font, NilClass]
+      model_attr :font, default: nil
       # @todo make this an enum
       # @!attribute [r] text_position
-      #   @return [Int, NilClass]
-      model_attr :text_position
-
-      def initialize(text_alignment: nil, fill_color: nil, line_color: nil,
-                     font_color: nil, line_width: nil, font: nil, text_position: nil)
-        @text_alignment = text_alignment
-        @fill_color = fill_color
-        @line_color = line_color
-        @font_color = font_color
-        @line_width = line_width
-        @font = font
-        @text_position = text_position
-      end
+      # @return [Int, NilClass]
+      model_attr :text_position, default: nil
 
       def to_s
         attr_name_vals = %i[text_alignment fill_color line_color font_color line_width