archimate 2.0.2 → 2.0.3

data/lib/archimate/data_model/referenceable.rb

@@ -16,9 +16,35 @@ module Archimate
         @referenceable_set ||= []
       end
 
-      # Diagrams that this entity is referenced in.
-      def diagrams
-        references.select { |ref| ref.is_a?(Diagram) }
+      def model
+        references.find { |ref| ref.is_a?(Model) }
+      end
+
+      def destroy
+        references.each { |ref| ref.remove_reference(self) }
+        to_h.values.select { |v| v.is_a?(Referenceable) }.each { |ref| ref.remove_reference(self) }
+      end
+
+      def replace_with(other)
+        references.dup.each do |ref|
+          ref.replace_item_with(self, other)
+          remove_reference(ref)
+        end
+      end
+
+      def replace_item_with(item, replacement)
+        # default not doing anything
+        # puts Archimate::Color.uncolor("        Referenceable(#{cls_name(self)}).replace_item_with item: #{item} replacement: #{replacement}")
+      end
+
+      private
+
+      def cls_name(o)
+        o.class.name.split("::").last
+      end
+
+      def to_cls_name
+        ->(o) { o.class.name.split("::").last }
       end
     end
   end

data/lib/archimate/data_model/referenceable_list.rb

@@ -7,24 +7,36 @@ module Archimate
     # A list of things that can be referenced by another entity.
     class ReferenceableList
       extend Forwardable
+      include Referenceable
 
       def_delegators :@list,
+                     :+,
+                     :==,
                      :[],
                      :all?,
+                     :any?,
+                     :chunk,
                      :dig,
+                     :each,
                      :each_with_object,
+                     :empty?,
                      :find,
+                     :first,
+                     :flat_map,
+                     :group_by,
                      :hash,
                      :include?,
+                     :inject,
+                     :inspect,
+                     :last,
                      :map,
                      :none?,
-                     :select,
-                     :==,
-                     :each,
-                     :empty?,
-                     :first,
                      :reduce,
-                     :size
+                     :reject,
+                     :select,
+                     :sort,
+                     :size,
+                     :to_a
 
       attr_reader :parent
 
@@ -46,14 +58,20 @@ module Archimate
       end
 
       def push(item)
+        return if @list.include?(item)
+        add_item_references(item)
+        @list.push(item)
+      end
+
+      def <<(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}]"
+      def delete(item)
+        @list.delete(item)
+        remove_item_references(item)
       end
 
       private
@@ -70,11 +88,13 @@ module Archimate
       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
+        @list.each { |item| remove_item_references(item) }
+      end
+
+      def remove_item_references(item)
+        item.remove_reference(parent)
+        @parent_attr_references.each do |attr|
+          item.remove_reference(parent.send(attr)) if parent.send(attr)
         end
       end
     end

data/lib/archimate/data_model/relationship.rb

@@ -23,7 +23,7 @@ module Archimate
       model_attr :name, default: nil
       # @!attribute [r] documentation
       # @return [PreservedLangString, NilClass]
-      model_attr :documentation, default: nil
+      model_attr :documentation, writable: true, default: nil
       # @return [Array<AnyElement>]
       # model_attr :other_elements
       # @return [Array<AnyAttribute>]
@@ -81,12 +81,6 @@ module Archimate
         ].compact.join(" ")
       end
 
-      # @todo remove when it doesn't break diff merge conflicts
-      # @deprecated
-      def referenced_identified_nodes
-        [@source, @target].compact
-      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)
@@ -94,9 +88,36 @@ module Archimate
       #     4. Any other elements
       # source and target don't change on a merge
       def merge(relationship)
-        super
+        if !documentation
+          self.documentation = relationship.documentation
+        elsif documentation != relationship.documentation
+          documentation.merge(relationship.documentation)
+        end
+        relationship.properties.each do |property|
+          unless properties.find { |my_prop| my_prop.property_definition.name == property.property_definition.name && my_prop.value == property.value}
+            properties << property
+          end
+        end
         @access_type ||= relationship.access_type
       end
+
+      # Diagrams that this entity is referenced in.
+      def diagrams
+        references.select { |ref| ref.is_a?(Diagram) }
+      end
+
+      def replace_item_with(item, replacement)
+        super
+        item.remove_reference(self)
+        case item
+        when source
+          @source = replacement
+        when target
+          @target = replacement
+        else
+          raise "Trying to replace #{item} that I don't reference"
+        end
+      end
     end
   end
 end

