archimate 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37d66a474e8d614dd2ccbbf746511e3c4b769ef7
-  data.tar.gz: 50e1139f2d69beb50da6e702bd0e20d226f615fa
+  metadata.gz: 4adaa55a050dfda4d29150a63c15860a21f50932
+  data.tar.gz: 78c4c98ef53b79704018ef5b761377ac01e4497d
 SHA512:
-  metadata.gz: e406c34a0b01b3f839f2ff8e9a688e7a5222ed02203bb0db45fdb03a71f6db5a9d8f9b9c575fa661ae3ce12ed8c7448cc340acea05c042097418eab8bffc498b
-  data.tar.gz: 64c3e07d73f2b053c790fb37a3d8f32129f35da594a03fc4a7fe4b6cb66ed15e4e27d1ef83fcd4d5b0e66bd4ce56962aa82bc567717ddaef4878d52eac109d84
+  metadata.gz: ad77b807f9800be3bd0b4cde9a8dffa00161b94925aa2fdaf7519bfbcd80a71a63acc80ef294647b6d442cbb92b41113c50de10397bd7b9831a52acfb5d35a38
+  data.tar.gz: ef2e775c6067f3a9b097c853083d687af9289ce28f68d7d36a166257e2572af06089bab38513f4c7661cb0d30810bba271f89a4be82b0724beeafa46e225b66a

data/archimate.gemspec

@@ -1,5 +1,5 @@
-# coding: utf-8
 # frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'archimate/version'
@@ -48,4 +48,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "faker"
   spec.add_development_dependency "rsense"
   spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "rubocop"
 end

data/lib/archimate/color.rb

@@ -23,7 +23,7 @@ HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
   cs[:Connectors]                     = %i[black on_light_gray]
   cs[:unknown_layer]                  = %i[black on_gray]
   cs[:Model]                          = [:cyan]
-  cs[:Connection]               = [:blue]
+  cs[:Connection]                     = [:blue]
   cs[:Organization]                   = [:cyan]
   cs[:Relationship]                   = %i[black on_light_gray]
   cs[:Diagram]                        = %i[black on_cyan]
@@ -33,7 +33,7 @@ end
 module Archimate
   class Color
     def self.layer_color(layer, str)
-      layer_sym = layer.to_sym
+      layer_sym = layer&.to_sym
       sym = HighLine.color_scheme.include?(layer_sym) ? layer_sym : :unknown_layer
       color(str, sym)
     end

data/lib/archimate/data_model/any_attribute.rb

@@ -7,20 +7,14 @@ module Archimate
       include Comparison
 
       # @!attribute [r] attribute
-      #   @return [String]
+      # @return [String]
       model_attr :attribute
       # @!attribute [r] prefix
-      #   @return [String]
-      model_attr :prefix
+      # @return [String]
+      model_attr :prefix, default: ""
       # @!attribute [r] value
-      #   @return [String]
+      # @return [String]
       model_attr :value
-
-      def initialize(attribute, value, prefix: "")
-        @attribute = attribute
-        @prefix = prefix
-        @value = value
-      end
     end
   end
 end

data/lib/archimate/data_model/any_element.rb

@@ -7,28 +7,20 @@ module Archimate
       include Comparison
 
       # @!attribute [r] element
-      #   @return [String]
+      # @return [String]
       model_attr :element
       # @!attribute [r] prefix
-      #   @return [String, NilClass]
-      model_attr :prefix
+      # @return [String, NilClass]
+      model_attr :prefix, default: ""
       # @!attribute [r] attributes
-      #   @return [Array<AnyAttribute>]
-      model_attr :attributes
+      # @return [Array<AnyAttribute>]
+      model_attr :attributes, default: []
       # @!attribute [r] content
-      #   @return [String, NilClass]
-      model_attr :content
+      # @return [String, NilClass]
+      model_attr :content, default: nil
       # @!attribute [r] children
-      #   @return [Array<AnyElement>]
-      model_attr :children
-
-      def initialize(element:, prefix: "", attributes: [], content: nil, children: [])
-        @element = element
-        @prefix = prefix
-        @attributes = attributes
-        @content = content
-        @children = children
-      end
+      # @return [Array<AnyElement>]
+      model_attr :children, default: []
 
       def to_sym
         element&.to_sym

