archimate 1.2.1 → 2.0.0

data/lib/archimate/data_model/connection.rb

@@ -9,73 +9,95 @@ module Archimate
     # If the connection is an ArchiMate relationship type, the connection's label, documentation and properties may be determined
     # (i.e inherited) from those in the referenced ArchiMate relationship. Otherwise the connection's label, documentation and properties
     # can be provided and will be additional to (or over-ride) those contained in the referenced ArchiMate relationship.
-    #
-    # This is ConnectionType in the XSD
-    # ViewConceptType > ConnectionType > SourcedConnectionType > Relationship > NestingRelationship
-    #                                  > Line
-    #                 > ViewNodeType >
-    #                                  Label
-    #                                  Container > Element
-    class Connection < Referenceable # ViewConcept
-      using DiffableArray
-
-      attribute :source_attachment, Location.optional
-      attribute :bendpoints, LocationList
-      attribute :target_attachment, Location.optional
-      attribute :source, Identifier.optional
-      attribute :target, Identifier.optional
-      attribute :type, Strict::String.optional
+    class Connection
+      include Comparison
 
-      # This is under Relationship
-      attribute :relationship, Strict::String.optional
+      # @!attribute [r] id
+      #   @return [String]
+      model_attr :id
+      # @!attribute [r] name
+      #   @return [LangString, NilClass]
+      model_attr :name
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString, NilClass]
+      model_attr :documentation
+      # # @!attribute [r] other_elements
+      #   @return [Array<AnyElement>]
+      model_attr :other_elements
+      # # @!attribute [r] other_attributes
+      #   @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] source_attachment
+      #   @return [Location, NilClass]
+      model_attr :source_attachment
+      # @!attribute [r] bendpoints
+      #   @return [Array<Location>]
+      model_attr :bendpoints
+      # @!attribute [r] target_attachment
+      #   @return [Location, NilClass]
+      model_attr :target_attachment
+      # @!attribute [rw] source
+      #   @return [ViewNode, NilClass]
+      model_attr :source, comparison_attr: :id, writable: true
+      # @!attribute [rw] target
+      #   @return [ViewNode, NilClass]
+      model_attr :target, comparison_attr: :id, writable: true
+      # @!attribute [rw] relationship
+      #   @return [Relationship, NilClass]
+      model_attr :relationship, comparison_attr: :id, writable: true
+      # @!attribute [r] style
+      #   @return [Style, NilClass]
+      model_attr :style
+      # @!attribute [r] properties
+      #   @return [Array<Property>]
+      model_attr :properties
 
-      # Note: this is added under ViewConcept
-      attribute :style, Style.optional
-      attribute :properties, PropertiesList
+      def initialize(id:, name: nil, documentation: nil, type: nil,
+                     source_attachment: nil, bendpoints: [], target_attachment: nil,
+                     source: nil, target: nil, relationship: nil, style: nil,
+                     properties: nil)
+        @id = id
+        @name = name
+        @documentation = documentation
+        @type = type
+        @source_attachment = source_attachment
+        @bendpoints = bendpoints
+        @target_attachment = target_attachment
+        @source = source
+        @target = target
+        @relationship = relationship
+        @style = style
+        @properties = properties
+      end
 
       def replace(entity, with_entity)
-        @relationship = with_entity.id if (relationship == entity.id)
-        @source = with_entity.id if (source == entity.id)
-        @target = with_entity.id if (target == entity.id)
+        @relationship = with_entity.id if relationship == entity.id
+        @source = with_entity.id if source == entity.id
+        @target = with_entity.id if target == entity.id
       end
 
       def type_name
-        Archimate::Color.color("#{Archimate::Color.data_model('Connection')}[#{Archimate::Color.color(@name || '', [:white, :underline])}]", :on_light_magenta)
-      end
-
-      def relationship_element
-        in_model.lookup(relationship)
+        Archimate::Color.color("#{Archimate::Color.data_model('Connection')}[#{Archimate::Color.color(@name || '', %i[white underline])}]", :on_light_magenta)
       end
 
       def element
-        relationship_element
-      end
-
-      def source_element
-        in_model.lookup(source)
-      end
-
-      def target_element
-        in_model.lookup(target)
+        relationship
       end
 
       def to_s
-        if in_model
-          s = in_model.lookup(source) unless source.nil?
-          t = in_model.lookup(target) unless target.nil?
-        else
-          s = source
-          t = target
-        end
-        "#{type_name} #{s.nil? ? 'nothing' : s} -> #{t.nil? ? 'nothing' : t}"
+        "#{type_name} #{source.nil? ? 'nothing' : source} -> #{target.nil? ? 'nothing' : target}"
       end
 
       def description
         [
           name.nil? ? nil : "#{name}: ",
-          source_element&.description,
-          relationship_element&.description,
-          target_element&.description
+          source&.description,
+          relationship&.description,
+          target&.description
         ].compact.join(" ")
       end
 
