archimate 2.0.1 → 2.0.2

data/lib/archimate/data_model.rb

@@ -4,16 +4,13 @@ module Archimate
   module DataModel
     # Enumeration of Influence Strength types. These are suggestions.
     # InfluenceStrengthEnum = String # Strict::String.enum(%w[+ ++ - -- 0 1 2 3 4 5 6 7 8 9 10])
-
+    require 'archimate/data_model/referenceable'
+    require 'archimate/data_model/referenceable_list'
     require 'archimate/data_model/connector_type'
     require 'archimate/data_model/diagram_type'
-    require 'archimate/data_model/element_type'
-    require 'archimate/data_model/relationship_type'
     require 'archimate/data_model/comparison'
-    require 'archimate/data_model/differentiable'
     require 'archimate/data_model/layer'
     require 'archimate/data_model/layers'
-    require 'archimate/data_model/viewpoint_type'
     require 'archimate/data_model/any_attribute'
     require 'archimate/data_model/any_element'
     require 'archimate/data_model/lang_string'
@@ -28,8 +25,12 @@ module Archimate
     require 'archimate/data_model/property_definition'
     require 'archimate/data_model/property'
     require 'archimate/data_model/organization'
-    require 'archimate/data_model/element'
     require 'archimate/data_model/relationship'
+    require 'archimate/data_model/relationships'
+    require 'archimate/data_model/relationship_references'
+    require 'archimate/data_model/element'
+    require 'archimate/data_model/elements'
+    require 'archimate/data_model/viewpoint_type'
     require 'archimate/data_model/concern'
     require 'archimate/data_model/viewpoint'
     require 'archimate/data_model/location'

data/lib/archimate/derived_relations.rb

@@ -1,7 +1,60 @@
+# frozen_string_literal: true
+
 module Archimate
+  # 5.6.1 Derivation Rule for Structural and Dependency Relationships
+  #
+  # The structural and dependency relationships can be ordered by 'strength'.
+  # Structural relationships are 'stronger' than dependency relationships, and
+  # the relationships within these categories can also be ordered by strength:
+  #
+  # *  Influence (weakest)
+  # *  Access
+  # *  Serving
+  # *  Realization
+  # *  Assignment
+  # *  Aggregation
+  # *  Composition (strongest)
+  #
+  # Part of the language definition is an abstraction rule that states that two
+  # relationships that join at an intermediate element can be combined and
+  # replaced by the weaker of the two.
+  #
+  #   5.6.2 Derivation Rules for Dynamic Relationships
+  #
+  # For the two dynamic relationships, the following rules apply:
+  #
+  # *  If there is a flow relationship r from element a to element b, and a
+  #    structural relationship from element c to element a, a flow relationship
+  #    r can be derived from element c to element b.
+  # *  If there is a flow relationship r from element a to element b, and a
+  #    structural relationship from element d to element b, a flow relationship
+  #    r can be derived from element a to element d.
+  #
+  # These rules can be applied repeatedly. Informally, this means that the
+  # begin and/or endpoint of a flow relationship can be transferred 'backward'
+  # in a chain of elements connected by structural relationships. Example 16
+  # shows two of the possible flow relationships that can be derived with these
+  # rules, given a flow relationship between the two services.
+  #
+  # This rule also applies for a triggering relationship, but only in
+  # combination with an assignment relationship (not with other structural
+  # relationships):
+  #
+  # *  If there is a triggering relationship r from element a to element b, and
+  #    an assignment relationship from element c to element a, a triggering
+  #    relationship r can be derived from element c to element b.
+  # *  If there is a triggering relationship r from element a to element b, and
+  #    an assignment relationship from element d to element b, a triggering
+  #    relationship r can be derived from element a to element d.
+  #
+  # Moreover, triggering relationships are transitive:
+  #
+  # *  If there is a triggering relationship from element a to element b, and a
+  #    triggering relationship from element b to element c, a triggering
+  #    relationship can be derived from element a to element c.
   class DerivedRelations
-    PASS_ALL = lambda { |_item| true }
-    FAIL_ALL = lambda { |_item| false }
+    PASS_ALL = ->(_item) { true }
+    FAIL_ALL = ->(_item) { false }
 
     def initialize(model)
       @model = model
@@ -30,26 +83,16 @@ module Archimate
     #        below this element are not followed
     def derived_relations(start_elements, relationship_filter, target_filter, stop_filter = FAIL_ALL)
       traverse(start_elements, relationship_filter, stop_filter)
