archimate 2.0.1 → 2.0.2

data/lib/archimate/data_model/lang_string.rb

@@ -10,58 +10,28 @@ module Archimate
       extend Forwardable
 
       def_delegators :@default_text, :strip, :tr, :+, :gsub, :sub, :downcase, :empty?, :split, :size, :include?
-      # def_delegators :@lang_hash, :size
 
       # @!attribute [r] lang_hash
-      #   @return [Hash]
+      # @return [Hash]
       model_attr :lang_hash
       # @!attribute [r] default_lang
-      #   @return [String, NilClass]
+      # @return [String, NilClass]
       model_attr :default_lang
       # @!attribute [r] default_text
-      #   @return [String]
+      # @return [String]
       model_attr :default_text
 
-      # def self.default_lang
-      #   Archimate::Config.instance.default_lang
-      # end
-
       def self.string(str, lang = nil)
         return nil if !str || str.strip.empty?
-        str = str.strip
-        lang = nil if !lang || lang.empty?
-        new(
-          lang_hash: { lang => str },
-          default_lang: lang,
-          default_text: str
-        )
-      end
-
-      def self.create(copy)
-        case copy
-        when String
-          string(copy)
-        when LangString
-          copy
-        when Hash
-          lang_hash = copy.fetch(:lang_hash, {})
-          default_lang = copy.fetch(:default_lang, "")
-          default_text = copy.fetch(:default_text, "")
-          return nil if [lang_hash, default_lang, default_text].any? { |i| i && i.empty? }
-          new(
-            lang_hash: lang_hash,
-            default_lang: default_lang,
-            default_text: default_text
-          )
-        end
+        new(str, lang)
       end
 
       # @param [Hash{Symbol => Object},LangString, String] attributes
       # @raise [Struct::Error] if the given attributes don't conform {#schema}
       #   with given {# # constructor_type}
-      def initialize(str = nil, lang_hash: {}, default_lang: nil, default_text: nil)
+      def initialize(str = nil, lang = nil, lang_hash: {}, default_lang: nil, default_text: nil)
         @lang_hash = lang_hash
-        @default_lang = default_lang
+        @default_lang = default_lang || lang
         @default_text = default_text
         case str
         when String
@@ -89,6 +59,10 @@ module Archimate
         end
       end
 
+      def brief_inspect
+        "#{to_s.slice(0, 40).inspect}#{'...' if to_s.size > 40}"
+      end
+
       def by_lang(lang)
         lang_hash.fetch(lang, nil)
       end

data/lib/archimate/data_model/layer.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
+
 require "ruby-enum"
 
 module Archimate
   module DataModel
     class Layer
-      attr_reader :elements
       attr_reader :name
+      attr_reader :background_class
 
       # No user serviceable parts here. don't use me.
-      def initialize(layer = "None", element_names = [])
+      def initialize(layer = "None", background_class = "")
         @symbol = Layer.symbolize(layer)
         @name = layer
-        @elements = element_names
+        @background_class = background_class
       end
 
       def hash
@@ -44,8 +45,6 @@ module Archimate
         @name
       end
 
-      private
-
       def self.symbolize(str)
         return str if str.is_a?(Symbol)
         str.downcase.tr(" ", "_").to_sym

data/lib/archimate/data_model/layers.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "ruby-enum"
 
 module Archimate
@@ -6,57 +7,52 @@ module Archimate
     class Layers
       include Ruby::Enum
 