data/lib/archimate/data_model/bounds.rb

@@ -6,16 +6,16 @@ module Archimate
       include Comparison
 
       # @!attribute [r] x
-      #   @return [Float, NilClass]
-      model_attr :x
+      # @return [Float, NilClass]
+      model_attr :x, default: nil
       # @!attribute [r] y
-      #   @return [Float, NilClass]
-      model_attr :y
+      # @return [Float, NilClass]
+      model_attr :y, default: nil
       # @!attribute [r] width
-      #   @return [Float]
+      # @return [Float]
       model_attr :width
       # @!attribute [r] height
-      #   @return [Float]
+      # @return [Float]
       model_attr :height
 
       def self.zero

data/lib/archimate/data_model/color.rb

@@ -10,16 +10,16 @@ module Archimate
       include Comparison
 
       # @!attribute [r] r
-      #   @return [Int] red component, value 0-255
+      # @return [Int] red component, value 0-255
       model_attr :r
       # @!attribute [r] g
-      #   @return [Int] green component, value 0-255
+      # @return [Int] green component, value 0-255
       model_attr :g
       # @!attribute [r] b
-      #   @return [Int] blue component, value 0-255
+      # @return [Int] blue component, value 0-255
       model_attr :b
       # @!attribute [r] a
-      #   @return [Int, NilClass] optional alpha component, value 0-100
+      # @return [Int, NilClass] optional alpha component, value 0-100
       model_attr :a
 
       # Parses a CSS style color string into a color object
@@ -45,8 +45,8 @@ module Archimate
 
       def initialize(r:, g:, b:, a: nil)
         raise "r, g, b cannot be nil" if [r, g, b].any?(&:nil?)
-        raise "r, g, b must be between 0 and 255" if [r, g, b].any? { |v| v < 0 || v > 255 }
-        raise "a must be between 0 and 100" if a && (a < 0 || a > 100)
+        raise "r, g, b must be between 0 and 255" if [r, g, b].any? { |v| v.negative? || v > 255 }
+        raise "a must be between 0 and 100" if a && (a.negative? || a > 100)
         @r = r
         @g = g
         @b = b

data/lib/archimate/data_model/comparison.rb

@@ -3,6 +3,32 @@
 module Archimate
   module DataModel
     module Comparison
+      def initialize(opts = {})
+        self.class.attr_info.each do |sym, attr_info|
+          if attr_info.default == :value_required && !opts.include?(sym)
+            raise "#{self.class} required value for #{sym} is missing."
+          end
+          val = opts.fetch(sym, attr_info.default)
+          instance_variable_set("@#{sym}".to_sym, val)
+          val.add_reference(self) if val.is_a?(Referenceable)
+        end
+
+        self.class.attr_info.each do |sym, attr_info|
+          if attr_info.referenceable_list
+            instance_variable_set(
+              "@#{sym}".to_sym,
+              ReferenceableList.new(self, opts.fetch(sym, attr_info.default), attr_info.also_reference)
+            )
+          elsif attr_info.also_reference.size.positive?
+            val = instance_variable_get("@#{sym}".to_sym)
+            attr_info.also_reference.each do |ref_sym|
+              ref = send(ref_sym)
+              val.add_reference(ref) if ref && val
+            end
+          end
+        end
+      end
+
       def hash
         @hash_key ||=
           self.class.attr_names.reduce(self.class.hash) { |ha, attr| ha ^ send(attr).hash }
@@ -35,6 +61,8 @@ module Archimate
         self.class.comparison_attr_paths.each(&blk)
       end
 
+      # @todo implement pretty_print as a more normal pretty_print with correct
+      #       handling for attr_info values for comparison_attr
       def pretty_print(pp)
         pp.object_address_group(self) do
           pp.seplist(self.class.comparison_attr_paths, proc { pp.text ',' }) do |attr|
@@ -50,26 +78,90 @@ module Archimate
         end
       end
 
