archimate 1.2.1 → 2.0.0

data/lib/archimate/data_model/archimate_node.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-module Archimate
-  module DataModel
-    class ArchimateNode < Dry::Struct
-      using DiffablePrimitive
-      using DiffableArray
-
-      constructor_type :schema # specifies constructor style for Dry::Struct
-
-      attr_writer :parent_attribute_name
-      attr_reader :struct_instance_variables
-
-      def initialize(attributes)
-        super
-        @struct_instance_variables = self.class.schema.keys
-      end
-
-      # TODO: Schedule this for eliminations
-      # Outside of test code, this is only used for the Bounds class
-      def with(options = {})
-        self.class.new(
-          struct_instance_variables
-            .each_with_object({}) { |i, a| a[i] = self[i] }
-            .merge(options)
-            .each_with_object({}) { |(k, v), a| a[k] = v.dup }
-        )
-      end
-
-      # Note: my clone method does one non-idiomatic thing - it does not clone the
-      # frozen state. TODO: respect the frozen state of the clone'd object.
-      def clone
-        self.class.new(
-          struct_instance_variables
-            .each_with_object({}) do |i, a|
-              a[i] = self[i].primitive? ? self[i] : self[i].clone
-            end
-        )
-      end
-
-      # Makes a copy of the archimate node which is not frozen
-      def dup
-        self.class.new(
-          struct_instance_variables
-            .each_with_object({}) do |i, a|
-              a[i] = self[i].primitive? ? self[i] : self[i].dup
-            end
-        )
-      end
-
-      def in_model
-        @in_model if defined?(@in_model)
-      end
-
-      def parent
-        @parent if defined?(@parent)
-      end
-
-      # TODO: this is used only such that every item has an id for sticking in the index.
-      # Is this really needed still?
-      def id
-        object_id
-      end
-
-      def ancestors
-        result = [self]
-        p = self
-        result << p until (p = p.parent).nil?
-        result
-      end
-
-      def primitive?
-        false
-      end
-
-      def parent=(par)
-        @parent = par
-        struct_instance_variables.each do |attrname|
-          self[attrname].parent = self
-        end
-      end
-
-      def parent_attribute_name
-        return @parent_attribute_name if defined?(@parent_attribute_name)
-        parent.find_index(self) if parent&.is_a?(Array)
-      end
-
-      def in_model=(model)
-        @in_model = model unless is_a?(Model)
-        struct_instance_variables.each { |attrname|
-          puts "#{attrname} is frozen in #{self.class}" if self[attrname].frozen? && self[attrname].is_a?(Array)
-          self[attrname].in_model = model }
-      end
-
-      def build_index(hash_index = {})
-        hash_index[id] = self unless id.nil?
-        struct_instance_variables.reduce(hash_index) do |a, e|
-          self[e].parent_attribute_name = e
-          self[e].build_index(a)
-        end
-      end
-
-      def diff(other)
-        raise ArgumentError, "other expected to be not nil" if other.nil?
-        raise TypeError, "Expected other <#{other.class} to be of type #{self.class}" unless other.is_a?(self.class)
-        struct_instance_variables.each_with_object([]) do |k, a|
-          val = self[k]
-          if val.nil?
-            a.concat([Diff::Insert.new(Diff::ArchimateNodeAttributeReference.new(other, k))]) unless other[k].nil?
-          elsif val.primitive?
-            a.concat(val.diff(other[k], self, other, k))
-          else
-            a.concat(val.diff(other[k]))
-          end
-        end
-      end
-
-      def path(options = {})
-        [
-          parent&.path(options),
-          path_identifier
-        ].compact.map(&:to_s).reject(&:empty?).join("/")
-      end
-
-      def compact!
-        struct_instance_variables.each { |attrname| self[attrname].compact! }
-        self
-      end
-
-      def delete(attrname)
-        if !attrname || attrname.empty?
-          raise(
-            ArgumentError,
-            "attrname was blank must be one of: #{struct_instance_variables.map(&:to_s).join(',')}"
-          )
-        end
-        in_model&.deregister(self[attrname])
-        instance_variable_set("@#{attrname}".to_sym, nil)
-        self
-      end
-
-      def set(attrname, value)
-        if !attrname
-          raise(
-            ArgumentError,
-            "attrname was blank must be one of: #{struct_instance_variables.map(&:to_s).join(',')}"
-          )
-        end #  || attrname.empty?
-        # value = value.clone
-        in_model&.register(value, self)
-        instance_variable_set("@#{attrname}".to_sym, value)
-        self
-      end
-
-      def referenced_identified_nodes
-        struct_instance_variables.reduce([]) do |a, e|
-          a.concat(self[e].referenced_identified_nodes)
-        end
-      end
-
-      def element_by_id(element_id)
-        return nil unless element_id
-        in_model&.lookup(element_id)
-      end
-
-      private
-
-      def path_identifier
-        case parent
-        when Array
-          find_my_index
-        else
-          parent_attribute_name
-        end
-      end
-
-      def find_my_index
-        parent.find_index(self)
-      end
-    end
-  end
-end

