archimate 1.1.0

data/lib/archimate/data_model/model.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # This is the root model type.
+    # It is a container for the elements, relationships, diagrams and organizations of the model.
+    class Model < NamedReferenceable
+      using DataModel::DiffableArray
+      using DataModel::DiffablePrimitive
+
+      ARRAY_RE = Regexp.compile(/\[(\d+)\]/)
+
+      attribute :properties, Strict::Array.member(Property).default([]) # Properties.optional
+      attribute :metadata, Metadata.optional
+      attribute :elements, Strict::Array.member(Element).default([])
+      attribute :relationships, Strict::Array.member(Relationship).default([])
+      attribute :organizations, Strict::Array.member(Organization).default([])
+      attribute :property_definitions, Strict::Array.member(PropertyDefinition).default([])
+      attribute :version, Strict::String.optional
+      attribute :diagrams, Strict::Array.member(Diagram).default([])
+      attribute :viewpoints, Strict::Array.member(Viewpoint).default([])
+      # Following attributes are to hold info on where the model came from
+      attribute :filename, Strict::String.optional
+      attribute :file_format, Strict::Symbol.enum(*Archimate::SUPPORTED_FORMATS).optional
+      attribute :archimate_version, Strict::Symbol.default(:archimate_3_0).enum(*Archimate::ARCHIMATE_VERSIONS)
+
+      attribute :namespaces, Strict::Hash.default({})
+      attribute :schema_locations, Strict::Array.member(Strict::String).default([])
+
+      def initialize(attributes)
+        super
+        self.in_model = self
+        self.parent = nil
+        rebuild_index
+      end
+
+      def with(options = {})
+        super.organize
+      end
+
+      def lookup(id)
+        rebuild_index(id) unless @index_hash.include?(id)
+        @index_hash[id]
+      end
+
+      def entities
+        @index_hash.values
+      end
+
+      def rebuild_index(missing_id = :model_creation_event)
+        return self unless missing_id
+        @index_hash = build_index
+        self
+      end
+
+      def register(node, parent)
+        node.in_model = self
+        node.parent = parent
+        @index_hash[node.id] = node
+      end
+
+      def deregister(node)
+        @index_hash.delete(node.id)
+      end
+
+      def find_by_class(klass)
+        @index_hash.values.select { |item| item.is_a?(klass) }
+      end
+
+      def to_s
+        "#{Archimate::Color.data_model('Model')}<#{id}>[#{Archimate::Color.color(name, [:white, :underline])}]"
+      end
+
+      # TODO: make these DSL like things added dynamically
+      def application_components
+        elements.select { |element| element.type == "ApplicationComponent" }
+      end
+
+      def element_type_names
+        elements.map(&:type).uniq
+      end
+
+      def elements_with_type(el_type)
+        elements.select { |element| element.type == el_type }
+      end
+
+      # TODO: make these DSL like things added dynamically
+      def all_properties
+        @index_hash.values.each_with_object([]) do |i, a|
+          a.concat(i.properties) if i.respond_to?(:properties)
+        end
+      end
+
+      # TODO: refactor to use property def structure instead of separate property objects
+      def property_keys
+        all_properties.map(&:key).uniq
+      end
+
+      # TODO: refactor to use property def structure instead of separate property objects
+      def property_def_id(key)
+        "propid-#{property_keys.index(key) + 1}"
+      end
+
+      # Iterate through the model and ensure that elements, relationships, and
+      # diagrams are all present in the model's organizations. If an item is missing
+      # then move it into the default top-level element for the item type.
+      def organize
+        []
+          .concat(elements)
+          .concat(relationships)
+          .concat(diagrams).each do |item|
+            if find_in_organizations(item).nil?
+              default_organization = default_organization_for(item)
+              default_organization.items.push(item.id) unless default_organization.items.include?(item.id)
+            end
+          end
+        self
+      end
+
+      def find_in_organizations(item, _fs = nil)
+        result = find_by_class(DataModel::Organization).select { |f| f.items.include?(item.id) }
+        # raise "Program Error! #{item.id} is located in more than one organization. #{result.map(&:to_s).inspect}\n#{item}\n" if result.size > 1
+        result.empty? ? nil : result.first
+      end
+
+      def default_organization_for(item)
+        case item
+        when Element
+          case item.layer
+          when "Strategy"
+            find_default_organization("strategy", "Strategy")
+          when "Business"
+            find_default_organization("business", "Business")
+          when "Application"
+            find_default_organization("application", "Application")
+          when "Technology"
+            find_default_organization("technology", "Technology")
+          when "Physical"
+            find_default_organization("physical", "Physical")
+          when "Motivation"
+            find_default_organization("motivation", "Motivation")
+          when "Implementation and Migration"
+            find_default_organization("implementation_migration", "Implementation & Migration")
+          when "Connectors"
+            find_default_organization("connectors", "Connectors")
+          else
+            raise StandardError, "Unexpected Element Layer: #{item.layer.inspect} for item type #{item.type.inspect}"
+          end
+        when Relationship
+          find_default_organization("relations", "Relations")
+        when Diagram
+          find_default_organization("diagrams", "Views")
+        else
+          raise StandardError, "Unexpected item type #{item.class}"
+        end
+      end
+
+      def find_default_organization(type, name)
+        result = organizations.find { |f| f.type == type }
+        return result unless result.nil?
+        result = organizations.find { |f| f.name == name }
+        return result unless result.nil?
+        add_organization(type, name)
+      end
+
+      def add_organization(type, name)
+        raise "Program Error: #{organizations.inspect}" unless organizations.none? { |f| f.type == type || f.name == name }
+        organization = Organization.new(id: make_unique_id, name: name, type: type, items: [], organizations: [])
+        register(organization, organizations)
+        organizations.push(organization)
+        organization
+      end
+
+      def make_unique_id
+        unique_id = random_id
+        unique_id = random_id while @index_hash.key?(unique_id)
+        unique_id
+      end
+
+      def referenced_identified_nodes
+        super.uniq
+      end
+
+      def identified_nodes
+        @index_hash.values.select { |node| node.is_a? Referenceable }
+      end
+
+      def unreferenced_nodes
+        identified_nodes - referenced_identified_nodes
+      end
+
+      def merge_entities(master_entity, copies)
+        copies.delete(master_entity)
+        copies.each do |copy|
+          entities.each do |entity|
+            case entity
+            when entity == master_entity
+              master_entity.merge(copy)
+            when Organization
+              entity.remove(copy.id)
+            when ViewNode, Relationship, Connection
+              entity.replace(copy, master_entity)
+            end
+          end
+          deregister(copy)
+        end
+      end
+
+      private
+
+      def random_id
+        @random ||= Random.new
+        format("%08x", @random.rand(0xffffffff))
+      end
+    end
+  end
+end