+      # @todo implement inspect as a more normal inspect with correct handling for
+      #       attr_info values for comparison_attr
+      def inspect
+        "#<#{self.class.to_s.split('::').last}\n    " +
+          self.class.attr_info
+              .map { |sym, info| info.attr_inspect(self, sym) }
+          .compact
+              .join("\n    ") + "\n    >"
+      end
+
+      def brief_inspect
+        "#<#{self.class.to_s.split('::').last}#{" id=#{id}" if respond_to?(:id)}#{" #{name.brief_inspect}" if respond_to?(:name) && name}>"
+      end
+
       def self.included(base)
         base.extend ClassMethods
       end
 
       module ClassMethods
+        AttributeInfo = Struct.new(:comparison_attr, :writable, :default, :referenceable_list, :also_reference) do
+          def attr_inspect(obj, sym)
+            case comparison_attr
+            when :no_compare
+              nil
+            when nil
+              "#{sym}: #{attr_value_inspect(obj.send(sym))}"
+            else
+              val = obj.send(sym)
+              cval = val&.send(comparison_attr)
+              "#{sym}: #<#{val.class.to_s.split('::').last} #{comparison_attr}=#{attr_value_inspect(cval)}>"
+            end
+          end
+
+          def attr_value_inspect(val)
+            case val
+            when Comparison
+              val.brief_inspect
+            when Array
+              vals = val.first(3).map do |v|
+                if v.is_a?(Comparison)
+                  v.brief_inspect
+                else
+                  v.inspect
+                end
+              end
+              "[#{vals.join(', ')}#{"...#{val.size}" if val.size > 3}]"
+            else
+              val.inspect
+            end
+          end
+        end
+
         # Define the reader method (or call model_attr)
         # Append the attr_sym to the @@attrs for the class
-        def model_attr(attr_sym, comparison_attr: nil, writable: false)
+        def model_attr(attr_sym, comparison_attr: nil, writable: false,
+                       default: :value_required, referenceable_list: false,
+                       also_reference: [])
           send(:attr_reader, attr_sym)
           attrs = attr_names << attr_sym
           class_variable_set(:@@attr_names, attrs.uniq)
-
+          class_variable_set(
+            :@@attr_info,
+            attr_info.merge(attr_sym => AttributeInfo.new(
+              comparison_attr, writable, default, referenceable_list, also_reference
+            ))
+          )
           if comparison_attr != :no_compare
             attrs = comparison_attr_paths << (comparison_attr ? [attr_sym, comparison_attr] : attr_sym)
             class_variable_set(:@@comparison_attr_paths, attrs.uniq)
           end
-          if writable
-            define_method("#{attr_sym}=".to_sym) do |val|
-              instance_variable_set(:@hash_key, nil)
+          return unless writable
+          define_method("#{attr_sym}=".to_sym) do |val|
+            instance_variable_set(:@hash_key, nil)
+            old_val = instance_variable_get("@#{attr_sym}")
+            if old_val.is_a?(ReferenceableList)
+              old_val.replace_with(val)
+            else
+              old_val.remove_reference(self) if old_val.is_a?(Referenceable)
               instance_variable_set("@#{attr_sym}".to_sym, val)
+              val.add_reference(self) if val.is_a?(Referenceable)
+              also_reference.each do |ref_sym|
+                ref = send(ref_sym)
+                val.add_reference(ref) if ref && val
+              end
             end
           end
         end
@@ -78,6 +170,10 @@ module Archimate
           class_variable_defined?(:@@attr_names) ? class_variable_get(:@@attr_names) : []
         end
 
+        def attr_info
+          class_variable_defined?(:@@attr_info) ? class_variable_get(:@@attr_info) : {}
+        end
+
         def comparison_attr_paths
           class_variable_defined?(:@@comparison_attr_paths) ? class_variable_get(:@@comparison_attr_paths) : []
         end

data/lib/archimate/data_model/concern.rb

@@ -9,22 +9,14 @@ module Archimate
       include Comparison
 
       # @!attribute [r] label
-      #   @return [LangString] one label is required
+      # @return [LangString] one label is required
       model_attr :label
       # @!attribute [r] documentation
-      #   @return [PreservedLangString]
-      model_attr :documentation
+      # @return [PreservedLangString]
+      model_attr :documentation, default: nil
       # @!attribute [r] stakeholders
-      #   @return [Array<LangString>]
-      model_attr :stakeholders
-
-      def initialize(label:, documentation: nil, stakeholders: [])
-        raise "label is required" unless label
-        raise "stakeholders is a list" unless stakeholders.is_a?(Array)
-        @label = label
-        @documentation = documentation
-        @stakeholders = stakeholders
-      end
+      # @return [Array<LangString>]
+      model_attr :stakeholders, default: []
     end
   end
 end