-      define :Strategy, Layer.new("Strategy", %w[Capability CourseOfAction Resource])
-
-      define :Business, Layer.new("Business", %w[BusinessActor BusinessCollaboration
-             BusinessEvent BusinessFunction
-             BusinessInteraction BusinessInterface
-             BusinessObject BusinessProcess
-             BusinessRole BusinessService
-             Contract Location
-             Meaning Value
-             Product Representation])
-
-      define :Application, Layer.new("Application", %w[ApplicationCollaboration ApplicationComponent
-             ApplicationFunction ApplicationInteraction
-             ApplicationInterface ApplicationService
-             DataObject ApplicationProcess ApplicationEvent])
-
-      define :Technology, Layer.new("Technology", %w[Artifact CommunicationPath
-             Device InfrastructureFunction
-             InfrastructureInterface InfrastructureService
-             Network Node SystemSoftware TechnologyCollaboration
-             TechnologyInterface Path CommunicationNetwork
-             TechnologyFunction TechnologyProcess TechnologyInteraction
-             TechnologyEvent TechnologyService
-             TechnologyObject])
-
-      define :Physical, Layer.new("Physical", %w[Equipment Facility DistributionNetwork Material])
-
-      define :Motivation, Layer.new("Motivation", %w[Assessment Constraint Driver
-             Goal Principle Requirement
-             Stakeholder Outcome])
-
-      define :Implementation_and_migration, Layer.new("Implementation and Migration", %w[Deliverable Gap Plateau
-             WorkPackage ImplementationEvent])
-
-      # @todo Is Connectors used? Should this be none?
-      define :Connectors, Layer.new("Connectors", %w[AndJunction Junction OrJunction])
+      define :Strategy, Layer.new(
+        "Strategy",
+        "archimate-strategy-background"
+      )
+
+      define :Business, Layer.new(
+        "Business",
+        "archimate-business-background"
+      )
+
+      define :Application, Layer.new(
+        "Application",
+        "archimate-application-background"
+      )
+
+      define :Technology, Layer.new(
+        "Technology",
+        "archimate-infrastructure-background"
+      )
+
+      define :Physical, Layer.new(
+        "Physical",
+        "archimate-physical-background"
+      )
+
+      define :Motivation, Layer.new(
+        "Motivation",
+        "archimate-motivation-background"
+      )
+
+      define :Implementation_and_migration, Layer.new(
+        "Implementation and Migration",
+        "archimate-implementation-background"
+      )
+
+      define :Connectors, Layer.new(
+        "Connectors",
+        "archimate-connectors-background"
+      )
+
+      define :Other, Layer.new(
+        "Other",
+        "archimate-other-background"
+      )
 
       define :None, Layer.new("None")
-
-      # def [](name_or_sym)
-      #   case name_or_sym
-      #   when Integer
-      #     @layers[name_or_sym]
-      #   else
-      #     @layers.find { |layer| layer === name_or_sym }
-      #   end
-      # end
-
-      def self.for_element(type)
-        values.find { |layer| layer.elements.include?(type) } || Layers::None
-      end
     end
   end
 end

data/lib/archimate/data_model/location.rb

@@ -15,22 +15,22 @@ module Archimate
       # corner of the diagram to the Top, Left corner of the bounding box of the concept.
       # @note the XSD has this as a NonNegativeInteger
       # @!attribute [r] x
-      #   @return [Float]
+      # @return [Float]
       model_attr :x
       # 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.
       # @note the XSD has this as a NonNegativeInteger
       # @!attribute [r] y
-      #   @return [Float]
+      # @return [Float]
       model_attr :y
 
       # These are holdovers from the archi file format and are only maintained for compatability
       # @!attribute [r] end_x
-      #   @return [Int, NilClass]
-      model_attr :end_x
+      # @return [Int, NilClass]
+      model_attr :end_x, default: nil
       # @!attribute [r] end_y
-      #   @return [Int, NilClass]
-      model_attr :end_y
+      # @return [Int, NilClass]
+      model_attr :end_y, default: nil
 
       def initialize(x:, y:, end_x: nil, end_y: nil)
         @x = x.to_i

data/lib/archimate/data_model/metadata.rb

@@ -10,12 +10,8 @@ module Archimate
       include Comparison
 
       # @!attribute [r] schema_infos
