archimate 1.2.1 → 2.0.0

data/lib/archimate/data_model/metadata.rb

@@ -6,9 +6,16 @@ module Archimate
     # about a meta-data element's parent only.
     #
     # One or more different meta-data models may be declared as child extensions of a meta-data element.
-    class Metadata < ArchimateNode
-      attribute :schema_infos, Strict::Array.member(SchemaInfo).default([])
+    class Metadata
+      include Comparison
+
+      # @!attribute [r] schema_infos
+      #   @return [Array<SchemaInfo>]
+      model_attr :schema_infos
+
+      def initialize(schema_infos: [])
+        @schema_infos = schema_infos
+      end
     end
-    Dry::Types.register_class(Metadata)
   end
 end

data/lib/archimate/data_model/model.rb

@@ -3,39 +3,99 @@
 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([])
+    #
+    # It is a container for the elements, relationships, diagrams and
+    # organizations of the model.
+    class Model
+      include Comparison
+
+      # @!attribute [r] id
+      #   @return [String] unique identifier of this model
+      model_attr :id
+      # @!attribute [r] name
+      #   @return [LangString] name of the model
+      model_attr :name
+
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString, NilClass] model documentation
+      model_attr :documentation
+      # @!attribute [r] properties
+      #   @return [Array<Property>] model properties
+      model_attr :properties
+      # @!attribute [r] metadata
+      #   @return [Metadata, NilClass] model metadata
+      model_attr :metadata
+      # @!attribute [r] elements
+      #   @return [Array<Element>]
+      model_attr :elements
+      # @!attribute [r] relationships
+      #   @return [Array<Relationship>]
+      model_attr :relationships
+      # @!attribute [r] organizations
+      #   @return [Array<Organization>]
+      model_attr :organizations
+      # @!attribute [r] property_definitions
+      #   @return [Array<PropertyDefinition>]
+      model_attr :property_definitions
+      # @!attribute [r] version
+      #   @return [String, NilClass]
+      model_attr :version
+      # @!attribute [r] diagrams
+      #   @return [Array<Diagram>]
+      model_attr :diagrams
+      # @!attribute [r] viewpoints
+      #   @return [Array<Viewpoint>]
+      model_attr :viewpoints
+
       # 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 [r] filename
+      #   @return [String]
+      model_attr :filename
+      # @see Archimate::SUPPORTED_FORMATS
+      # @!attribute [r] file_format
+      #   @return [Symbol, NilClass] supported Archimate format [Archimate::SUPPORTED_FORMATS] or +nil+
+      model_attr :file_format
+      # @!attribute [r] archimate_version
+      #   @return [Symbol] one of [Archimate::ARCHIMATE_VERSIONS], default +:archimate_3_0+
+      model_attr :archimate_version
 
-      attribute :namespaces, Strict::Hash.default({})
-      attribute :schema_locations, Strict::Array.member(Strict::String).default([])
+      # @!attribute [r] namespaces
+      #   @return [Hash]
+      model_attr :namespaces
+      # @!attribute [r] schema_locations
+      #   @return [Array<String>]
+      model_attr :schema_locations
 
-      def initialize(attributes)
-        super
-        self.in_model = self
-        self.parent = nil
-        rebuild_index
-      end
+      # # @return [Array<AnyElement>]
+      # model_attr :other_elements
+      # # @return [Array<AnyAttribute>]
+      # model_attr :other_attributes
 
-      def with(options = {})
-        super.organize
+      # Constructor
+      def initialize(id:, name:, documentation: nil, properties: [],
+                     metadata: nil, elements: [], relationships: [],
+                     organizations: [], property_definitions: [],
+                     version: nil, diagrams: [], viewpoints: [],
+                     filename: nil, file_format: nil, archimate_version: :archimate_3_0,
+                     namespaces: {}, schema_locations: [])
+        @id = id
+        @name = name
+        @documentation = documentation
+        @properties = properties
+        @metadata = metadata
+        @elements = elements
+        @relationships = relationships
+        @organizations = organizations
+        @property_definitions = property_definitions
+        @version = version
+        @diagrams = diagrams
+        @viewpoints = viewpoints
+        @filename = filename
+        @file_format = file_format
+        @archimate_version = archimate_version
+        @namespaces = namespaces
+        @schema_locations = schema_locations
+        rebuild_index
       end
 
       def lookup(id)
@@ -43,67 +103,27 @@ module Archimate
         @index_hash[id]
       end
 
+      # Called only by [Lint::DuplicateEntities]
       def entities
         @index_hash.values
       end
 
+      # Called only by [Diff::Merge]
       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}"
+        "#{Archimate::Color.data_model('Model')}<#{id}>[#{Archimate::Color.color(name, %i[white underline])}]"
       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.
+      #
+      # @note this is only called by [Diff::Merge]
       def organize
         []
           .concat(elements)
@@ -117,34 +137,82 @@ module Archimate
         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
+      # Only used by [Diff::DeletedItemsReferencedConflict]
+      def referenced_identified_nodes
+        classes = [Diagram, ViewNode, Connection, Organization, Relationship].freeze
+        @index_hash
+          .values
+          .select { |entity| classes.include?(entity.class) }
+          .map(&:referenced_identified_nodes)
+          .flatten
+          .uniq
+      end
+
+      # This is used only by the model [Cli::Cleanup] class.
+      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
+
+      # Only used by [#find_default_organization]
+      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: LangString.create(name), type: type, items: [], organizations: [], documentation: nil)
+        register(organization, organizations)
+        organizations.push(organization)
+        organization
+      end
+
+      def build_index
+        @index_hash = { id => self }
+        elements.each { |ref| @index_hash[ref.id] = ref }
+        relationships.each { |ref| @index_hash[ref.id] = ref }
+        diagrams.each { |dia| @index_hash[dia.id] = index_view_nodes(dia) }
+        property_definitions.each { |ref| @index_hash[ref.id] = ref }
+        index_organizations(self)
+        @index_hash
       end
 
       def default_organization_for(item)
         case item
         when Element
           case item.layer
