archimate 1.1.0

data/lib/archimate/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "logger"
+require "singleton"
+require "observer"
+
+module Archimate
+  # This is the singleton class that contains application configuration.
+  class Config
+    include Singleton
+    include Observable
+
+    attr_reader :interactive
+    attr_reader :logger
+
+    def initialize
+      @interactive = true
+      @logger ||= Logger.new(STDERR, progname: "archimate")
+    end
+
+    def interactive=(interactive)
+      return @interactive unless @interactive != interactive
+      @interactive = interactive
+      changed
+      notify_observers(:interactive, @interactive)
+    end
+
+    def logger=(logger)
+      return @logger unless @logger != logger
+      @logger = logger
+      changed
+      notify_observers(:logger, @logger)
+    end
+  end
+end

data/lib/archimate/data_model/any_attribute.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # An instance of any XML attribute for arbitrary content like metadata
+    class AnyAttribute < ArchimateNode
+      attribute :attribute, Strict::String
+      attribute :prefix, Strict::String
+      attribute :value, Strict::String
+    end
+    Dry::Types.register_class(AnyAttribute)
+  end
+end

data/lib/archimate/data_model/any_element.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # An instance of any XML element for arbitrary content like metadata
+    class AnyElement < ArchimateNode
+      attribute :element, Strict::String
+      attribute :prefix, Strict::String.optional
+      attribute :attributes, Strict::Array.member(AnyAttribute).default([])
+      attribute :content, Strict::String.optional
+      attribute :children, Strict::Array.member(AnyElement).default([])
+    end
+    Dry::Types.register_class(AnyElement)
+  end
+end

data/lib/archimate/data_model/archimate_node.rb

@@ -0,0 +1,181 @@
+# 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/bounds.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    class Bounds < ArchimateNode
+      attribute :x, Coercible::Float.optional
+      attribute :y, Coercible::Float.optional
+      attribute :width, Coercible::Float
+      attribute :height, Coercible::Float
+
+      def self.zero
+        Archimate::DataModel::Bounds.new(x: 0, y: 0, width: 0, height: 0)
+      end
+
+      def to_s
+        "Bounds(x: #{x}, y: #{y}, width: #{width}, height: #{height})"
+      end
+
+      def x_range
+        Range.new(left, right)
+      end
+
+      def y_range
+        Range.new(top, bottom)
+      end
+
+      def top
+        y || 0
+      end
+
+      def bottom
+        top + height
+      end
+
+      def right
+        left + width
+      end
+
+      def left
+        x || 0
+      end
+
+      def is_above?(other)
+        bottom < other.top
+      end
+
+      def is_below?(other)
+        top > other.bottom
+      end
+
+      def is_right_of?(other)
+        left > other.right
+      end
+
+      def is_left_of?(other)
+        right < other.left
+      end
+
+      def reduced_by(val)
+        Bounds.new(x: left + val, y: top + val, width: width - val * 2, height: height - val * 2)
+      end
+
+      def inside?(other)
+        left > other.left &&
+          right < other.right &&
+          top > other.top &&
+          bottom < other.bottom
+      end
+    end
+
+    Dry::Types.register_class(Bounds)
+  end
+end