-      #   @return [Array<SchemaInfo>]
-      model_attr :schema_infos
-
-      def initialize(schema_infos: [])
-        @schema_infos = schema_infos
-      end
+      # @return [Array<SchemaInfo>]
+      model_attr :schema_infos, default: []
     end
   end
 end

data/lib/archimate/data_model/model.rb

@@ -10,91 +10,70 @@ module Archimate
       include Comparison
 
       # @!attribute [r] id
-      #   @return [String] unique identifier of this model
+      # @return [String] unique identifier of this model
       model_attr :id
       # @!attribute [r] name
-      #   @return [LangString] name of the model
+      # @return [LangString] name of the model
       model_attr :name
 
       # @!attribute [r] documentation
-      #   @return [PreservedLangString, NilClass] model documentation
-      model_attr :documentation
+      # @return [PreservedLangString, NilClass] model documentation
+      model_attr :documentation, default: nil
       # @!attribute [r] properties
-      #   @return [Array<Property>] model properties
-      model_attr :properties
+      # @return [Array<Property>] model properties
+      model_attr :properties, default: []
       # @!attribute [r] metadata
-      #   @return [Metadata, NilClass] model metadata
-      model_attr :metadata
+      # @return [Metadata, NilClass] model metadata
+      model_attr :metadata, default: nil
       # @!attribute [r] elements
-      #   @return [Array<Element>]
-      model_attr :elements
+      # @return [Array<Element>]
+      model_attr :elements, default: [], referenceable_list: true
       # @!attribute [r] relationships
-      #   @return [Array<Relationship>]
-      model_attr :relationships
+      # @return [Array<Relationship>]
+      model_attr :relationships, default: [], referenceable_list: true
       # @!attribute [r] organizations
-      #   @return [Array<Organization>]
-      model_attr :organizations
+      # @return [Array<Organization>]
+      model_attr :organizations, default: [], referenceable_list: true
       # @!attribute [r] property_definitions
-      #   @return [Array<PropertyDefinition>]
-      model_attr :property_definitions
+      # @return [Array<PropertyDefinition>]
+      model_attr :property_definitions, default: [], referenceable_list: true
       # @!attribute [r] version
-      #   @return [String, NilClass]
-      model_attr :version
+      # @return [String, NilClass]
+      model_attr :version, default: nil
       # @!attribute [r] diagrams
-      #   @return [Array<Diagram>]
-      model_attr :diagrams
+      # @return [Array<Diagram>]
+      model_attr :diagrams, default: [], referenceable_list: true
       # @!attribute [r] viewpoints
-      #   @return [Array<Viewpoint>]
-      model_attr :viewpoints
+      # @return [Array<Viewpoint>]
+      model_attr :viewpoints, default: [], referenceable_list: true
 
       # Following attributes are to hold info on where the model came from
       # @!attribute [r] filename
-      #   @return [String]
-      model_attr :filename
+      # @return [String]
+      model_attr :filename, default: nil
       # @see Archimate::SUPPORTED_FORMATS
       # @!attribute [r] file_format
-      #   @return [Symbol, NilClass] supported Archimate format [Archimate::SUPPORTED_FORMATS] or +nil+
-      model_attr :file_format
+      # @return [Symbol, NilClass] supported Archimate format [Archimate::SUPPORTED_FORMATS] or +nil+
+      model_attr :file_format, default: nil
       # @!attribute [r] archimate_version
-      #   @return [Symbol] one of [Archimate::ARCHIMATE_VERSIONS], default +:archimate_3_0+
-      model_attr :archimate_version
+      # @return [Symbol] one of [Archimate::ARCHIMATE_VERSIONS], default +:archimate_3_0+
+      model_attr :archimate_version, default: :archimate_3_0
 
       # @!attribute [r] namespaces
-      #   @return [Hash]
-      model_attr :namespaces
+      # @return [Hash]
+      model_attr :namespaces, default: {}
       # @!attribute [r] schema_locations
-      #   @return [Array<String>]
-      model_attr :schema_locations
+      # @return [Array<String>]
+      model_attr :schema_locations, default: []
 