data/lib/archimate/data_model/relationship_references.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Archimate::CoreRefinements
+
 module Archimate
   module DataModel
     # RelationshipReferences provides a means to allow a class that is referenced
@@ -13,15 +15,122 @@ module Archimate
         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 }
+      # List of relationships where this object is the source
+      def source_relationships
+        relationships.select { |rel| rel.source.id == id }
+      end
+
+      # List of relationships where this object is the target
+      def target_relationships
+        relationships.select { |rel| rel.target.id == id }
+      end
+
+      # Creates a method on this instance that returns the relationships of the
+      # relationship type `rel_cls` where this object is the source.
+      #
+      # @param rel_cls [Archimate::DataModel::Relationship] Relationships class to define references method
+      def self.define_typed_relationships_method(rel_cls)
+        define_method(rel_cls::VERB.to_method_name("relationships")) do
+          references.select { |ref| ref.is_a?(rel_cls) && ref.source == self }
+        end
+      end
+
+      # Creates a method on this instance that returns the elements related by the
+      # relationship type `rel_cls` where this object is the source.
+      #
+      # @param rel_cls [Archimate::DataModel::Relationship] Relationships class to define references method
+      def self.define_typed_elements_method(rel_cls)
+        define_method(rel_cls::VERB.to_method_name("elements")) do
+          references
+            .select { |ref| ref.is_a?(rel_cls) && ref.source == self }
+            .map(&:target)
+        end
+      end
+
+      # Creates a method on this instance that returns the relationships of the
+      # relationship type `rel_cls` where this object is the target.
+      #
+      # @param rel_cls [Archimate::DataModel::Relationship] Relationships class to define references method
+      def self.define_typed_targeted_relationships_method(rel_cls)
+        define_method(rel_cls::OBJECT_VERB.to_method_name("relationships")) do
+          references.select { |ref| ref.is_a?(rel_cls) && ref.target == self }
+        end
+      end
+
+      # Creates a method on this instance that returns the elements related by the
+      # relationship type `rel_cls` where this object is the source.
+      #
+      # @param rel_cls [Archimate::DataModel::Relationship] Relationships class to define references method
+      def self.define_typed_targeted_elements_method(rel_cls)
+        define_method(rel_cls::OBJECT_VERB.to_method_name("elements")) do
+          references
+            .select { |ref| ref.is_a?(rel_cls) && ref.target == self }
+            .map(&:source)
+        end
+      end
+
+      # Creates a method on this instance to create relationships to one or more
+      # elements of a the rel_cls relationship type where this object is source.
+      #
+      # @param rel_cls [Archimate::DataModel::Relationship] Relationships class to define references method
+      def self.define_source_relationship_creation_method(rel_cls)
+        define_method(rel_cls::VERB.to_method_name) do |targets = nil, args = {}|
+          rels = Array(args.fetch(:target, targets)).compact.map do |target|
+            relationship = model&.relationships&.find do |r|
+              r.is_a?(rel_cls) &&
+                r.name == args.fetch(:name, nil) &&
+                r.source == self &&
+                r.target == target
+            end
+            unless relationship
+              rargs = args.dup
+              rargs[:target] = target
+              rargs[:source] = self
+              rargs[:id] = model.make_unique_id if !rargs.key?(:id) && model
+              relationship = rel_cls.new(rargs)
+              (model.relationships << relationship) if model
+            end
+            relationship
           end
+          rels.size < 2 ? rels.first : rels
+        end
+      end
 
-          define_method(rel_cls::OBJECT_VERB.tr(' ', '_').to_sym) do
-            references.select { |ref| ref.is_a?(rel_cls) && ref.target == self }
+      # Creates a method on this instance to create relationships to one or more
+      # elements of a the rel_cls relationship type where this object is target.
+      #
+      # @param rel_cls [Archimate::DataModel::Relationship] Relationships class to define references method
+      def self.define_target_relationship_creation_method(rel_cls)
+        define_method(rel_cls::OBJECT_VERB.to_method_name) do |sources = nil, args = {}|
+          rels = Array(args.fetch(:source, sources)).compact.map do |source|
+            relationship = model&.relationships&.find do |r|
+              r.is_a?(rel_cls) &&
+                r.name == args.fetch(:name, nil) &&
+                r.source == source &&
+                r.target == self
+            end
+            unless relationship
+              rargs = args.dup
+              rargs[:source] = source
+              rargs[:target] = self
+              rargs[:id] = model.make_unique_id if !rargs.key?(:id) && model
+              relationship = rel_cls.new(rargs)
+              (model.relationships << relationship) if model
+            end
+            relationship
           end
