archimate 1.2.1 → 2.0.0

data/lib/archimate/data_model/relationship_type.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "ruby-enum"
+
+module Archimate
+  module DataModel
+    RELATION_VERBS = {
+      "AccessRelationship" => "accesses",
+      "AggregationRelationship" => "aggregates",
+      "AssignmentRelationship" => "is assigned to",
+      "AssociationRelationship" => "is associated with",
+      "CompositionRelationship" => "composes",
+      "FlowRelationship" => "flows to",
+      "InfluenceRelationship" => "influenecs",
+      "RealisationRelationship" => "realizes",
+      "SpecialisationRelationship" => "specializes",
+      "TriggeringRelationship" => "triggers",
+      "UsedByRelationship" => "is used by"
+    }.freeze
+
+    class RelationshipType
+      include Ruby::Enum
+
+      define :AccessRelationship, "AccessRelationship"
+      define :AggregationRelationship, "AggregationRelationship"
+      define :AssignmentRelationship, "AssignmentRelationship"
+      define :AssociationRelationship, "AssociationRelationship"
+      define :CompositionRelationship, "CompositionRelationship"
+      define :FlowRelationship, "FlowRelationship"
+      define :InfluenceRelationship, "InfluenceRelationship"
+      define :RealisationRelationship, "RealisationRelationship"
+      define :SpecialisationRelationship, "SpecialisationRelationship"
+      define :SpecializationRelationship, "SpecializationRelationship"
+      define :TriggeringRelationship, "TriggeringRelationship"
+      define :UsedByRelationship, "UsedByRelationship" # @todo Support: Serving
+      define :ServingRelationship, "ServingRelationship" # @todo Support: Serving
+      define :GroupingRelationship, "GroupingRelationship"
+
+      def self.===(other)
+        values.include?(other)
+      end
+    end
+  end
+end

data/lib/archimate/data_model/schema_info.rb

@@ -2,17 +2,28 @@
 
 module Archimate
   module DataModel
-    class SchemaInfo < ArchimateNode
-      using DiffablePrimitive
+    class SchemaInfo
+      include Comparison
 
-      attribute :schema, Strict::String.optional
-      attribute :schemaversion, Strict::String.optional
-      attribute :elements, Strict::Array.member(AnyElement).default([])
+      # @!attribute [r] schema
+      #   @return [String, NilClass]
+      model_attr :schema
+      # @!attribute [r] schemaversion
+      #   @return [String, NilClass]
+      model_attr :schemaversion
+      # @!attribute [r] elements
+      #   @return [Array<AnyElement>]
+      model_attr :elements
+
+      def initialize(schema: nil, schemaversion: nil, elements: [])
+        @schema = schema
+        @schemaversion = schemaversion
+        @elements = elements
+      end
 
       def to_s
         "#{type.light_black}[#{schema} #{schemaversion}]"
       end
     end
-    Dry::Types.register_class(SchemaInfo)
   end
 end

data/lib/archimate/data_model/style.rb

@@ -1,17 +1,49 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
-    class Style < ArchimateNode
-      attribute :text_alignment, Coercible::Int.optional # TODO: make this an enum
-      attribute :fill_color, Color.optional
-      attribute :line_color, Color.optional
-      attribute :font_color, Color.optional # TODO: move this to font
-      attribute :line_width, Coercible::Int.optional
-      attribute :font, Font.optional
-      attribute :text_position, Coercible::Int.optional # TODO: make this an enum
+    class Style
+      include Comparison
+
+      # @todo make this an enum
+      # @!attribute [r] text_alignment
+      #   @return [Int, NilClass]
+      model_attr :text_alignment
+      # @!attribute [r] fill_color
+      #   @return [Color, NilClass]
+      model_attr :fill_color
+      # @!attribute [r] line_color
+      #   @return [Color, NilClass]
+      model_attr :line_color
+      # @todo move this to font
+      # @!attribute [r] font_color
+      #   @return [Color, NilClass]
+      model_attr :font_color
+      # @!attribute [r] line_width
+      #   @return [Int, NilClass]
+      model_attr :line_width
+      # @!attribute [r] font
+      #   @return [Font, NilClass]
+      model_attr :font
+      # @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
 
       def to_s
-        attr_name_vals = struct_instance_variables.map { |k| "#{k}: #{self[k]}" }.join(", ")
+        attr_name_vals = %i[text_alignment fill_color line_color font_color line_width
+                            font text_position].map { |k| "#{k}: #{send(k)}" }.join(", ")
         "Style(#{attr_name_vals})"
       end
 