-      # # @return [Array<AnyElement>]
-      # model_attr :other_elements
-      # # @return [Array<AnyAttribute>]
-      # model_attr :other_attributes
+      # @return [Array<AnyElement>]
+      model_attr :other_elements, default: []
+      # @return [Array<AnyAttribute>]
+      model_attr :other_attributes, default: []
 
       # 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
+      def initialize(opts = {})
+        super
         rebuild_index
       end
 
@@ -131,7 +110,7 @@ module Archimate
           .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)
+              default_organization.items.push(item) unless default_organization.items.include?(item)
             end
           end
         self
@@ -181,7 +160,14 @@ module Archimate
       # 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)
+        organization = Organization.new(
+          id: make_unique_id,
+          name: LangString.new(name),
+          type: type,
+          items: [],
+          organizations: [],
+          documentation: nil
+        )
         register(organization, organizations)
         organizations.push(organization)
         organization
@@ -217,6 +203,8 @@ module Archimate
             find_default_organization("implementation_migration", "Implementation & Migration")
           when Layers::Connectors
             find_default_organization("connectors", "Connectors")
+          when Layers::Other
+            find_default_organization("other", "Other")
           else
             raise StandardError, "Unexpected Element Layer: #{item.layer} for item type #{item.type}"
           end
@@ -242,7 +230,7 @@ module Archimate
       end
 
       def find_in_organizations(item, _fs = nil)
-        find_by_class(DataModel::Organization).select { |f| f.items.include?(item.id) }.first
+        find_by_class(DataModel::Organization).select { |f| f.items.include?(item) }.first
       end
 
       # Only used by [#unreferenced_nodes]

data/lib/archimate/data_model/modeling_note.rb

@@ -8,17 +8,12 @@ module Archimate
       include Comparison
 
       # @!attribute [r] documentation
-      #   @return [PreservedLangString]
+      # @return [PreservedLangString]
       model_attr :documentation
       # `type` attribute expresses a type for the notes, e.g. OCL for OCL rules.
       # @!attribute [r] type
-      #   @return [String, NilClass]
-      model_attr :type
-
-      def initialize(documentation:, type: nil)
-        @documentation = documentation
-        @type = type
-      end
+      # @return [String, NilClass]
+      model_attr :type, default: nil
     end
   end
 end

data/lib/archimate/data_model/organization.rb

@@ -14,44 +14,35 @@ module Archimate
     # @note that Organization must fit into a tree structure (so strictly nested).
     class Organization
       include Comparison
+      include Referenceable
 
       # Format should match +/[[[:alpha:]]_][w-.]*/+ to be valid for Archimate
       # Model exchange format
       # @!attribute [r] id
-      #   @return [String, NilClass]
-      model_attr :id
+      # @return [String, NilClass]
+      model_attr :id, default: nil
       # LabelGroup in the XSD
       # @!attribute [r] name
-      #   @return [LangString, NilClass]
-      model_attr :name
+      # @return [LangString, NilClass]
+      model_attr :name, default: nil
       # I believe this is used only for Archi formats
       # @!attribute [r] type
-      #   @return [String, NilClass]
-      model_attr :type
+      # @return [String, NilClass]
+      model_attr :type, default: nil
       # @!attribute [r] documentation
-      #   @return [PreservedLangString, NilClass]
-      model_attr :documentation
+      # @return [PreservedLangString, NilClass]
+      model_attr :documentation, default: nil
       # @!attribute [rw] items
-      #   @return [Array<Object>]
-      model_attr :items, writable: true
+      # @return [Array<Object>]
+      model_attr :items, writable: true, default: [], referenceable_list: 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
+      # @return [Array<Organization>]
+      model_attr :organizations, writable: true, default: [], referenceable_list: true
+      # @return [Array<AnyElement>]
+      model_attr :other_elements, default: []
+      # @return [Array<AnyAttribute>]
+      model_attr :other_attributes, default: []
 
       def to_s
         "#{Archimate::Color.data_model('Organization')}<#{id}>[#{Archimate::Color.color(name, %i[white underline])}]"
