archimate 2.0.2 → 2.0.3

data/lib/archimate/data_model/bounds.rb

@@ -22,6 +22,15 @@ module Archimate
         Archimate::DataModel::Bounds.new(x: 0, y: 0, width: 0, height: 0)
       end
 
+      def self.from_location(location)
+        DataModel::Bounds.new(
+          x: location.x,
+          y: location.y,
+          width: 0,
+          height: 0
+        )
+      end
+
       def initialize(x: nil, y: nil, width:, height:)
         raise "Width expected" unless width
         raise "Height expected" unless height
@@ -68,19 +77,19 @@ module Archimate
         )
       end
 
-      def is_above?(other)
+      def above?(other)
         bottom < other.top
       end
 
-      def is_below?(other)
+      def below?(other)
         top > other.bottom
       end
 
-      def is_right_of?(other)
+      def right_of?(other)
         left > other.right
       end
 
-      def is_left_of?(other)
+      def left_of?(other)
         right < other.left
       end
 
@@ -88,6 +97,7 @@ module Archimate
         Bounds.new(x: left + val, y: top + val, width: width - val * 2, height: height - val * 2)
       end
 
+      # Tests if this bounds is inside the argument Bounds
       def inside?(other)
         left > other.left &&
           right < other.right &&

data/lib/archimate/data_model/comparison.rb

@@ -78,18 +78,12 @@ 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}>"
+              .join(" ") + ">"
       end
 
       def self.included(base)
@@ -103,29 +97,11 @@ module Archimate
             when :no_compare
               nil
             when nil
-              "#{sym}: #{attr_value_inspect(obj.send(sym))}"
+              "#{sym}: #{obj.send(sym).inspect}"
             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
+              "#{sym}: #<#{val.class.to_s.split('::').last} #{comparison_attr}=#{cval.inspect}>"
             end
           end
         end

data/lib/archimate/data_model/connection.rb

@@ -92,8 +92,20 @@ module Archimate
         ].compact.join(" ")
       end
 
-      def referenced_identified_nodes
-        [@source, @target, @relationship].compact
+      def start_location
+        source_attachment || source_bounds.center
+      end
+
+      def end_location
+        target_attachment || target_bounds.center
+      end
+
+      def source_bounds
+        source.absolute_position
+      end
+
+      def target_bounds
+        target.absolute_position
       end
 
       # This is used when rendering a connection to connection relationship.
@@ -101,17 +113,20 @@ module Archimate
         []
       end
 
-      # TODO: Is this true for all or only Archi models?
       def absolute_position
-        # offset = bounds || Archimate::DataModel::Bounds.zero
-        offset = 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
+        pt = Svg::Path.new(self).midpoint
+        Bounds.new(x: pt.x, y: pt.y, width: 0, height: 0)
+      end
+
+      def replace_item_with(item, replacement)
+        super
+        item.remove_reference(self)
+        case item
+        when relationship
+          @relationship = replacement
+        else
+          raise "Trying to replace #{item} that I don't reference"
         end
-        offset
       end
     end
   end

data/lib/archimate/data_model/diagram.rb

@@ -26,10 +26,6 @@ module Archimate
       # @!attribute [rw] properties
       # @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, default: nil
       # @!attribute [r] viewpoint
       # @return [Viewpoint, NilClass]
       model_attr :viewpoint, default: nil
@@ -73,14 +69,25 @@ module Archimate
       end
 
       def total_viewpoint?
-        viewpoint_type.nil? || viewpoint_type.empty?
+        viewpoint.nil?
       end
 
-      def referenced_identified_nodes
-        (nodes.to_ary + connections)
-          .map(&:referenced_identified_nodes)
-          .flatten
-          .uniq
+      def viewpoint_description
+        case viewpoint
+        when Symbol
+          viewpoint.to_s
+        when Viewpoint
+          viewpoint.name.to_s
+        else
+          case type
+          when "canvas:CanvasModel"
+            "Canvas"
+          when "archimate:SketchModel"
+            "Sketch"
+          else
+            "Total"
+          end
+        end
       end
     end
   end