@@ -101,7 +123,5 @@ module Archimate
         offset
       end
     end
-    Dry::Types.register_class(Connection)
-    ConnectionList = Strict::Array.member("archimate.data_model.connection").default([])
   end
 end

data/lib/archimate/data_model/connector_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require "ruby-enum"
+
+module Archimate
+  module DataModel
+    # An enumeration of the connector types available in Archimate
+    # @example Reference an "And" Junction.
+    #   ConnectorType::AndJunction #=> "AndJunction"
+    class ConnectorType
+      include Ruby::Enum
+
+      define :AndJunction, "AndJunction"
+      define :Junction, "Junction"
+      define :OrJunction, "OrJunction"
+
+      # Returns true if {other} is a +ConnectorType+
+      # @param other [String]
+      def self.===(other)
+        values.include?(other)
+      end
+    end
+  end
+end

data/lib/archimate/data_model/diagram.rb

@@ -1,11 +1,67 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
-    class Diagram < View
-      attribute :nodes, Strict::Array.member(ViewNode).default([])
-      attribute :connection_router_type, Coercible::Int.optional # TODO: Archi formats only fill this in, should be an enum
-      attribute :background, Coercible::Int.optional # value of 0 on Archi Sketch Model
-      attribute :connections, Strict::Array.member(Connection).default([])
+    class Diagram
+      include Comparison
+
+      # @!attribute [r] id
+      #   @return [String]
+      model_attr :id
+      # @!attribute [rw] name
+      #   @return [LangString]
+      model_attr :name, writable: true
+      # @!attribute [rw] documentation
+      #   @return [PreservedLangString, NilClass]
+      model_attr :documentation, writable: true
+      # # @return [Array<AnyElement>]
+      # model_attr :other_elements
+      # # @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 [rw] properties
+      #   @return [Array<Property>]
+      model_attr :properties, writable: true
+      # @todo make this a ViewpointType is better but is Archimate specification version dependent
+      # @!attribute [r] viewpoint_type
+      #   @return [String, NilClass]
+      model_attr :viewpoint_type
+      # @!attribute [r] viewpoint
+      #   @return [Viewpoint, NilClass]
+      model_attr :viewpoint
+      # @!attribute [rw] nodes
+      #   @return [Array<ViewNode>]
+      model_attr :nodes, writable: true
+      # @todo Archi formats only fill this in, should be an enum
+      # @!attribute [r] connection_router_type
+      #   @return [Int, NilClass]
+      model_attr :connection_router_type
+      # value of 0 on Archi Sketch Model
+      # @!attribute [r] background
+      #   @return [Int, NilClass]
+      model_attr :background
+      # @!attribute [rw] connections
+      #   @return [Array<Connection>]
+      model_attr :connections, writable: true
+
+      def initialize(id:, name: nil, documentation: nil, type: nil, properties: [],
+                     viewpoint_type: nil, viewpoint: nil, nodes: [],
+                     connection_router_type: nil, background: nil, connections: [])
+        @id = id
+        @name = name
+        @documentation = documentation
+        @type = type
+        @properties = properties
+        @viewpoint_type = viewpoint_type
+        @viewpoint = viewpoint
+        @nodes = nodes
+        @connection_router_type = connection_router_type
+        @background = background
+        @connections = connections
+      end
 
       def all_nodes
         nodes.inject(Array.new(nodes)) { |child_ary, child| child_ary.concat(child.all_nodes) }
@@ -16,25 +72,31 @@ module Archimate
       end
 
       def element_ids
-        @element_ids ||= all_nodes.map(&:archimate_element).compact
+        @element_ids ||= elements.map(&:id)
       end
 
       def relationships
-        @relationships ||= connections.map(&:element).compact
+        @relationships ||= connections.map(&:relationship).compact
       end
 
       def relationship_ids
-        @relationship_ids ||= connections.map(&:relationship).compact
+        @relationship_ids ||= relationships.map(&:id)
       end
 
       def to_s
-        "#{Archimate::Color.data_model('Diagram')}<#{id}>[#{Archimate::Color.color(name, [:white, :underline])}]"
+        "#{Archimate::Color.data_model('Diagram')}<#{id}>[#{Archimate::Color.color(name, %i[white underline])}]"
       end
 
       def total_viewpoint?
         viewpoint_type.nil? || viewpoint_type.empty?
       end