@@ -59,7 +50,7 @@ module Archimate
 
       def referenced_identified_nodes
         organizations.reduce(items) do |a, e|
-          a.concat(e.referenced_identified_nodes)
+          a.to_ary + e.referenced_identified_nodes
         end
       end
 

data/lib/archimate/data_model/property.rb

@@ -8,17 +8,12 @@ module Archimate
       include Comparison
 
       # @!attribute [r] value
-      #   @return [LangString, NilClass] value of the property, default +nil+
-      model_attr :value
+      # @return [LangString, NilClass] value of the property, default +nil+
+      model_attr :value, default: nil
       # @!attribute [rw] property_definition
-      #   @return [PropertyDefinition] property definition of the property
+      # @return [PropertyDefinition] property definition of the property
       model_attr :property_definition, writable: true
 
-      def initialize(property_definition:, value: nil)
-        @property_definition = property_definition
-        @value = value
-      end
-
       def to_s
         "Property(key: #{property_definition.name}, value: #{value || 'no value'})"
       end
@@ -26,6 +21,12 @@ module Archimate
       def key
         property_definition.name
       end
+
+      def brief_inspect
+        cls_name = self.class.name.split('::').last
+        val = "#{value.to_s.slice(0, 40).inspect}#{'...' if value.to_s.size > 40}"
+        "#<#{cls_name} #{key} = #{val}>"
+      end
     end
   end
 end

data/lib/archimate/data_model/property_definition.rb

@@ -9,38 +9,32 @@ module Archimate
     # A Property definition type containing its unique identifier, name, and data type.
     class PropertyDefinition
       include Comparison
+      include Referenceable
 
       # @!attribute [r] id
-      #   @return [String]
+      # @return [String]
       model_attr :id
       # @!attribute [r] name
-      #   @return [LangString]
+      # @return [LangString]
       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
+      # @return [PreservedLangString, NilClass]
+      model_attr :documentation, default: nil
+      # @!attribute [r] other_elements
+      # @return [Array<AnyElement>]
+      model_attr :other_elements, default: []
+      # @!attribute [r] other_attributes
+      # @return [Array<AnyAttribute>]
+      model_attr :other_attributes, default: []
       # @!attribute [r] type
-      #   @note if +type+ is nil, then type "string" is assumed
-      #   @see Archimate::DataModel::PROPERTY_DEFINITION_TYPES
-      #   @return [String, NilClass]
-      model_attr :type
+      # @note if +type+ is nil, then type "string" is assumed
+      # @see Archimate::DataModel::PROPERTY_DEFINITION_TYPES
+      # @return [String, NilClass]
+      model_attr :type, default: nil
 
       def self.identifier_for_key(key)
         (self.class.hash ^ key.hash).to_s(16)
       end
-
-      def initialize(id:, name:, documentation: nil, type: nil)
-        @id = id
-        @name = name
-        @documentation = documentation
-        @type = type
-      end
     end
   end
 end

data/lib/archimate/data_model/referenceable.rb

@@ -2,18 +2,23 @@
 
 module Archimate
   module DataModel
-    # Something that can be referenced in the model.
-    class Referenceable < ArchimateNode
-      private
+    # Something that can be referenced by another entity.
+    module Referenceable
+      def add_reference(referencer)
+        references << referencer unless references.include?(referencer)
+      end
+
+      def remove_reference(referencer)
+        references.delete(referencer)
+      end
 
-      def find_my_index
-        id
+      def references
+        @referenceable_set ||= []
       end
 
-      # name isn't merged
-      def merge(node)
-        documentation.concat(node.documentation)
-        properties.concat(node.properties)
+      # Diagrams that this entity is referenced in.
+      def diagrams
+        references.select { |ref| ref.is_a?(Diagram) }
       end
     end
   end