@@ -26,7 +58,5 @@ module Archimate
         end
       end
     end
-
-    Dry::Types.register_class(Style)
   end
 end

data/lib/archimate/data_model/view_node.rb

@@ -1,55 +1,151 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
-    PositiveInteger = Strict::Int.constrained(gt: 0)
+    # PositiveInteger =Int.constrained(gt: 0)
 
     # Graphical node type. It can contain child node types.
-    # TODO: This is ViewNodeType in the v3 XSD
-    class ViewNode < Referenceable #  < ViewConcept
-      using DiffableArray
-
-      # LocationGroup: TODO: Consider making this a mixin or extract object
-      # The x (towards the right, associated with width) attribute from the Top,Left (i.e. 0,0)
-      # corner of the diagram to the Top, Left corner of the bounding box of the concept.
-      # attribute :x, NonNegativeInteger
-      # The y (towards the bottom, associated with height) attribute from the Top,Left (i.e. 0,0)
-      # corner of the diagram to the Top, Left corner of the bounding box of the concept.
-      # attribute :y, NonNegativeInteger
-
-      # SizeGroup:
-      # The width (associated with x) attribute from the Left side to the right side of the
-      # bounding box of a concept.
-      # attribute :w, PositiveInteger
-      # The height (associated with y) attribute from the top side to the bottom side of the
-      # bounding box of a concept.
-      # attribute :h, PositiveInteger
-
-      attribute :model, Identifier.optional
-      attribute :content, Strict::String.optional
-      attribute :target_connections, Strict::Array.member(Identifier).default([])
-      attribute :archimate_element, Identifier.optional
-      attribute :bounds, Bounds.optional
-      attribute :nodes, Strict::Array.member(ViewNode).default([])
-      attribute :connections, ConnectionList
-      attribute :style, Style.optional
-      attribute :type, Strict::String.optional
-      attribute :child_type, Coercible::Int.optional
-      attribute :properties, PropertiesList # Note: this is not in the model under element
-      # it's added under Real Element
+    # This can be specialized as Label and Container
+    # In the ArchiMate v3 Schema, the tree of these nodes is:
+    # ViewConceptType(
+    #     LabelGroup (name LangString)
+    #     PreservedLangString
+    #     style (optional)
+    #     viewRefs
+    #     id)
+    # - ViewNodeType(
+    #       LocationGroup (x, y)
+    #       SizeGroup (width, height))
+    #   - Label(
+    #         conceptRef
+    #         attributeRef
+    #         xpathPart (optional)
+    #     )
+    #   - Container(
+    #         nodes (ViewNodeType)
+    #     - Element(
+    #           elementRef)
+    class ViewNode
+      include Comparison
+
+      # ViewConceptType
+      # @!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] style
+      #   @return [Style, NilClass]
+      model_attr :style
+
+      # @note viewRefs are pointers to 0-* Diagrams for diagram drill in defined in abstract View Concept
+      # @todo Make this an array
+      # @!attribute [rw] view_refs
+      #   @return [Diagram]
+      model_attr :view_refs, comparison_attr: :id, writable: true
+
+      # @todo document where this comes from
+      # @!attribute [r] content
+      #   @return [String, NilClass]
+      model_attr :content
+
+      # This is needed for various calculations
+      # @!attribute [r] parent
+      #   @return [ViewNode]
+      model_attr :parent, writable: true, comparison_attr: :no_compare
+
+      # ViewNodeType
+      # @!attribute [r] bounds
+      #   @return [Bounds, NilClass]
+      model_attr :bounds
+
+      # Container - container doesn't distinguish between nodes and connections
+      # @!attribute [r] nodes
+      #   @return [Array<ViewNode>]
+      model_attr :nodes
+      # @!attribute [r] connections
+      #   @return [Array<Connection>]
+      model_attr :connections
+
+      # @note properties is not in the model under element, it's added under Real Element
+      # @todo Delete this - I think it's not used
+      # @!attribute [r] properties
+      #   @return [Array<Property>]
+      model_attr :properties
+
+      # Element
+      # @!attribute [rw] element
+      #   @return [Element, NilClass]
+      model_attr :element, writable: true, comparison_attr: :id
+      # Archi format, selects the shape of element (for elements that can have two or more shapes)
+      # @!attribute [r] child_type
+      #   @return [Int, NilClass]
+      model_attr :child_type
+
+      # @!attribute [r] diagram
+      #   @return [Diagram, NilClass]
+      model_attr :diagram, comparison_attr: :no_compare
+
+      # Node type to allow a Label in a Artifact. the "label" element holds the info for the @note.
+      # Label View Nodes have the following attributes
+
+      # conceptRef is a reference to an concept for this particular label, along with the attributeRef
+      # which references the particular concept's part which this label represents.
+      # @!attribute [r] concept_ref
+      #   @return [String]
+      model_attr :concept_ref
+      # conceptRef is a reference to an concept for this particular label, along with the partRef
+      # which references the particular concept's part which this label represents. If this attribute
+      # is set, then there is no need to add a label tag in the Label parent (since it is contained in the model).
+      # the XPATH statement is meant to be interpreted in the context of what the conceptRef points to.
+      # @!attribute [r] xpath_path
+      #   @return [String, NilClass]
+      model_attr :xpath_path
+
+      def initialize(id:, name: nil, documentation: nil, type: nil, parent: nil,
+                     style: nil, view_refs: [], content: nil, bounds: nil,
+                     nodes: [], connections: [], properties: [], element: nil,
+                     child_type: nil, diagram:, concept_ref: nil, xpath_path: nil)
+        @id = id
+        @name = name
+        @documentation = documentation
+        @type = type
+        @parent = parent
+        @style = style
+        @view_refs = view_refs
+        @content = content
+        @bounds = bounds
+        @nodes = nodes
+        @connections = connections
+        @properties = properties
+        @element = element
+        @child_type = child_type
+        @diagram = diagram
+        @concept_ref = concept_ref
+        @xpath_path = xpath_path
+      end
 
       def replace(entity, with_entity)