data/lib/archimate/data_model/connection.rb

@@ -4,75 +4,66 @@ module Archimate
   module DataModel
     # Graphical connection type.
     #
-    # If the 'relationshipRef' attribute is present, the connection should reference an existing ArchiMate relationship.
+    # If the 'relationshipRef' attribute is present, the connection should
+    # reference an existing ArchiMate relationship.
     #
-    # 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.
+    # 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.
     class Connection
       include Comparison
+      include Referenceable
 
       # @!attribute [r] id
-      #   @return [String]
+      # @return [String]
       model_attr :id
       # @!attribute [r] name
-      #   @return [LangString, NilClass]
-      model_attr :name
+      # @return [LangString, NilClass]
+      model_attr :name, default: nil
       # @!attribute [r] documentation
-      #   @return [PreservedLangString, NilClass]
-      model_attr :documentation
+      # @return [PreservedLangString, NilClass]
+      model_attr :documentation, default: nil
       # # @!attribute [r] other_elements
-      #   @return [Array<AnyElement>]
-      model_attr :other_elements
+      # @return [Array<AnyElement>]
+      model_attr :other_elements, default: []
       # # @!attribute [r] other_attributes
-      #   @return [Array<AnyAttribute>]
-      model_attr :other_attributes
+      # @return [Array<AnyAttribute>]
+      model_attr :other_attributes, default: []
       # @note type here was used for the Element/Relationship/Diagram type
       # @!attribute [r] type
-      #   @return [String, NilClass]
-      model_attr :type
+      # @return [String, NilClass]
+      model_attr :type, default: nil
       # @!attribute [r] source_attachment
-      #   @return [Location, NilClass]
-      model_attr :source_attachment
+      # @return [Location, NilClass]
+      model_attr :source_attachment, default: nil
       # @!attribute [r] bendpoints
-      #   @return [Array<Location>]
-      model_attr :bendpoints
+      # @return [Array<Location>]
+      model_attr :bendpoints, default: []
       # @!attribute [r] target_attachment
-      #   @return [Location, NilClass]
-      model_attr :target_attachment
+      # @return [Location, NilClass]
+      model_attr :target_attachment, default: nil
       # @!attribute [rw] source
-      #   @return [ViewNode, NilClass]
-      model_attr :source, comparison_attr: :id, writable: true
+      # @return [ViewNode, NilClass]
+      model_attr :source, comparison_attr: :id, writable: true, default: nil
       # @!attribute [rw] target
-      #   @return [ViewNode, NilClass]
-      model_attr :target, comparison_attr: :id, writable: true
+      # @return [ViewNode, NilClass]
+      model_attr :target, comparison_attr: :id, writable: true, default: nil
       # @!attribute [rw] relationship
-      #   @return [Relationship, NilClass]
-      model_attr :relationship, comparison_attr: :id, writable: true
+      # @return [Relationship, NilClass]
+      model_attr :relationship, comparison_attr: :id, writable: true, default: nil, also_reference: [:diagram]
       # @!attribute [r] style
-      #   @return [Style, NilClass]
-      model_attr :style
+      # @return [Style, NilClass]
+      model_attr :style, default: nil
       # @!attribute [r] properties
-      #   @return [Array<Property>]
-      model_attr :properties
+      # @return [Array<Property>]
+      model_attr :properties, default: []
 
-      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
+      # @!attribute [r] diagram
+      # @return [Diagram, NilClass]
+      model_attr :diagram, comparison_attr: :no_compare
 
       def replace(entity, with_entity)
         @relationship = with_entity.id if relationship == entity.id

data/lib/archimate/data_model/connector_type.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "ruby-enum"
 
 module Archimate

data/lib/archimate/data_model/diagram.rb

@@ -4,64 +4,49 @@ module Archimate
   module DataModel
     class Diagram
       include Comparison
+      include Referenceable
 
       # @!attribute [r] id
-      #   @return [String]
+      # @return [String]
       model_attr :id
       # @!attribute [rw] name