-        .reject { |path| Array(path).size <= 1 } # See #2 above
-        .select { |path| target_filter.call(path.last.target) }
-        .map { |path|
-          DataModel::Relationship.new(
-            id: @model.make_unique_id,
-            type: derived_relationship_type(path),
-            source: path.first.source,
-            target: path.last.target,
-            derived: true
-          )
-        }
+        .reject(&single_relation_paths) # See #2 above
+        .select(&target_relations(target_filter))
+        .map(&create_relationship_for_path)
         .uniq { |rel| [rel.type, rel.source, rel.target] }
     end
 
     def derived_relationship_type(path)
-      DataModel::Relationship::WEIGHTS.rassoc(
-        path
-          .map(&:weight)
-          .min
-      ).first
+      path
+        .min_by(&:weight)
+        .class
     end
 
     # traverse returns an Array of paths (Array<Relationship>)
@@ -65,19 +108,11 @@ module Archimate
     #        returns true for.
     def traverse(start_elements, relation_filter, stop_filter, from_path = [])
       return [] if from_path.size > 100
-      start_elements.each_with_object([]) do |el, result|
-        immediate_rels = element_relationships(el)
-          .select(&relation_filter)
-          .reject { |rel| from_path.include?(rel) }
-
-        result.concat(immediate_rels)
-        result.concat(
-          *immediate_rels
-            .reject { |rel| rel.target.nil? || (stop_filter && stop_filter.call(rel)) }
-            .map { |rel|
-              traverse([rel.target], relation_filter, stop_filter, from_path + [rel])
-                .map { |path| Array(path).unshift(rel) }
-            }
+      start_elements.each_with_object([]) do |el, relations|
+        concrete_rels = concrete_relationships(el, relation_filter, from_path)
+        relations.concat(
+          concrete_rels,
+          *derived_relationship_paths(concrete_rels, relation_filter, stop_filter, from_path)
         )
       end
     end
@@ -91,5 +126,45 @@ module Archimate
         .relationships
         .select { |rel| rel.source.id == el.id }
     end
+
+    private
+
+    def concrete_relationships(el, relation_filter, from_path)
+      element_relationships(el)
+        .select(&relation_filter)
+        .reject { |rel| from_path.include?(rel) }
+    end
+
+    def derived_relationship_paths(concrete_rels, relation_filter, stop_filter, from_path)
+      concrete_rels
+        .reject { |rel| rel.target.nil? || (stop_filter&.call(rel)) }
+        .map do |rel|
+          traverse([rel.target], relation_filter, stop_filter, from_path + [rel])
+            .map { |path| Array(path).unshift(rel) }
+        end
+    end
+
+    def single_relation_paths
+      ->(path) { Array(path).size <= 1 }
+    end
+
+    def target_relations(target_filter)
+      ->(path) { target_filter.call(path.last.target) }
+    end
+
+    def create_relationship_for_path
+      lambda do |path|
+        derived_relationship_type(path).new(
+          id: @model.make_unique_id,
+          source: path.first.source,
+          target: path.last.target,
+          derived: true
+        )
+      end
+    end
+
+    def by_relation_uniq_attributes
+      ->(rel) { [rel.type, rel.source, rel.target] }
+    end
   end
 end

data/lib/archimate/export/cypher.rb

@@ -22,24 +22,6 @@
 #     accessType: Relationship.access_type
 #   Labels:
 #     Relationship.type
-#
-# | Weight | Name           |
-# |--------+----------------|
-# |      1 | Association    |
-# |      2 | Access         |
-# |      3 | Used by        |
-# |      4 | Realization    |
-# |      5 | Assignment     |
-# |      6 | Aggregation    |
-# |      7 | Composition    |
-# |      8 | Flow           |
-# |      9 | Triggering     |
-# |     10 | Grouping       |
-# |     11 | Junction       |
-# |     12 | Specialization |
-# Structural stronger than Dependency Relationships
-# ServingRelationship == UsedByRelationship
-
 
 module Archimate
   module Export

data/lib/archimate/export/jsonl.rb

@@ -45,7 +45,7 @@ require "json"
 module Archimate
   module Export
     def self.clean_json(hash)
-      JSON.generate(hash.delete_if { |_k,v| v.nil? || (v.is_a?(String) && v.empty?) })
+      JSON.generate(hash.delete_if { |_k, v| v.nil? || (v.is_a?(String) && v.empty?) })
     end
 
     class PropertiesHash
@@ -75,35 +75,17 @@ module Archimate
       # `nodeId`: "d8e75068-df75-4c21-a2af-fab5c195687a"
       def to_jsonl
         Export.clean_json(
-          {
-            _key: element.id,
-            name: element.name&.to_s,
-            layer: element.layer&.delete(" "),
-            type: element.type,
-            documentation: element.documentation&.to_s,
-            properties: PropertiesHash.new(element.properties).to_h
-          }
+          _key: element.id,
+          name: element.name&.to_s,
+          layer: element.layer&.name&.to_s&.delete(" "),
+          type: element.type,
+          documentation: element.documentation&.to_s,
+          properties: PropertiesHash.new(element.properties).to_h
         )
       end
     end
 
     class JsonlEdge
-      WEIGHTS = {
-        'GroupingRelationship' => 0,
-        'JunctionRelationship' => 0,
-        'AssociationRelationship' => 0,
-        'SpecialisationRelationship' => 1,
-        'FlowRelationship' => 2,
-        'TriggeringRelationship' => 3,
-        'InfluenceRelationship' => 4,
-        'AccessRelationship' => 5,
-        'UsedByRelationship' => 6,
-        'RealisationRelationship' => 7,
-        'AssignmentRelationship' => 8,
-        'AggregationRelationship' => 9,
-        'CompositionRelationship' => 10
-      }
-
       attr_reader :relationship
 
       def initialize(relationship)
@@ -112,28 +94,17 @@ module Archimate
 
       def to_jsonl
         Export.clean_json(
-          {
-            _key: relationship.id,
-            _from: relationship.source,
-            _to: relationship.target,
-            name: relationship.name&.to_s,
-            type: relationship.type,
-            accessType: relationship.access_type,
-            documentation: relationship.documentation&.to_s,
-            properties: PropertiesHash.new(relationship.properties).to_h,
-            weight: weight
-          }
+          _key: relationship.id,
+          _from: relationship.source,
+          _to: relationship.target,
+          name: relationship.name&.to_s,
+          type: relationship.type,
+          accessType: relationship.access_type,
+          documentation: relationship.documentation&.to_s,
+          properties: PropertiesHash.new(relationship.properties).to_h,
+          weight: relationship.weight
         )
       end
-
-      private
-      def weight
-        unless WEIGHTS.include?(relationship.type)
-          raise "Relationship type not found: \"#{relationship.type}\""
-          return 0
-        end
-        WEIGHTS[relationship.type]
-      end
     end
 
     class Jsonl

data/lib/archimate/export/n_quads.rb

@@ -103,35 +103,12 @@ module Archimate
 
       def relationships(el)
         [
-          make_quad(el.source.id, predicate(el.type), el.target.id),
+          make_quad(el.source.id, el.class::VERB, el.target.id),
           make_quad(el.id, "sources", el.source.id),
           make_quad(el.id, "target", el.target.id)
         ]
       end
 
-      PREDICATES = {
-        "AssociationRelationship" => %w(associated_with associated_with),
-        "AccessRelationship" => %w(accesses accessed_by),
-        "UsedByRelationship" => %w(used_by uses),
-        "ServingRelationship" => %w(serving served_by),
-        "RealisationRelationship" => %w(realizes realized_by),
-        "RealizationRelationship" => %w(realizes realized_by),
-        "AssignmentRelationship" => %w(assigned_to assigned_from),
-        "AggregationRelationship" => %w(aggregates aggregated_by),
-        "CompositionRelationship" => %w(composes composed_by),
-        "FlowRelationship" => %w(flows_to flows_from),
-        "TriggeringRelationship" => %w(triggers triggered_by),
-        "GroupingRelationship" => %w(groups grouped_by),
-        "SpecialisationRelationship" => %w(specializes specialized_by),
-        "SpecializationRelationship" => %w(specializes specialized_by),
-        "InfluenceRelationship" => %w(influences influenced)
-      }.freeze
-
-      def predicate(t)
-        raise "Unexpected relationship name: '#{t}'" unless PREDICATES.include?(t)
-        PREDICATES[t][0]
-      end
-
       def make_quad(subject, predicate, object)
         if subject.nil? || predicate.nil? || object.nil?
           raise(

data/lib/archimate/file_formats/archi_file_reader.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "nokogiri"
 
 module Archimate
@@ -8,7 +9,7 @@ module Archimate
         @string_or_io = doc
       end
 
-      def parse()
+      def parse
         handler_factory = Sax::Archi::ArchiHandlerFactory.new
         parser = Nokogiri::XML::SAX::Parser.new(Sax::Document.new(handler_factory))
         parser.parse(@string_or_io)

data/lib/archimate/file_formats/model_exchange_file_writer_21.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
+
 require "nokogiri"
 
 module Archimate
   module FileFormats
+    REL_NAME_MAPPING = {
+      DataModel::Relationships::Realization => "Realisation",
+      DataModel::Relationships::Serving => "UsedBy",
+      DataModel::Relationships::Specialization => "Specialisation"
+    }.freeze
+
     # Archimate version 2.1 Model Exchange Format Writer
     class ModelExchangeFileWriter21 < Serializer::ModelExchangeFile::ModelExchangeFileWriter
       include Serializer::ModelExchangeFile::V21::Connection
@@ -25,11 +32,12 @@ module Archimate
       end
 
       def relationship_attributes(relationship)
+        rel_name = REL_NAME_MAPPING.fetch(relationship.class, relationship.type)
         {
           identifier: identifier(relationship.id),
           source: identifier(relationship.source.id),
           target: identifier(relationship.target.id),
-          "xsi:type" => meff_type(relationship.type)
+          "xsi:type" => "#{rel_name}Relationship"
         }
       end
 

data/lib/archimate/file_formats/sax/archi/archi_handler_factory.rb

@@ -14,11 +14,11 @@ module Archimate
             when "element"
               element_type = Hash[attrs]["xsi:type"].sub(/archimate:/, '')
               case element_type
-              when DataModel::ElementType, DataModel::ConnectorType
+              when DataModel::Elements
                 Element
               when DataModel::DiagramType
                 Diagram
-              when DataModel::RelationshipType
+              when DataModel::Relationships
                 Relationship
               else
                 raise "Unexpected element_type #{element_type}"

data/lib/archimate/file_formats/sax/archi/connection.rb

@@ -25,7 +25,8 @@ module Archimate
               style: style,
               bendpoints: @bendpoints,
               documentation: documentation,
-              properties: properties
+              properties: properties,
+              diagram: diagram
             )
             [
               event(:on_connection, connection),

data/lib/archimate/file_formats/sax/archi/element.rb

@@ -23,11 +23,13 @@ module Archimate
           private
 
           def element
-            @element ||= DataModel::Element.new(id: @attrs["id"],
-                                                name: DataModel::LangString.string(process_text(@attrs["name"])),
-                                                type: element_type,
-                                                documentation: documentation,
-                                                properties: properties)
+            @element ||= DataModel::Elements.create(
+              id: @attrs["id"],
+              name: DataModel::LangString.string(process_text(@attrs["name"])),
+              type: element_type,
+              documentation: documentation,
+              properties: properties
+            )
           end
         end
       end

data/lib/archimate/file_formats/sax/archi/relationship.rb

@@ -25,7 +25,7 @@ module Archimate
           private
 
           def relationship
-            @relationship ||= DataModel::Relationship.new(
+            @relationship ||= DataModel::Relationships.create(
               id: @attrs["id"],
               type: element_type,
               source: nil,

data/lib/archimate/file_formats/sax/model_exchange_file/connection.rb

@@ -58,7 +58,8 @@ module Archimate
                                                       style: @style,
                                                       bendpoints: @bendpoints,
                                                       documentation: documentation,
-                                                      properties: properties)
+                                                      properties: properties,
+                                                      diagram: diagram)
           end
         end
       end

data/lib/archimate/file_formats/sax/model_exchange_file/element.rb

@@ -28,7 +28,7 @@ module Archimate
           private
 
           def element
-            @element ||= DataModel::Element.new(
+            @element ||= DataModel::Elements.create(
               id: attrs["identifier"],
               name: name,
               type: element_type,

data/lib/archimate/file_formats/sax/model_exchange_file/relationship.rb

@@ -31,7 +31,7 @@ module Archimate
           private
 
           def relationship
-            @relationship ||= DataModel::Relationship.new(
+            @relationship ||= DataModel::Relationships.create(
               id: attrs["identifier"],
               type: attrs["xsi:type"],
               source: nil,

data/lib/archimate/file_formats/sax/model_exchange_file/view_node.rb

@@ -22,7 +22,6 @@ module Archimate
           def complete
             [
               event(:on_future,
-                    # Fiber.new { |index| view_node.view_refs = index[attrs["model"]] },
                     Sax::FutureReference.new(view_node, :view_refs, attrs["model"])),
               event(:on_future,
                     Sax::FutureReference.new(view_node,

data/lib/archimate/file_formats/serializer/archi/relationship.rb

@@ -8,7 +8,7 @@ module Archimate
           def serialize_relationship(xml, rel)
             xml.element(
               remove_nil_values(
-                "xsi:type" => "archimate:#{rel.type}",
+                "xsi:type" => "archimate:#{rel.type}Relationship",
                 "id" => rel.id,
                 "name" => rel.name,
                 "source" => rel.source.id,

data/lib/archimate/lint/duplicate_entities.rb

@@ -1,42 +1,45 @@
+# frozen_string_literal: true
+
 module Archimate
   module Lint
-    STOP_WORDS = %w(
-          a able about above according accordingly across actually after afterwards again against all allow allows
-          almost alone along already also although always am among amongst amoungst amount an and another any anybody
-          anyhow anyone anything anyway anyways anywhere apart appear appreciate appropriate are around as aside ask
-          asking associated at available away awfully back be became because become becomes becoming been before
-          beforehand behind being believe below beside besides best better between beyond bill both bottom brief but
-          by call came can can't cannot cant cause causes certain certainly changes clearly co com come comes computer
-          con concerning consequently consider considering contain containing contains corresponding could couldn't
-          couldnt course cry currently de dear definitely describe described despite detail did didn't different do
-          does doesn't doing don't done down downwards due during each edu eg eight either eleven else elsewhere empty
-          enough entirely especially et etc even ever every everybody everyone everything everywhere ex exactly example
-          except far few fifteen fifth fify fill find fire first five followed following follows for former formerly
-          forth forty found four from front full further furthermore get gets getting give given gives go goes going
-          gone got gotten greetings had hadn't happens hardly has hasn't hasnt have haven't having he he's hello help
-          hence her here here's hereafter hereby herein hereupon hers herself hi him himself his hither hopefully how
-          howbeit however hundred i i'd i'll i'm i've ie if ignored immediate in inasmuch inc indeed indicate indicated
-          indicates inner insofar instead interest into inward is isn't it it'd it'll it's its itself just keep keeps
-          kept know known knows last lately later latter latterly least less lest let let's like liked likely little
-          look looking looks ltd made mainly many may maybe me mean meanwhile merely might mill mine more moreover most
-          mostly move much must my myself name namely nd near nearly necessary need needs neither never nevertheless
-          new next nine no nobody non none noone nor normally not nothing novel now nowhere obviously of off often oh
-          ok okay old on once one ones only onto or other others otherwise ought our ours ourselves out outside over
-          overall own part particular particularly per perhaps placed please plus possible presumably probably provides
-          put que quite qv rather rd re really reasonably regarding regardless regards relatively respectively right
-          said same saw say saying says second secondly see seeing seem seemed seeming seems seen self selves sensible
-          sent serious seriously seven several shall she should shouldn't show side since sincere six sixty so some
-          somebody somehow someone something sometime sometimes somewhat somewhere soon sorry specified specify
-          specifying still sub such sup sure system take taken tell ten tends th than thank thanks thanx that that's
-          thats the their theirs them themselves then thence there there's thereafter thereby therefore therein theres
-          thereupon these they they'd they'll they're they've thick thin think third this thorough thoroughly those
-          though three through throughout thru thus tis to together too took top toward towards tried tries truly try
-          trying twas twelve twenty twice two un under unfortunately unless unlikely until unto up upon us use used
-          useful uses using usually value various very via viz vs want wants was wasn't way we we'd we'll we're we've
-          welcome well went were weren't what what's whatever when whence whenever where where's whereafter whereas
-          whereby wherein whereupon wherever whether which while whither who who's whoever whole whom whose why will
-          willing wish with within without won't wonder would wouldn't yes yet you you'd you'll you're you've your
-          yours yourself yourselves zero).freeze
+    STOP_WORDS = %w[
+      a able about above according accordingly across actually after afterwards again against all allow allows
+      almost alone along already also although always am among amongst amoungst amount an and another any anybody
+      anyhow anyone anything anyway anyways anywhere apart appear appreciate appropriate are around as aside ask
+      asking associated at available away awfully back be became because become becomes becoming been before
+      beforehand behind being believe below beside besides best better between beyond bill both bottom brief but
+      by call came can can't cannot cant cause causes certain certainly changes clearly co com come comes computer
+      con concerning consequently consider considering contain containing contains corresponding could couldn't
+      couldnt course cry currently de dear definitely describe described despite detail did didn't different do
+      does doesn't doing don't done down downwards due during each edu eg eight either eleven else elsewhere empty
+      enough entirely especially et etc even ever every everybody everyone everything everywhere ex exactly example
+      except far few fifteen fifth fify fill find fire first five followed following follows for former formerly
+      forth forty found four from front full further furthermore get gets getting give given gives go goes going
+      gone got gotten greetings had hadn't happens hardly has hasn't hasnt have haven't having he he's hello help
+      hence her here here's hereafter hereby herein hereupon hers herself hi him himself his hither hopefully how
+      howbeit however hundred i i'd i'll i'm i've ie if ignored immediate in inasmuch inc indeed indicate indicated
+      indicates inner insofar instead interest into inward is isn't it it'd it'll it's its itself just keep keeps
+      kept know known knows last lately later latter latterly least less lest let let's like liked likely little
+      look looking looks ltd made mainly many may maybe me mean meanwhile merely might mill mine more moreover most
+      mostly move much must my myself name namely nd near nearly necessary need needs neither never nevertheless
+      new next nine no nobody non none noone nor normally not nothing novel now nowhere obviously of off often oh
+      ok okay old on once one ones only onto or other others otherwise ought our ours ourselves out outside over
+      overall own part particular particularly per perhaps placed please plus possible presumably probably provides
+      put que quite qv rather rd re really reasonably regarding regardless regards relatively respectively right
+      said same saw say saying says second secondly see seeing seem seemed seeming seems seen self selves sensible
+      sent serious seriously seven several shall she should shouldn't show side since sincere six sixty so some
+      somebody somehow someone something sometime sometimes somewhat somewhere soon sorry specified specify
+      specifying still sub such sup sure system take taken tell ten tends th than thank thanks thanx that that's
+      thats the their theirs them themselves then thence there there's thereafter thereby therefore therein theres
+      thereupon these they they'd they'll they're they've thick thin think third this thorough thoroughly those
+      though three through throughout thru thus tis to together too took top toward towards tried tries truly try
+      trying twas twelve twenty twice two un under unfortunately unless unlikely until unto up upon us use used
+      useful uses using usually value various very via viz vs want wants was wasn't way we we'd we'll we're we've
+      welcome well went were weren't what what's whatever when whence whenever where where's whereafter whereas
+      whereby wherein whereupon wherever whether which while whither who who's whoever whole whom whose why will
+      willing wish with within without won't wonder would wouldn't yes yet you you'd you'll you're you've your
+      yours yourself yourselves zero
+    ].freeze
 
     class DuplicateEntities
       attr_reader :word_count
@@ -47,7 +50,7 @@ module Archimate
         @dupes = nil
         @count = nil
         @word_count = {}
-        @ignored_entity_types = %w(Junction AndJunction OrJunction)
+        @ignored_entity_types = %w[Junction AndJunction OrJunction]
         dupe_list
       end
 
@@ -59,15 +62,16 @@ module Archimate
         count.zero?
       end
 
-      def each(&block)
+      def each
         @dupes.keys.sort.each do |name|
           ary = @dupes[name]
           element_type = ary.first.type
-          block.call(element_type, name, ary)
+          yield(element_type, name, ary)
         end
       end
 
       protected
+
       def candidate_entities
         @model.entities.select do |entity|
           (entity.is_a?(DataModel::Element) || entity.is_a?(DataModel::Relationship)) &&
@@ -86,7 +90,7 @@ module Archimate
       end
 
       def entity_hash_name(entity)
-        layer = DataModel::Layers.for_element(entity.type)
+        layer = entity.layer
         layer_sort_order = layer ? DataModel::Layers.find_index(layer) : 9
         [
           entity.class.name, # Taking advantage of Element being before Relationship
@@ -105,7 +109,7 @@ module Archimate
       # 5. names differ only by stop-words (list of words such as "the", "api", etc.)
       def simplify(entity)
         name = entity.name&.dup.to_s || ""
-        name.sub!("(copy)", "") # (copy) is a special case inserted by the Archi tool
+        name = name.sub("(copy)", "") # (copy) is a special case inserted by the Archi tool
         name.downcase!
         name.gsub!(/[[:punct:]]/, "") unless entity.is_a?(DataModel::Relationship)
         name.strip!