data/lib/archimate/data_model/color.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    # RGBColorType in the XSD
+    # RGB Color type.
+    # The r, g, b attributes range from 0 - 255.
+    # The a (alpha) transparency attribute is optional. 0 = full transparency, 100 = opaque.
+    class Color < ArchimateNode
+      attribute :r, Coercible::Int.constrained(lt: 256, gt: -1)
+      attribute :g, Coercible::Int.constrained(lt: 256, gt: -1)
+      attribute :b, Coercible::Int.constrained(lt: 256, gt: -1)
+      attribute :a, Coercible::Int.constrained(lt: 101, gt: -1).optional
+
+      def self.rgba(str)
+        return nil if str.nil?
+        md = str.match(/#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?/)
+        return nil unless md
+        new(
+          r: md[1].to_i(16),
+          g: md[2].to_i(16),
+          b: md[3].to_i(16),
+          a: md[4].nil? ? 100 : (md[4].to_i(16) / 256.0 * 100.0).to_i
+        )
+      end
+
+      def self.black
+        new(r: 0, g: 0, b: 0, a: 100)
+      end
+
+      def to_s
+        "Color(r: #{r}, g: #{g}, b: #{b}, a: #{a})"
+      end
+
+      def to_rgba
+        a == 100 ? format("#%02x%02x%02x", r, g, b) : format("#%02x%02x%02x%02x", r, g, b, scaled_alpha)
+      end
+
+      private
+
+      def scaled_alpha(max = 255)
+        (max * (a / 100.0)).round
+      end
+    end
+
+    Dry::Types.register_class(Color)
+  end
+end

data/lib/archimate/data_model/concept.rb

@@ -0,0 +1,14 @@
+# 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/concern.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # document attribute holds all the concern information.
+    #
+    # This is ConcernType in the XSD
+    class Concern < ArchimateNode
+      attribute :labels, Strict::Array.member(LangString).constrained(min_size: 1)
+      attribute :documentation, DocumentationGroup
+      attribute :stakeholders, Strict::Array.member(LangString)
+    end
+
+    Dry::Types.register_class(Concern)
+    ConcernList = Strict::Array.member(Concern).default([])
+  end
+end

data/lib/archimate/data_model/connection.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    # Graphical connection type.
+    #
+    # 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.
+    #
+    # This is ConnectionType in the XSD
+    # ViewConceptType > ConnectionType > SourcedConnectionType > Relationship > NestingRelationship
+    #                                  > Line
+    #                 > ViewNodeType >
+    #                                  Label
+    #                                  Container > Element
+    class Connection < Referenceable # ViewConcept
+      using DiffableArray
+
+      attribute :source_attachment, Location.optional
+      attribute :bendpoints, LocationList
+      attribute :target_attachment, Location.optional
+      attribute :source, Identifier.optional
+      attribute :target, Identifier.optional
+      attribute :type, Strict::String.optional
+
+      # This is under Relationship
+      attribute :relationship, Strict::String.optional
+
+      # Note: this is added under ViewConcept
+      attribute :style, Style.optional
+      attribute :properties, PropertiesList
+
+      def replace(entity, with_entity)
+        @relationship = with_entity.id if (relationship == entity.id)
+        @source = with_entity.id if (source == entity.id)
+        @target = with_entity.id if (target == entity.id)
+      end
+
+      def type_name
+        Archimate::Color.color("#{Archimate::Color.data_model('Connection')}[#{Archimate::Color.color(@name || '', [:white, :underline])}]", :on_light_magenta)
+      end
+
+      def relationship_element
+        in_model.lookup(relationship)
+      end
+
+      def element
+        relationship_element
+      end
+
+      def source_element
+        in_model.lookup(source)
+      end
+
+      def target_element
+        in_model.lookup(target)
+      end
+
+      def to_s
+        if in_model
+          s = in_model.lookup(source) unless source.nil?
+          t = in_model.lookup(target) unless target.nil?
+        else
+          s = source
+          t = target
+        end
+        "#{type_name} #{s.nil? ? 'nothing' : s} -> #{t.nil? ? 'nothing' : t}"
+      end
+
+      def description
+        [
+          name.nil? ? nil : "#{name}: ",
+          source_element&.description,
+          relationship_element&.description,
+          target_element&.description
+        ].compact.join(" ")
+      end
+
+      def referenced_identified_nodes
+        [@source, @target, @relationship].compact
+      end
+
+      # This is used when rendering a connection to connection relationship.
+      def nodes
+        []
+      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
+        end
+        offset
+      end
+    end
+    Dry::Types.register_class(Connection)
+    ConnectionList = Strict::Array.member("archimate.data_model.connection").default([])
+  end
+end

data/lib/archimate/data_model/constants.rb

@@ -0,0 +1,82 @@
+# 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

@@ -0,0 +1,17 @@
+# 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/diagram.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Archimate
+  module DataModel
+    class Diagram < View
+      attribute :nodes, Strict::Array.member(ViewNode).default([])
+      attribute :connection_router_type, Coercible::Int.optional # TODO: Archi formats only fill this in, should be an enum
+      attribute :background, Coercible::Int.optional # value of 0 on Archi Sketch Model
+      attribute :connections, Strict::Array.member(Connection).default([])
+
+      def all_nodes
+        nodes.inject(Array.new(nodes)) { |child_ary, child| child_ary.concat(child.all_nodes) }
+      end
+
+      def elements
+        @elements ||= all_nodes.map(&:element).compact
+      end
+
+      def element_ids
+        @element_ids ||= all_nodes.map(&:archimate_element).compact
+      end
+
+      def relationships
+        @relationships ||= connections.map(&:element).compact
+      end
+
+      def relationship_ids
+        @relationship_ids ||= connections.map(&:relationship).compact
+      end
+
+      def to_s
+        "#{Archimate::Color.data_model('Diagram')}<#{id}>[#{Archimate::Color.color(name, [:white, :underline])}]"
+      end
+
+      def total_viewpoint?
+        viewpoint_type.nil? || viewpoint_type.empty?
+      end
+    end
+    Dry::Types.register_class(Diagram)
+  end
+end