-      #   @return [LangString]
-      model_attr :name, writable: true
+      # @return [LangString]
+      model_attr :name, writable: true, default: nil
       # @!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
+      # @return [PreservedLangString, NilClass]
+      model_attr :documentation, writable: true, default: nil
+      # @return [Array<AnyElement>]
+      model_attr :other_elements, default: []
+      # @return [Array<AnyAttribute>]
+      model_attr :other_attributes, default: []
       # @note type here was used for the Element/Relationship/Diagram type
       # @!attribute [r] type
-      #   @return [String, NilClass]
-      model_attr :type
+      # @return [String, NilClass]
+      model_attr :type, default: nil
       # @!attribute [rw] properties
-      #   @return [Array<Property>]
-      model_attr :properties, writable: true
+      # @return [Array<Property>]
+      model_attr :properties, writable: true, default: []
       # @todo make this a ViewpointType is better but is Archimate specification version dependent
       # @!attribute [r] viewpoint_type
-      #   @return [String, NilClass]
-      model_attr :viewpoint_type
+      # @return [String, NilClass]
+      model_attr :viewpoint_type, default: nil
       # @!attribute [r] viewpoint
-      #   @return [Viewpoint, NilClass]
-      model_attr :viewpoint
+      # @return [Viewpoint, NilClass]
+      model_attr :viewpoint, default: nil
       # @!attribute [rw] nodes
-      #   @return [Array<ViewNode>]
-      model_attr :nodes, writable: true
+      # @return [Array<ViewNode>]
+      model_attr :nodes, writable: true, default: [], referenceable_list: 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
+      # @return [Int, NilClass]
+      model_attr :connection_router_type, default: nil
       # value of 0 on Archi Sketch Model
       # @!attribute [r] background
-      #   @return [Int, NilClass]
-      model_attr :background
+      # @return [Int, NilClass]
+      model_attr :background, default: nil
       # @!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
+      # @return [Array<Connection>]
+      model_attr :connections, writable: true, default: [], referenceable_list: true
 
       def all_nodes
         nodes.inject(Array.new(nodes)) { |child_ary, child| child_ary.concat(child.all_nodes) }
@@ -92,7 +77,7 @@ module Archimate
       end
 
       def referenced_identified_nodes
-        (nodes + connections)
+        (nodes.to_ary + connections)
           .map(&:referenced_identified_nodes)
           .flatten
           .uniq

data/lib/archimate/data_model/diagram_type.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "ruby-enum"
 
 module Archimate

data/lib/archimate/data_model/element.rb

@@ -8,63 +8,42 @@ module Archimate
     # 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
+      include Referenceable
+      include RelationshipReferences
 
       # @!attribute [r] id
-      #   @return [String]
+      # @return [String]
       model_attr :id
       # @!attribute [r] name
-      #   @return [LangString, NilClass]
+      # @return [LangString, NilClass]
       model_attr :name
       # @!attribute [rw] documentation
-      #   @return [PreservedLangString, NilClass]
-      model_attr :documentation, writable: true
+      # @return [PreservedLangString, NilClass]
+      model_attr :documentation, writable: true, default: nil
       # # @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
-
-      def initialize(id:, name:, documentation: nil, type: nil, properties: [])
-        @id = id
-        @name = name
-        @documentation = documentation
-        @type = type
-        @properties = properties
-      end
+      # @return [Array<Property>]
+      model_attr :properties, default: []
 
       def to_s
         Archimate::Color.layer_color(layer, "#{type}<#{id}>[#{name}]")
       end
 
-      def layer
-        Layers.for_element(type)
+      def type
+        self.class.name.split("::").last
       end
 
-      # Diagrams that this element is referenced in.
-      # @todo this implementation is broken - in_model no longer exists
-      def diagrams
-        @diagrams ||= in_model.diagrams.select do |diagram|
-          diagram.element_ids.include?(id)
-        end
+      def classification
+        self.class::CLASSIFICATION
       end
 
-      # Relationships that this element is referenced in.
-      # @todo this implementation is broken - in_model no longer exists
-      def relationships
-        @relationships ||= in_model.relationships.select do |relationship|
-          relationship.source == id || relationship.target == id
-        end
+      def layer
+        self.class::LAYER
       end
 
       # Copy any attributes/docs, etc. from each of the others into the original.