data/lib/archimate/data_model/modeling_note.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # This is a set of notes to the modeler on how to use and model with this viewpoint. Could contain rules
+    # or constraints. The part hold the information for this element.
+    class ModelingNote < ArchimateNode
+      attribute :documentation, DocumentationGroup # .constrained(min_size: 1)
+      # `type` attribute expresses a type for the notes, e.g. OCL for OCL rules.
+      attribute :type, Strict::String.optional
+    end
+  end
+end

data/lib/archimate/data_model/named_referenceable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    class NamedReferenceable < Referenceable
+      # Note: minimum 1 name is required for a Named Referenceable
+      # attribute :name, Strict::Array.member(LangString).default([]) .constrained(min_size: 1)
+      # attribute :documentation, DocumentationGroup
+      # attribute :grp_any, Strict::Array.member(AnyGroup).default([])
+    end
+
+    Dry::Types.register_class(NamedReferenceable)
+  end
+end

data/lib/archimate/data_model/organization.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    # An organization element represents a structural node in a particular organization of the model concepts.
+    # An organization element may be a parent or sibling of other organization elements,
+    # each one representing a unique structural node.
+    #
+    # An organization element may reference an ArchiMate element, ArchiMate relationship,
+    # or nothing (in which case it is a structural container)
+    #
+    # An organization has no meaning unless it has at least child organization element.
+    #
+    # Note that Organization must fit into a tree structure (so strictly nested).
+    class Organization < ArchimateNode # was Referenceable
+      attribute :id, Identifier.optional # .constrained(format: /[[[:alpha:]]_][w-.]*/)
+      attribute :name, LangString.optional # LabelGroup in the XSD, TODO: this is a LangString collection
+      attribute :type, Strict::String.optional # I believe this is used only for Archi formats
+      attribute :documentation, DocumentationGroup
+      attribute :items, Strict::Array.member(Identifier).default([]) # TODO: Convert this to referenceable
+      attribute :organizations, Strict::Array.member(Organization).default([]) # item in the XSD
+      # attribute :other_elements, Strict::Array.member(AnyElement).default([])
+      # attribute :other_attributes, Strict::Array.member(AnyAttribute).default([])
+
+      def to_s
+        "#{Archimate::Color.data_model('Organization')}<#{id}>[#{Archimate::Color.color(name, [:white, :underline])}]"
+      end
+
+      def referenced_identified_nodes
+        organizations.reduce(items) do |a, e|
+          a.concat(e.referenced_identified_nodes)
+        end
+      end
+
+      def remove(id)
+        items.delete(id)
+      end
+    end
+    Dry::Types.register_class(Organization)
+  end
+end