data/lib/archimate/data_model/element.rb

@@ -22,10 +22,12 @@ module Archimate
       # @!attribute [rw] documentation
       # @return [PreservedLangString, NilClass]
       model_attr :documentation, writable: true, default: nil
-      # # @return [Array<AnyElement>]
-      # model_attr :other_elements
-      # # @return [Array<AnyAttribute>]
-      # model_attr :other_attributes
+      # @!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] properties
       # @return [Array<Property>]
       model_attr :properties, default: []
@@ -51,12 +53,22 @@ module Archimate
       #     2. Child `documentation` (and different `xml:lang` attribute values)
       #     3. Child `properties`
       #     4. Any other elements
-      # @todo this implementation is broken - in_model no longer exists
       def merge(element)
-        super
-        element.diagrams.each { |diagram| diagram.replace(element, self) }
-        element.relationships.each { |relationship| relationship.replace(element, self) }
-        element.organization.remove(element.id)
+        if !documentation
+          self.documentation = element.documentation
+        elsif documentation != element.documentation
+          documentation.merge(element.documentation)
+        end
+        element.properties.each do |property|
+          unless properties.find { |my_prop| my_prop.property_definition.name == property.property_definition.name && my_prop.value == property.value}
+            properties << property
+          end
+        end
+      end
+
+      # Diagrams that this entity is referenced in.
+      def diagrams
+        references.select { |ref| ref.is_a?(Diagram) }
       end
     end
   end

data/lib/archimate/data_model/elements.rb

@@ -115,15 +115,6 @@ module Archimate
         end
       end
 
-      class Meaning < Element
-        CLASSIFICATION = :passive_structure
-        LAYER = Layers::Business
-
-        def initialize(args)
-          super
-        end
-      end
-
       class Product < Element
         CLASSIFICATION = :passive_structure
         LAYER = Layers::Business
@@ -142,15 +133,6 @@ module Archimate
         end
       end
 
-      class Value < Element
-        CLASSIFICATION = :passive_structure
-        LAYER = Layers::Business
-
-        def initialize(args)
-          super
-        end
-      end
-
       #############################################################
       # Application Layer
       #############################################################
@@ -491,6 +473,15 @@ module Archimate
         end
       end
 
+      class Meaning < Element
+        CLASSIFICATION = :passive_structure
+        LAYER = Layers::Motivation
+
+        def initialize(args)
+          super
+        end
+      end
+
       class Outcome < Element
         CLASSIFICATION = :active_structure
         LAYER = Layers::Motivation
@@ -527,6 +518,15 @@ module Archimate
         end
       end
 
+      class Value < Element
+        CLASSIFICATION = :passive_structure
+        LAYER = Layers::Motivation
+
+        def initialize(args)
+          super
+        end
+      end
+
       #############################################################
       # Implementation and Migration Layer
       #############################################################
@@ -676,6 +676,12 @@ module Archimate
       def self.classes
         constants.map { |cls_name| const_get(cls_name) }
       end
+
+      def self.core_elements
+        classes.select do |el|
+          [Layers::Business, Layers::Application, Layers::Technology].include?(el::LAYER)
+        end
+      end
     end
   end
 end

data/lib/archimate/data_model/lang_string.rb

@@ -6,6 +6,7 @@ module Archimate
   module DataModel
     # A base string type for multi-language strings.
     class LangString
+      include Comparable
       include Comparison
       extend Forwardable
 
@@ -23,16 +24,18 @@ module Archimate
 
       def self.string(str, lang = nil)
         return nil if !str || str.strip.empty?
-        new(str, lang)
+        new(str, default_lang: lang)
       end
 
-      # @param [Hash{Symbol => Object},LangString, String] attributes
+      # @param str [String, LangString] optional shortcut to set define this LangString
+      # @param lang_hash [Hash{Symbol => Object}] attributes
+      # @param default_lang [String] optional setting of the default language
       # @raise [Struct::Error] if the given attributes don't conform {#schema}
       #   with given {# # constructor_type}