-          when "Strategy"
+          when Layers::Strategy
             find_default_organization("strategy", "Strategy")
-          when "Business"
+          when Layers::Business
             find_default_organization("business", "Business")
-          when "Application"
+          when Layers::Application
             find_default_organization("application", "Application")
-          when "Technology"
+          when Layers::Technology
             find_default_organization("technology", "Technology")
-          when "Physical"
+          when Layers::Physical
             find_default_organization("physical", "Physical")
-          when "Motivation"
+          when Layers::Motivation
             find_default_organization("motivation", "Motivation")
-          when "Implementation and Migration"
+          when Layers::Implementation_and_migration
             find_default_organization("implementation_migration", "Implementation & Migration")
-          when "Connectors"
+          when Layers::Connectors
             find_default_organization("connectors", "Connectors")
           else
-            raise StandardError, "Unexpected Element Layer: #{item.layer.inspect} for item type #{item.type.inspect}"
+            raise StandardError, "Unexpected Element Layer: #{item.layer} for item type #{item.type}"
           end
         when Relationship
           find_default_organization("relations", "Relations")
@@ -155,6 +223,10 @@ module Archimate
         end
       end
 
+      def find_by_class(klass)
+        @index_hash.values.select { |item| item.is_a?(klass) }
+      end
+
       def find_default_organization(type, name)
         result = organizations.find { |f| f.type == type }
         return result unless result.nil?
@@ -163,55 +235,50 @@ module Archimate
         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
+      def find_in_organizations(item, _fs = nil)
+        find_by_class(DataModel::Organization).select { |f| f.items.include?(item.id) }.first
       end
 
+      # Only used by [#unreferenced_nodes]
       def identified_nodes
-        @index_hash.values.select { |node| node.is_a? Referenceable }
+        @index_hash.values.select { |node| node.respond_to? :id }
       end
 
-      def unreferenced_nodes
-        identified_nodes - referenced_identified_nodes
+      # @todo make this private - maybe move to [Organization]
+      def index_organizations(ref)
+        ref.organizations.each do |org|
+          @index_hash[org.id] = index_organizations(org)
+        end
+        ref
       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)
+      # @todo make this private - maybe move to [ViewNode]
+      def index_view_nodes(ref)
+        ref.nodes.each do |node|
+          @index_hash[node.id] = index_view_nodes(node)
         end
+        ref.connections.each { |con| @index_hash[con.id] = con }
+        ref
       end
 
-      private
+      def make_unique_id
+        unique_id = random_id
+        unique_id = random_id while @index_hash.key?(unique_id)
+        unique_id
+      end
 
       def random_id
         @random ||= Random.new
         format("%08x", @random.rand(0xffffffff))
       end
+
+      def register(node, _parent)
+        @index_hash[node.id] = node
+      end
+
+      def deregister(node)
+        @index_hash.delete(node.id)
+      end
     end
   end
 end

data/lib/archimate/data_model/modeling_note.rb

@@ -4,10 +4,21 @@ 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)
+    class ModelingNote
+      include Comparison
+
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString]
+      model_attr :documentation
       # `type` attribute expresses a type for the notes, e.g. OCL for OCL rules.
-      attribute :type, Strict::String.optional
+      # @!attribute [r] type
+      #   @return [String, NilClass]
+      model_attr :type
+
+      def initialize(documentation:, type: nil)
+        @documentation = documentation
+        @type = type
+      end
     end
   end
 end

data/lib/archimate/data_model/organization.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
     # An organization element represents a structural node in a particular organization of the model concepts.
@@ -10,19 +11,50 @@ module Archimate
     #
     # 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([])
+    # @note that Organization must fit into a tree structure (so strictly nested).
+    class Organization
+      include Comparison
+
+      # Format should match +/[[[:alpha:]]_][w-.]*/+ to be valid for Archimate
+      # Model exchange format
+      # @!attribute [r] id
+      #   @return [String, NilClass]
+      model_attr :id
+      # LabelGroup in the XSD
+      # @!attribute [r] name
+      #   @return [LangString, NilClass]
+      model_attr :name
+      # I believe this is used only for Archi formats
+      # @!attribute [r] type
+      #   @return [String, NilClass]
+      model_attr :type
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString, NilClass]
+      model_attr :documentation
+      # @!attribute [rw] items
+      #   @return [Array<Object>]
+      model_attr :items, writable: true
+      # item in the XSD
+      # @!attribute [rw] organizations
+      #   @return [Array<Organization>]
+      model_attr :organizations, writable: true
+      # # @return [Array<AnyElement>]
+      # model_attr :other_elements
+      # # @return [Array<AnyAttribute>]
+      # model_attr :other_attributes
+
+      def initialize(id: nil, name: nil, type: nil, documentation: nil,
+                     items: [], organizations: [])
+        @id = id
+        @name = name
+        @type = type
+        @documentation = documentation
+        @items = items
+        @organizations = organizations
+      end
 
       def to_s
-        "#{Archimate::Color.data_model('Organization')}<#{id}>[#{Archimate::Color.color(name, [:white, :underline])}]"
+        "#{Archimate::Color.data_model('Organization')}<#{id}>[#{Archimate::Color.color(name, %i[white underline])}]"
       end
 
       def referenced_identified_nodes
@@ -32,9 +64,8 @@ module Archimate
       end
 
       def remove(id)
-        items.delete(id)
+        items.delete_if { |item| item.id == id }
       end
     end
-    Dry::Types.register_class(Organization)
   end
 end