data/lib/archimate/data_model/concept.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Archimate
-  module DataModel
-    # This is an abstract class for Concepts (Elements, Relationships, Composites, and RelationConnectors).
-    class Concept < Referenceable
-      attribute :properties, PropertiesList
-      # group -> ConceptGroup # Empty. Available for Extension purposes.
-      # attributeGroup -> ConceptAttributeGroup # Empty. Available for Extension purposes.
-    end
-
-    Dry::Types.register_class(Concept)
-  end
-end

data/lib/archimate/data_model/constants.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-module Archimate
-  module DataModel
-    # The Constants module contains constants for ArchiMate standards
-    # TODO: This should be namespaced for the ArchiMate version in effect
-    module Constants
-      ELEMENTS = %w(BusinessActor BusinessCollaboration BusinessEvent BusinessFunction
-                    BusinessInteraction BusinessInterface BusinessObject BusinessProcess
-                    BusinessRole BusinessService Contract Location Meaning Value Product
-                    Representation ApplicationCollaboration ApplicationComponent
-                    ApplicationFunction ApplicationInteraction ApplicationInterface
-                    ApplicationService DataObject Artifact CommunicationPath Device
-                    InfrastructureFunction InfrastructureInterface InfrastructureService
-                    Network Node SystemSoftware Assessment Constraint Driver Goal Principle
-                    Requirement Stakeholder Deliverable Gap Plateau WorkPackage AndJunction
-                    Junction OrJunction Capability CourseOfAction Resource
-                    ApplicationProcess ApplicationEvent TechnologyCollaboration
-                    TechnologyInterface Path CommunicationNetwork
-                    TechnologyFunction TechnologyProcess TechnologyInteraction
-                    TechnologyEvent TechnologyService
-                    TechnologyObject Equipment Facility DistributionNetwork Material
-                    Outcome ImplementationEvent).freeze
-
-      RELATIONSHIPS = %w(AssociationRelationship AccessRelationship UsedByRelationship
-                         RealisationRelationship AssignmentRelationship AggregationRelationship
-                         CompositionRelationship FlowRelationship TriggeringRelationship
-                         GroupingRelationship SpecialisationRelationship InfluenceRelationship).freeze
-
-      LAYER_ELEMENTS = {
-        "Strategy" =>
-          %w(Capability CourseOfAction Resource),
-        "Business" =>
-          %w(BusinessActor BusinessCollaboration
-             BusinessEvent BusinessFunction
-             BusinessInteraction BusinessInterface
-             BusinessObject BusinessProcess
-             BusinessRole BusinessService
-             Contract Location
-             Meaning Value
-             Product Representation),
-        "Application" =>
-          %w(ApplicationCollaboration ApplicationComponent
-             ApplicationFunction ApplicationInteraction
-             ApplicationInterface ApplicationService
-             DataObject ApplicationProcess ApplicationEvent),
-        "Technology" =>
-          %w(Artifact CommunicationPath
-             Device InfrastructureFunction
-             InfrastructureInterface InfrastructureService
-             Network Node SystemSoftware TechnologyCollaboration
-             TechnologyInterface Path CommunicationNetwork
-             TechnologyFunction TechnologyProcess TechnologyInteraction
-             TechnologyEvent TechnologyService
-             TechnologyObject),
-        "Physical" =>
-          %w(Equipment Facility DistributionNetwork Material),
-        "Motivation" =>
-          %w(Assessment Constraint Driver
-             Goal Principle Requirement
-             Stakeholder Outcome),
-        "Implementation and Migration" =>
-          %w(Deliverable Gap Plateau
-             WorkPackage ImplementationEvent),
-        "Connectors" =>
-          %w(AndJunction Junction OrJunction)
-      }.freeze
-
-      ELEMENT_LAYER = LAYER_ELEMENTS.each_with_object({}) do |(layer, elements), el_layer_hash|
-        elements.each_with_object(el_layer_hash) { |element, a| a[element] = layer }
-      end
-
-      VIEWPOINTS = ["Total", "Actor Co-operation", "Application Behaviour",
-                    "Application Co-operation", "Application Structure", "Application Usage",
-                    "Business Function", "Business Process Co-operation", "Business Process",
-                    "Business Product", "Implementation and Deployment", "Information Structure",
-                    "Infrastructure Usage", "Infrastructure", "Layered", "Organisation",
-                    "Service Realization", "Stakeholder", "Goal Realization", "Goal Contribution",
-                    "Principles", "Requirements Realisation", "Motivation", "Project",
-                    "Migration", "Implementation and Migration"].freeze
-    end
-  end
-end