-        if (archimate_element == entity.id)
-          @archimate_element = with_entity.id
-          @element = with_entity
-        end
-        if (model == entity.id)
-          @model = with_entity.id
-          @model_element = with_entity
-        end
+        @element = with_entity if element.id == entity.id
+        @view_refs = with_entity if view_refs == entity
       end
 
       def to_s
-        "ViewNode[#{name || ''}](#{in_model.lookup(archimate_element) if archimate_element && in_model})"
+        "ViewNode[#{name || ''}](#{element if element})"
       end
 
       def description
@@ -60,14 +156,6 @@ module Archimate
         ].compact.join(" ")
       end
 
-      def element
-        @element ||= in_model.lookup(archimate_element)
-      end
-
-      def model_element
-        @model_element ||= in_model.lookup(model)
-      end
-
       def all_nodes
         nodes.inject(Array.new(nodes)) { |child_ary, child| child_ary.concat(child.all_nodes) }
       end
@@ -78,30 +166,36 @@ module Archimate
 
       def referenced_identified_nodes
         (nodes + connections).reduce(
-          (target_connections + [archimate_element]).compact
+          [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)
+        diagram # ||= ->(node) { node = node.parent until node.nil? || node.is_a?(Diagram) }.call(self)
       end
 
-      # TODO: Is this true for all or only Archi models?
+      # @todo Is this true for all or only Archi models?
       def absolute_position
-        offset = bounds || Archimate::DataModel::Bounds.zero
-        el = parent.parent
+        offset = bounds || Bounds.zero
+        el = parent
         while el.respond_to?(:bounds) && el.bounds
           bounds = el.bounds
-          offset = offset.with(x: (offset.x || 0) + (bounds.x || 0), y: (offset.y || 0) + (bounds.y || 0))
-          el = el.parent.parent
+          offset = Bounds.new(offset.to_h.merge(x: (offset.x || 0) + (bounds.x || 0), y: (offset.y || 0) + (bounds.y || 0)))
+          el = el.parent
         end
         offset
       end
-    end
 
-    Dry::Types.register_class(ViewNode)
+      def target_connections
+        diagram
+          .connections
+          .select { |conn| conn.target&.id == id }
+          .map(&:id)
+      end
+    end
   end
 end
 

data/lib/archimate/data_model/viewpoint.rb

@@ -2,86 +2,62 @@
 
 module Archimate
   module DataModel
-    # Basic Viewpoints
-    # Category:Composition Viewpoints that defines internal compositions and aggregations of elements.
-    COMPOSITION_VIEWPOINTS = [
-      "Organization",
-      "Application Platform",
-      "Information Structure",
-      "Technology",
-      "Layered",
-      "Physical"
-    ].freeze
-
-    # Category:Support Viewpoints where you are looking at elements that are supported by other elements. Typically from one layer and upwards to an above layer.
-    SUPPORT_VIEWPOINTS = [
-      "Product",
-      "Application Usage",
-      "Technology Usage"
-    ].freeze
-
-    # Category:Cooperation Towards peer elements which cooperate with each other. Typically across aspects.
-    COOPERATION_VIEWPOINTS = [
-      "Business Process Cooperation",
-      "Application Cooperation"
-    ].freeze
-
-    # Category:Realization Viewpoints where you are looking at elements that realize other elements. Typically from one layer and downwards to a below layer.
-    REALIZATION_VIEWPOINTS = [
-      "Service Realization",
-      "Implementation and Deployment",
-      "Goal Realization",
-      "Goal Contribution",
-      "Principles",
-      "Requirements Realization",
-      "Motivation"
-    ].freeze
-
-    # Strategy Viewpoints
-    STRATEGY_VIEWPOINTS = [
-      "Strategy",
-      "Capability Map",
-      "Outcome Realization",
-      "Resource Map"
-    ].freeze
-
-    # Implementation and Migration Viewpoints
-    IMPLEMENTATION_AND_MIGRATION_VIEWPOINTS = [
-      "Project",
-      "Migration",
-      "Implementation and Migration"
-    ].freeze
-
-    # Other Viewpoints
-    Other_Viewpoints = %w[Stakeholder].freeze
-
-    VIEWPOINTS_ENUM = [].concat(
-                        [COMPOSITION_VIEWPOINTS, SUPPORT_VIEWPOINTS, COOPERATION_VIEWPOINTS,
-                         REALIZATION_VIEWPOINTS, STRATEGY_VIEWPOINTS,
-                         IMPLEMENTATION_AND_MIGRATION_VIEWPOINTS].flatten
-                      )
-
-    ViewpointType = Strict::String.enum(*VIEWPOINTS_ENUM).optional
-
-    ViewpointContentEnum = Strict::String.enum(%w[Details Coherence Overview])
-    ViewpointContent = Strict::Array.member(ViewpointContentEnum).default([])
-
-    ViewpointPurposeEnum = Strict::String.enum(%w[Designing Deciding Informing])
-    ViewpointPurpose = Strict::Array.member(ViewpointPurposeEnum).default([])
-
-    class Viewpoint < NamedReferenceable
-      using DataModel::DiffableArray
-      using DataModel::DiffablePrimitive
-
-      attribute :concern, ConcernList
-      attribute :viewpointPurpose, ViewpointPurpose.optional
-      attribute :viewpointContent, ViewpointContent.optional
-      attribute :allowedElementTypes, AllowedElementTypes
-      attribute :allowedRelationshipTypes, AllowedRelationshipTypes
-      attribute :modelingNotes, Strict::Array.member(ModelingNote).default([])
+    class Viewpoint
+      include Comparison
+
+      # @!attribute [r] id
+      #   @return [String]
+      model_attr :id
+      # @!attribute [r] name
+      #   @return [LangString]
+      model_attr :name
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString]
+      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
+      # type here was used for the Element/Relationship/Diagram type
+      # @!attribute [r] type
+      #   @return [String, NilClass]
+      model_attr :type
+      # @!attribute [r] concerns
+      #   @return [Array<Concern>]
+      model_attr :concerns
+      # @!attribute [r] viewpoint_purposes
+      #   @return [Array<ViewpointPurposeEnum>]
+      model_attr :viewpoint_purposes
+      # @!attribute [r] viewpoint_contents
+      #   @return [Array<ViewpointContentEnum>]
+      model_attr :viewpoint_contents
+      # @!attribute [r] allowed_element_types
+      #   @return [Array<ElementType>]
+      model_attr :allowed_element_types
+      # @!attribute [r] allowed_relationship_types
+      #   @return [Array<RelationshipType>]
+      model_attr :allowed_relationship_types
+      # @!attribute [r] modeling_notes
+      #   @return [Array<ModelingNote>]
+      model_attr :modeling_notes
+
+      def initialize(id:, name:, documentation: nil, type: nil,
+                     concerns: [], viewpoint_purposes: [],
+                     viewpoint_contents: [], allowed_element_types: [],
+                     allowed_relationship_types: [], modeling_notes: [])
+        @id = id
+        @name = name
+        @documentation = documentation
+        @type = type
+        @concerns = concerns
+        @viewpoint_purposes = viewpoint_purposes
+        @viewpoint_contents = viewpoint_contents
+        @allowed_element_types = allowed_element_types
+        @allowed_relationship_types = allowed_relationship_types
+        @modeling_notes = modeling_notes
+      end
     end
-
-    Dry::Types.register_class(Viewpoint)
-    ViewpointList = Strict::Array.member(Viewpoint).default([])
   end
 end