data/lib/archimate/data_model/property.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    # A Property instance type declaring the reference to a Property definition and containing the Property value.
+    class Property < ArchimateNode
+      attribute :values, Strict::Array.member(LangString).default([]) # .constrained(min_size: 1)
+      attribute :property_definition, PropertyDefinition
+
+      def to_s
+        "Property(key: #{property_definition.name}, value: #{value || 'no value'})"
+      end
+
+      def key
+        property_definition.name
+      end
+
+      def value
+        values.first
+      end
+    end
+
+    Dry::Types.register_class(Property)
+    PropertiesList = Strict::Array.member(Property).default([])
+  end
+end

data/lib/archimate/data_model/property_definition.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # A Property definition type containing its unique identifier, name, and data type.
+    class PropertyDefinition < NamedReferenceable
+      attribute :value_type, DataType
+
+      def self.identifier_for_key(key)
+        (self.class.hash ^ key.hash).to_s(16)
+      end
+    end
+
+    Dry::Types.register_class(PropertyDefinition)
+  end
+end

data/lib/archimate/data_model/referenceable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # Something that can be referenced in the model.
+    class Referenceable < ArchimateNode
+      attribute :id, Identifier
+      attribute :name, LangString.optional # TODO: Strict::Array.member(LangString).constrained(min_size: 1)
+
+      attribute :documentation, DocumentationGroup
+      # attribute :grp_any, Strict::Array.member(AnyNode).default([])
+      # attribute :other_attributes, Strict::Array.member(AnyAttribute).default([])
+      # attribute :properties, PropertiesList # Note: Referenceable doesn't have properties in the spec
+      attribute :type, Strict::String.optional # Note: type here was used for the Element/Relationship/Diagram type
+
+      private
+
+      def find_my_index
+        id
+      end
+
+      # name isn't merged
+      def merge(node)
+        documentation.concat(node.documentation)
+        properties.concat(node.properties)
+      end
+    end
+  end
+end

data/lib/archimate/data_model/relationship.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    RelationshipTypeEnum = %w[
+      Composition
+      Aggregation
+      Assignment
+      Realization
+      Serving
+      Access
+      Influence
+      Triggering
+      Flow
+      Specialization
+      Association
+    ].freeze
+    RelationshipType = Strict::String.enum(*RelationshipTypeEnum)
+    AllowedRelationshipTypes = Strict::Array.member(RelationshipType).default([])
+
+    AccessType = %w[Access Read Write ReadWrite]
+    AccessTypeEnum = Strict::String.enum(*AccessType)
+
+    # 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.
+    class Relationship < Concept
+      attribute :source, Identifier
+      attribute :target, Identifier
+      attribute :access_type, AccessTypeEnum.optional
+
+      def replace(entity, with_entity)
+        @source = with_entity.id if source == entity.id
+        @target = with_entity.id if target == entity.id
+      end
+
+      def to_s
+        Archimate::Color.color(
+          "#{Archimate::Color.data_model(type)}<#{id}>[#{Archimate::Color.color(name&.strip || '', %i[black underline])}]",
+          :on_light_magenta
+        ) + " #{source_element} -> #{target_element}"
+      end
+
+      def description
+        [
+          name.nil? ? nil : "#{name}:",
+          FileFormats::ArchimateV2::RELATION_VERBS.fetch(type, nil)
+        ].compact.join(" ")
+      end
+
+      def referenced_identified_nodes
+        [@source, @target].compact
+      end
+
+      def source_element
+        element_by_id(source)
+      end
+
+      def target_element
+        element_by_id(target)
+      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)
+      #     3. Child `properties`
+      #     4. Any other elements
+      # source and target don't change on a merge
+      def merge(relationship)
+        super
+        access_type ||= relationship.access_type
+      end
+    end
+    Dry::Types.register_class(Relationship)
+  end
+end