+
+      def referenced_identified_nodes
+        (nodes + connections)
+          .map(&:referenced_identified_nodes)
+          .flatten
+          .uniq
+      end
     end
-    Dry::Types.register_class(Diagram)
   end
 end

data/lib/archimate/data_model/diagram_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "ruby-enum"
+
+module Archimate
+  module DataModel
+    class DiagramType
+      include Ruby::Enum
+
+      define :ArchimateDiagramModel, "ArchimateDiagramModel"
+      define :SketchModel, "SketchModel"
+
+      def self.===(other)
+        values.include?(other)
+      end
+    end
+  end
+end

data/lib/archimate/data_model/differentiable.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # Let's talk about diff...
+    #
+    # Here are my expectations of diff:
+    #
+    # = Preconditions:
+    #
+    # 1. self is non-nil
+    # 2. self is a class that includes Comparison
+    #
+    # = Requirements for other
+    #
+    # Not matching one of these is a programming error.
+    #
+    # 1. Other is nil
+    # 2. Other is an instance of the same class as self
+    #
+    # = Diff results
+    #
+    # * Diffing results in a list of Diff instances between +self+ and +other+
+    # * Patching the list of diffs against self results in an instance that == +other+
+    #
+    # = Diff Container
+    #
+    # A diff container is a top level entity that is meaningful in the user domain
+    # for example: [Element], [Relationship], [Diagram]. It collects and groups
+    # the smaller diffs into the things that changed by an entity tha makes sense
+    # to the user.
+    #
+    # = Diff structure
+    #
+    # A diff contains a change to be applied in a particular context.
+    #
+    # Use cases:
+    #
+    # 1. Delete a value that is a member of this class. Example: Delete the
+    #    +a+ member of a [Color] instance.
+    # 2. A non-reference value replacing a value in a class. Example:
+    #    Changing the +r+ value of a [Color] with a different value.
+    # 3. Updating the value of an attribute of a child. (or child's child)
+    # 4. Deleting the value of an attribute of a child. (or child's child)
+    # 5. For Array attributes with non-referenceable contents
+    #    1. Deleting a value from an array attribute
+    #    2. Inserting a value into an array attribute
+    #    3. Changing a value in an array attribute
+    # 6. For Array attributes with referenceable contents
+    #    1. Deleting a value from an array attribute (has an implication on
+    #       if the entity is deleted from the model entirely)
+    #    2. Inserting a value into an array attribute (may need addtion to the
+    #       model)
+    #    3. Changing a value in an array attribute (changing the entity id may
+    #       require the implications of deletion and insertion as above)
+    #
+    # When to stop?
+    #
+    # When digging down into a diff operation, there are some natural stopping
+    # points:
+    #
+    # 1. When there is no more depth to dig
+    # 2. When the objects being compared are references to other entities, but
+    #    do not belong to the current object being diffed.
+    # 3. When the object being diffed is a Diff container unto itself. For
+    #    example: When diffing a model, the diff should include the order
+    #    of elements referenced in the +elements+ attribute, but shouldn't
+    #    continue with the diff of each element itself.
+    #
+    # = Complications
+    #
+    # == Object references
+    #
+    # Since a patch operation produces an new replacement object, object
+    # references need to be handled. For example, given an +Element+ with +id=3+
+    # if a patch changes this +Element+'s name, then the +Element+ in
+    # the model under +Model#elements+ is replaced with a different instance,
+    # but a +Relationship+ that references the +Element+ is still pointing at
+    # a different instance and needs to be updated.
+    Insert = Struct.new(:path, :value)
+    Delete = Struct.new(:path)
+    Change = Struct.new(:path, :from, :to)
+
+    module Differentiable
+      # Computes the diffs between this object and another object of the same type
+      #
+      # @param other [self.class] another object to compare
+      # @return [Array<Diff::Difference>]
+      # @raise
+      def diff(other)
+        return [] if other.nil?
+        raise TypeError, "Expected other <#{other.class} to be of type #{self.class}" unless other.is_a?(self.class)
+
+        self.class.attr_names.each_with_object([]) do |k, a|
+          val = send(k)
+          case val
+          when NilClass
+            a << Insert.new(k, other[k]) unless other[k].nil?
+          when Integer, Float, Hash, String, Symbol
+            a.concat(Differentiable.diff_primitive(val, other[k], self, other, k))
+          when Differentiable
+            a.concat(val.diff(other[k]))
+          else
+            raise "Unexpected Type for Diff don't know how to diff a #{val.class}"
+          end
+        end
+      end
+
+      def patch(diffs)
+        ary = diffs.is_a?(Array) ? diffs : [diffs]
+        self.class.new(
+          ary.each_with_object(to_h) do |diff, args|
+            case diff
+            when Delete
+              args[diff.path] = nil
+            when Insert
+              args[diff.path] = diff.value
+            when Change
+              args[diff.path] = diff.to
+            else
+              raise "Unexpected diff type #{diff.class} #{diff.inspect}"
+            end
+          end
+        )
+      end
+
+      private
+
+      def self.diff_primitive(val, other, from_parent, to_parent, attribute, from_attribute = nil)
+        from_attribute = attribute if from_attribute.nil?
+        if other.nil?
+          return [Delete.new(attribute)]
+        end
+        raise TypeError, "Expected other #{other.class} to be of type #{val.class}" unless other.is_a?(val.class)
+        unless val == other
+          return [Change.new(attribute, val, other)]
+        end
+        []
+      end
+    end
+  end
+end