data/lib/archimate/data_model/container.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Archimate
-  module DataModel
-    # Node type to allow a Container in a Artifact. This is a visual grouping container.
-    class Container < ViewNode
-      # This is to support Nested Nodes on the Diagram
-      # The order of sibling nodes in their parent View or Node container as declared in the model
-      # instance dictates the z-order of the nodes. Given nodes A, B, and C as declared in that order,
-      # node B is considered to be in front of node A, node C is considered to be in front of node B, and
-      # node C is considered to be in front of nodes A and B.
-      attribute :nodes, Strict::Array.member(ViewNode)
-    end
-
-    Dry::Types.register_class(Container)
-  end
-end

data/lib/archimate/data_model/diffable_array.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-module Archimate
-  module DataModel
-    module DiffableArray
-      using DiffablePrimitive
-
-      refine Array do
-        using DiffablePrimitive
-
-        attr_writer :parent_attribute_name
-
-        def in_model
-          @in_model if defined?(@in_model)
-        end
-
-        def parent
-          @parent if defined?(@parent)
-        end
-
-        def id
-          object_id.to_s
-        end
-
-        def ancestors
-          result = [self]
-          p = self
-          result << p until (p = p.parent).nil?
-          result
-        end
-
-        def primitive?
-          false
-        end
-
-        # def diff(other)
-        #   raise TypeError, "Expected other #{other.class} to be of type #{self.class}" unless other.is_a?(self.class)
-        #   raise "Well Hell other #{other.path} in_model is nil" if other.in_model.nil?
-        #   raise "Well Hell my path `#{path}` in_model is nil" if in_model.nil?
-
-        #   result = []
-        #   remaining_content = Array.new(self) # TODO: I want a copy of the array, not a deep clone
-        #   other_enum = other.each_with_index
-
-        #   loop do
-        #     if other_enum.peek[0] == remaining_content[0]
-        #       other_enum.next
-        #       remaining_content.shift
-        #     elsif items_are_changed?(other, other_enum, remaining_content)
-        #       result.concat(compute_item_changes(other, other_enum, self, remaining_content[0]))
-        #       remaining_content.shift
-        #       other_enum.next
-        #     elsif !remaining_content.empty? && !other.smart_include?(remaining_content[0])
-        #       result << Diff::Delete.new(Diff::ArchimateArrayReference.new(self, smart_find(remaining_content[0])))
-        #       remaining_content.shift
-        #     elsif !smart_include?(other_enum.peek[0])
-        #       result << Diff::Insert.new(Diff::ArchimateArrayReference.new(other, other_enum.next[1]))
-        #     elsif smart_include?(other_enum.peek[0])
-        #       result << Diff::Move.new(
-        #         Diff::ArchimateArrayReference.new(other, other_enum.peek[1]),
-        #         Diff::ArchimateArrayReference.new(self, smart_find(other_enum.peek[0]))
-        #       )
-        #       remaining_item_idx = remaining_content.smart_find(other_enum.peek[0])
-        #       if remaining_item_idx
-        #         result.concat(compute_item_changes(other, other_enum, self, remaining_content[remaining_item_idx]))
-        #         remaining_content.delete_at(remaining_item_idx) if remaining_content.smart_include?(other_enum.peek[0])
-        #       end
-        #       other_enum.next
-        #     else
-        #       raise "Unhandled diff case for remaining_content: #{remaining_content[0]} and #{other_enum.peek[0]}"
-        #     end
-        #   end
-
-        #   result.concat(
-        #     remaining_content
-        #       .reject { |item| other.include?(item) }
-        #       .map do |item|
-        #         Diff::Delete.new(Diff::ArchimateArrayReference.new(self, find_index(item)))
-        #       end
-        #   )
-        # end
-
-        # TODO: This may not continue to live here. Only used by testing.
-        # def patch(diffs)
-        #   # TODO: Beware, order of diffs could break patching at the moment.
-        #   Array(diffs).each do |diff|
-        #     case diff
-        #     when Diff::Delete
-        #       delete_at(smart_find(diff.target.value))
-        #     when Diff::Insert
-        #       insert(diff.target.array_index, diff.target.value)
-        #     when Diff::Change
-        #       self[smart_find(diff.changed_from.value)] = diff.target.value
-        #     when Diff::Move
-        #       insert(diff.target.array_index, delete_at(smart_find(diff.target.value)))
-        #     else
-        #       raise "Unexpected diff type: #{diff.class}"
-        #     end
-        #   end
-        #   self
-        # end
-
-        def items_are_changed?(other, other_enum, remaining)
-          !remaining.empty? &&
-            case remaining[0]
-            when DataModel::Referenceable
-              remaining[0].id == other_enum.peek[0].id
-            when String, DataModel::ArchimateNode
-              !other.include?(remaining[0]) && !include?(other_enum.peek[0])
-            else
-              raise "Unhandled type for #{remaining[0].class}"
-            end
-        end
-
-        def compute_item_changes(other, other_enum, _myself, my_item)
-          case my_item
-          when DataModel::ArchimateNode
-            my_item.diff(other_enum.peek[0])
-          else
-            my_item.diff(other_enum.peek[0], self, other, other_enum.peek[1], find_index(my_item))
-          end
-        end
-
-        def in_model=(model)
-          puts "#{self.inspect} is frozen" if self.frozen?
-          @in_model = model
-          each { |item| item.in_model = model }
-        end
-
-        def parent=(par)
-          @parent = par
-          each { |i| i.parent = self }
-        end
-
-        def parent_attribute_name
-          @parent_attribute_name if defined?(@parent_attribute_name)
-        end
-
-        def build_index(hash_index = {})
-          reduce(hash_index) { |hi, array_item| array_item.build_index(hi) }
-        end
-
-        def path(options = {})
-          [
-            parent&.path(options),
-            parent_attribute_name
-          ].compact.reject(&:empty?).join("/")
-        end
-
-        def clone
-          map(&:clone)
-        end
-
-        def dup
-          map(&:dup)
-        end
-
-        def to_s
-          "#{parent}/#{parent_attribute_name}"
-        end
-
-        def referenced_identified_nodes
-          reduce([]) do |a, e|
-            a.concat(e.referenced_identified_nodes)
-          end
-        end
-
-        def find_by_id(an_id)
-          find { |el| el.id == an_id }
-        end
-
-        def smart_find(val = nil)
-          case val
-          when Referenceable
-            lazy.map(&:id).find_index(val.id)
-          else
-            find_index(val)
-          end
-        end
-
-        def smart_include?(val)
-          case val
-          when Referenceable
-            lazy.map(&:id).include?(val.id)
-          else
-            include?(val)
-          end
-        end
-
-        def smart_intersection(ary)
-          select { |item| ary.smart_include?(item) }
-        end
-
-        def after(idx)
-          return [] if idx >= size - 1
-          self[idx + 1..-1]
-        end
-
-        # Given a node in self and ary,
-        # return the idx of first node p in self that exists in both self and ary
-        # and is previous to node in self
-        def previous_item_index(ary, node)
-          return -1 unless ary.smart_include?(node)
-          initial_idx = smart_find(node)
-          return -1 if initial_idx.nil?
-
-          (initial_idx - 1).downto(0).find(-> { -1 }) do |idx|
-            ary.smart_include?(at(idx))
-          end
-        end
-      end
-    end
-  end
-end