+          rels.size < 2 ? rels.first : rels
+        end
+      end
+
+      def self.included(_base)
+        Relationships.classes.each do |rel_cls|
+          define_typed_relationships_method(rel_cls)
+          define_typed_elements_method(rel_cls)
+          define_typed_targeted_relationships_method(rel_cls)
+          define_typed_targeted_elements_method(rel_cls)
+          define_source_relationship_creation_method(rel_cls)
+          define_target_relationship_creation_method(rel_cls)
         end
       end
     end

data/lib/archimate/data_model/relationships.rb

@@ -209,6 +209,21 @@ module Archimate
       def self.classes
         constants.map { |cls_name| const_get(cls_name) }
       end
+
+      def self.default
+        [
+          Relationships::Access,
+          Relationships::Aggregation,
+          Relationships::Assignment,
+          Relationships::Association,
+          Relationships::Composition,
+          Relationships::Flow,
+          Relationships::Realization,
+          Relationships::Specialization,
+          Relationships::Triggering,
+          Relationships::Serving
+        ].freeze
+      end
     end
   end
 end

data/lib/archimate/data_model/view_node.rb

@@ -92,8 +92,9 @@ module Archimate
       # @return [Element, NilClass]
       model_attr :element, writable: true, comparison_attr: :id, default: nil, also_reference: [:diagram]
       # Archi format, selects the shape of element (for elements that can have two or more shapes)
+      # A nil value indicates the standard representation, a value of "1" indicates the alternate
       # @!attribute [r] child_type
-      # @return [Int, NilClass]
+      # @return [String, NilClass]
       model_attr :child_type, default: nil
 
       # @!attribute [r] diagram
@@ -122,9 +123,9 @@ module Archimate
 
       def description
         [
-          name.nil? ? nil : name.to_s,
-          element.nil? ? nil : element.name,
-          element&.type.nil? ? nil : "(#{element.type})"
+          name&.to_s,
+          element&.name,
+          element ? "(#{element.type})" : nil
         ].compact.join(" ")
       end
 
@@ -136,15 +137,6 @@ module Archimate
         nodes.each_with_object(id => self) { |i, a| a.merge!(i.child_id_hash) }
       end
 
-      def referenced_identified_nodes
-        (nodes.to_ary + connections).reduce(
-          [element]
-        .compact
-        ) do |a, e|
-          a.concat(e.referenced_identified_nodes)
-        end
-      end
-
       def in_diagram
         diagram # ||= ->(node) { node = node.parent until node.nil? || node.is_a?(Diagram) }.call(self)
       end
@@ -167,6 +159,21 @@ module Archimate
           .select { |conn| conn.target&.id == id }
           .map(&:id)
       end
+
+      def center
+        @bounds&.center
+      end
+
+      def replace_item_with(item, replacement)
+        super
+        item.remove_reference(self)
+        case item
+        when element
+          @element = replacement
+        else
+          raise "Trying to replace #{item} that I don't reference"
+        end
+      end
     end
   end
 end

data/lib/archimate/data_model/viewpoint.rb

@@ -35,7 +35,7 @@ module Archimate
       # @return [Array<ViewpointContentEnum>]
       model_attr :viewpoint_contents, default: []
       # @!attribute [r] allowed_element_types
-      # @return [Array<ElementType>]
+      # @return [Array<Elements::*>]
       model_attr :allowed_element_types, default: []
       # @!attribute [r] allowed_relationship_types
       # @return [Array<Relationships::*>]
@@ -43,6 +43,18 @@ module Archimate
       # @!attribute [r] modeling_notes
       # @return [Array<ModelingNote>]
       model_attr :modeling_notes, default: []
+
+      def to_s
+        name.to_s
+      end
+
+      def select_elements(from_elements)
+        from_elements.select { |el| allowed_element_types.include?(el.class) }
+      end
+
+      def select_relationships(from_relationships)
+        from_relationships.select { |rel| allowed_relationship_types.include?(rel.class) }
+      end
     end
   end
 end