-      def initialize(str = nil, lang = nil, lang_hash: {}, default_lang: nil, default_text: nil)
+      def initialize(str = nil, lang_hash: {}, default_lang: nil)
         @lang_hash = lang_hash
-        @default_lang = default_lang || lang
-        @default_text = default_text
+        @default_lang = default_lang || lang_hash.keys.first
+        @default_text = str || lang_hash.fetch(@default_lang, nil)
         case str
         when String
           @lang_hash[@default_lang] = @default_text = str.strip
@@ -41,7 +44,7 @@ module Archimate
           @default_lang = str.default_lang
           @default_text = str.default_text
         else
-          @lang_hash[default_lang] = default_text if default_text
+          @lang_hash[default_lang] = @default_text if @default_text
         end
       end
 
@@ -59,10 +62,6 @@ 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
@@ -75,6 +74,14 @@ module Archimate
         default_lang
       end
 
+      def ==(other)
+        if other.is_a?(String)
+          to_s == other
+        else
+          super
+        end
+      end
+
       def =~(other)
         str = to_s
         if other.is_a?(Regexp)
@@ -83,6 +90,23 @@ module Archimate
           Regexp.new(Regexp.escape(str)) =~ other
         end
       end
+
+      def <=>(other)
+        to_s <=> other.to_s
+      end
+
+      def merge(other)
+        return unless other
+        other.lang_hash.each do |k, v|
+          if @lang_hash.include?(k)
+            @lang_hash[k] = [@lang_hash[k], v].join("\n") if @lang_hash[k] != other.lang_hash[k]
+          else
+            @lang_hash[k] = v
+          end
+        end
+        @default_lang = @default_lang || other.default_lang || @lang_hash.keys.first
+        @default_text = @lang_hash[@default_lang]
+      end
     end
   end
 end

data/lib/archimate/data_model/layer.rb

@@ -5,6 +5,8 @@ require "ruby-enum"
 module Archimate
   module DataModel
     class Layer
+      include Comparable
+
       attr_reader :name
       attr_reader :background_class
 
@@ -37,6 +39,10 @@ module Archimate
         @symbol == other&.to_sym
       end
 
+      def <=>(other)
+        Layers.find_index(self) <=> Layers.find_index(other)
+      end
+
       def to_sym
         @symbol
       end

data/lib/archimate/data_model/location.rb

@@ -16,32 +16,29 @@ module Archimate
       # @note the XSD has this as a NonNegativeInteger
       # @!attribute [r] x
       # @return [Float]
-      model_attr :x
+      model_attr :x, writable: true
       # 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]
-      model_attr :y
+      model_attr :y, writable: true
 
-      # 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, default: nil
-      # @!attribute [r] end_y
-      # @return [Int, NilClass]
-      model_attr :end_y, default: nil
-
-      def initialize(x:, y:, end_x: nil, end_y: nil)
+      def initialize(x:, y:)
         @x = x.to_i
         @y = y.to_i
-        @end_x = end_x.nil? ? nil : end_x.to_i
-        @end_y = end_y.nil? ? nil : end_y.to_i
       end
 
       def to_s
         "Location(x: #{x}, y: #{y})"
       end
+
+      # Returns true if this location is inside the bounds argument
+      # @param bounds [Bounds]
+      def inside?(bounds)
+        bounds.x_range.cover?(x) &&
+          bounds.y_range.cover?(y)
+      end
     end
   end
 end

data/lib/archimate/data_model/model.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Archimate::CoreRefinements
+
 module Archimate
   module DataModel
     # This is the root model type.
@@ -116,45 +118,65 @@ module Archimate
         self
       end
 