data/lib/archimate/data_model/schema_info.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    class SchemaInfo < ArchimateNode
+      using DiffablePrimitive
+
+      attribute :schema, Strict::String.optional
+      attribute :schemaversion, Strict::String.optional
+      attribute :elements, Strict::Array.member(AnyElement).default([])
+
+      def to_s
+        "#{type.light_black}[#{schema} #{schemaversion}]"
+      end
+    end
+    Dry::Types.register_class(SchemaInfo)
+  end
+end

data/lib/archimate/data_model/style.rb

@@ -0,0 +1,32 @@
+# 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
+
+      def to_s
+        attr_name_vals = struct_instance_variables.map { |k| "#{k}: #{self[k]}" }.join(", ")
+        "Style(#{attr_name_vals})"
+      end
+
+      def text_align
+        case text_alignment
+        when "1"
+          "left"
+        when "2"
+          "center"
+        when "3"
+          "right"
+        end
+      end
+    end
+
+    Dry::Types.register_class(Style)
+  end
+end

data/lib/archimate/data_model/view.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # This is a container for all of the Views in the model.
+    class View < NamedReferenceable
+      attribute :properties, PropertiesList
+      attribute :viewpoint_type, Strict::String.optional # TODO: ViewpointType.optional is better, but is ArchiMate version dependent. Need to figure that out
+      attribute :viewpoint, Viewpoint.optional
+    end
+  end
+end

data/lib/archimate/data_model/view_concept.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # This is an abstract super-type of Node and Connection.
+    class ViewConcept < ArchimateNode
+      attribute :id, Identifier
+      attribute :labels, Strict::Array.member(LangString).constrained(min_size: 1)
+      attribute :documentation, DocumentationGroup
+      attribute :style, Style.optional
+      # the "viewRef" of an "Concept" is to a view that allows drill-down diagrams.
+      attribute :view_refs, Strict::Array.member(Identifier)
+      # TODO: any other attributes
+    end
+
+    Dry::Types.register_class(ViewConcept)
+  end
+end

data/lib/archimate/data_model/view_node.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    PositiveInteger = Strict::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
+
+      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
+      end
+
+      def to_s
+        "ViewNode[#{name || ''}](#{in_model.lookup(archimate_element) if archimate_element && in_model})"
+      end
+
+      def description
+        [
+          name.nil? ? nil : name.to_s,
+          element.nil? ? nil : element.name,
+          element&.type.nil? ? nil : "(#{element.type})"
+        ].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
+
+      def child_id_hash
+        nodes.each_with_object(id => self) { |i, a| a.merge!(i.child_id_hash) }
+      end
+
+      def referenced_identified_nodes
+        (nodes + connections).reduce(
+          (target_connections + [archimate_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
+
+      # TODO: Is this true for all or only Archi models?
+      def absolute_position
+        offset = bounds || Archimate::DataModel::Bounds.zero
+        el = parent.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
+        end
+        offset
+      end
+    end
+
+    Dry::Types.register_class(ViewNode)
+  end
+end
+
+# Type is one of:  ["archimate:DiagramModelReference", "archimate:Group", "archimate:DiagramObject"]
+# textAlignment "2"
+# model is on only type of archimate:DiagramModelReference and is id of another element type=archimate:ArchimateDiagramModel
+# fillColor, lineColor, fontColor are web hex colors
+# targetConnections is a string of space separated ids to connections on diagram objects found on DiagramObject
+# archimateElement is an id of a model element found on DiagramObject types
+# font is of this form: font="1|Arial|14.0|0|WINDOWS|1|0|0|0|0|0|0|0|0|1|0|0|0|0|Arial"