data/lib/archimate/data_model/element.rb

@@ -2,58 +2,53 @@
 
 module Archimate
   module DataModel
-    ElementTypeEnum = %w[BusinessActor BusinessRole BusinessCollaboration BusinessInterface
-                         BusinessProcess BusinessFunction BusinessInteraction BusinessEvent BusinessService
-                         BusinessObject Contract Representation Product
-                         ApplicationComponent ApplicationCollaboration ApplicationInterface ApplicationFunction
-                         ApplicationInteraction ApplicationProcess ApplicationEvent ApplicationService DataObject
-                         Node Device SystemSoftware TechnologyCollaboration TechnologyInterface Path
-                         CommunicationNetwork TechnologyFunction TechnologyProcess TechnologyInteraction
-                         TechnologyEvent TechnologyService Artifact Equipment Facility DistributionNetwork Material
-                         Stakeholder Driver Assessment Goal Outcome
-                         Principle Requirement Constraint Meaning Value
-                         Resource Capability CourseOfAction
-                         WorkPackage Deliverable ImplementationEvent Plateau Gap
-                         Grouping Location
-                         AndJunction OrJunction].freeze
-
-    CompositeTypeEnum = %w[Grouping Location].freeze
-
-    RelationshipConnectorEnum = %w[AndJunction OrJunction].freeze
-
-    ElementEnumType = [].concat([ElementTypeEnum, CompositeTypeEnum, RelationshipConnectorEnum]).freeze
+    # A base element type that can be extended by concrete ArchiMate types.
+    #
+    # Note that ElementType is abstract, so one must have derived types of this
+    # type. This is indicated in xml by having a tag name of +element+ and an
+    # attribute of +xsi:type="BusinessRole"+ where +BusinessRole+ is a derived
+    # type from [ElementType].
+    #
+    # @todo Possible Make this abstract with concrete implementations for all
+    #       valid element types
+    class Element
+      include Comparison
 
-    ElementType = Strict::String.enum(*ElementEnumType)
+      # @!attribute [r] id
+      #   @return [String]
+      model_attr :id
+      # @!attribute [r] name
+      #   @return [LangString, NilClass]
+      model_attr :name
+      # @!attribute [rw] documentation
+      #   @return [PreservedLangString, NilClass]
+      model_attr :documentation, writable: true
+      # # @return [Array<AnyElement>]
+      # model_attr :other_elements
+      # # @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
 
-    AllowedElementTypes = Strict::Array.member(ElementType).default([])
+      def initialize(id:, name:, documentation: nil, type: nil, properties: [])
+        @id = id
+        @name = name
+        @documentation = documentation
+        @type = type
+        @properties = properties
+      end
 
-    # A base element type that can be extended by concrete ArchiMate types.
-    #
-    # Note that ElementType is abstract, so one must have derived types of this type. this is indicated in xml
-    # by having a tag name of "element" and an attribute of xsi:type="BusinessRole" where BusinessRole is
-    # a derived type from ElementType.
-    class Element < Concept
       def to_s
         Archimate::Color.layer_color(layer, "#{type}<#{id}>[#{name}]")
       end
 
       def layer
-        Constants::ELEMENT_LAYER.fetch(type, "None")
-      end
-
-      # TODO: move to dynamic method creation
-      def composed_by
-        in_model
-          .relationships.select { |r| r.type == "CompositionRelationship" && r.target == id }
-          .map { |r| in_model.lookup(r.source) }
-      end
-
-      # TODO: move to dynamic method creation
-      def composes
-        in_model
-          .relationships
-          .select { |r| r.type == "CompositionRelationship" && r.source == id }
-          .map { |r| in_model.lookup(r.target) }
+        Layers.for_element(type)
       end
 
       # Diagrams that this element is referenced in.
@@ -82,6 +77,5 @@ module Archimate
         element.organization.remove(element.id)
       end
     end
-    Dry::Types.register_class(Element)
   end
 end