-      # 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
+      # @todo this should move into either Comparison or a Mergeable class
+      # Steps to merge
+      # merge attributes of each copy into master_entity
+      # update references of each copy to reference master_entity instead (where it makes sense)
+      # remove reference of each copy from its references
+      def merge_entities(master_entity, copies)
+        copies.delete(master_entity)
+        copies.each do |copy|
+          master_entity.merge(copy)
+          copy.replace_with(master_entity)
+          # if !copy.references.empty?
+          #   puts "#{copy.class} still referenced by #{copy.references.map { |ref| ref.class.name }.join(", ")}"
+          # end
+          deregister(copy)
+        end
       end
 
-      # This is used only by the model [Cli::Cleanup] class.
-      def unreferenced_nodes
-        identified_nodes - referenced_identified_nodes
+      def replace_item_with(item, replacement)
+        case item
+        when Organization
+          organizations.delete(item)
+          organizations << replacement
+        when Element
+          elements.delete(item)
+          elements << replacement
+        when Relationship
+          relationships.delete(item)
+          relationships << replacement
+        end
       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
-
       def make_unique_id
-        unique_id = random_id
-        unique_id = random_id while @index_hash.key?(unique_id)
+        @random ||= Random.new
+        begin
+          unique_id = format("%08x", @random.rand(0xffffffff))
+        end until !@index_hash.key?(unique_id)
         unique_id
       end
 
+      def remove_reference(item)
+        case item
+        when Element
+          elements.delete(item)
+        when Relationship
+          relationships.delete(item)
+        when Diagram
+          diagrams.delete(item)
+        else
+          raise "Unhandled remove reference for type #{item.class}"
+        end
+        organizations.each { |org| org.remove_reference(item) }
+      end
+
+      Elements.classes.each do |el_cls|
+        define_method(el_cls.name.split("::").last.snake_case + "s") do
+          elements.select { |el| el.is_a?(el_cls) }
+        end
+      end
+
       private
 
       # Only used by [#find_default_organization]
@@ -233,12 +255,7 @@ module Archimate
         find_by_class(DataModel::Organization).select { |f| f.items.include?(item) }.first
       end
 
-      # Only used by [#unreferenced_nodes]
-      def identified_nodes
-        @index_hash.values.select { |node| node.respond_to? :id }
-      end
-
-      # @todo make this private - maybe move to [Organization]
+      # @todo maybe move to [Organization]
       def index_organizations(ref)
         ref.organizations.each do |org|
           @index_hash[org.id] = index_organizations(org)
@@ -246,7 +263,7 @@ module Archimate
         ref
       end
 
-      # @todo make this private - maybe move to [ViewNode]
+      # @todo maybe move to [ViewNode]
       def index_view_nodes(ref)
         ref.nodes.each do |node|
           @index_hash[node.id] = index_view_nodes(node)
@@ -255,11 +272,6 @@ module Archimate
         ref
       end
 
-      def random_id
-        @random ||= Random.new
-        format("%08x", @random.rand(0xffffffff))
-      end
-
       def register(node, _parent)
         @index_hash[node.id] = node
       end

data/lib/archimate/data_model/organization.rb

@@ -48,14 +48,30 @@ module Archimate
         "#{Archimate::Color.data_model('Organization')}<#{id}>[#{Archimate::Color.color(name, %i[white underline])}]"
       end
 
-      def referenced_identified_nodes
-        organizations.reduce(items) do |a, e|
-          a.to_ary + e.referenced_identified_nodes
+      def remove(id)
+        items.delete_if { |item| item.id == id }
+      end
+
+      def remove_reference(item)
+        super
+        case item
+        when Organization
+          organizations.delete(item)
+        else
+          items.delete(item)
+          organizations.each { |org| org.remove_reference(item) }
         end
       end
 
-      def remove(id)
-        items.delete_if { |item| item.id == id }
+      def replace_item_with(item, replacement)
+        case item
+        when Organization
+          organizations.delete(item)
+          organizations << replacement
+        else
+          items.delete(item)
+          items << replacement
+        end
       end
     end
   end

data/lib/archimate/data_model/property.rb

@@ -21,12 +21,6 @@ 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