archimate 2.0.2 → 2.0.3

data/lib/archimate/data_model/viewpoints.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+require "ruby-enum"
+
+module Archimate
+  module DataModel
+    # This module contains an enumeration of built-in ArchiMate viewpoint
+    # types. These viewpoints are a summary of the viewpoint types defined
+    # in ArchiMate versions 2 and 3.
+    class Viewpoints
+      include Ruby::Enum
+
+      # Basic Viewpoints
+      define :Introductory, Viewpoint.new(
+        id: "VIEWPOINT-INTRODUCTORY",
+        name: "Introductory",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      # Category:Composition Viewpoints that defines internal compositions and aggregations of elements.
+      define :Organization, Viewpoint.new(
+        id: "VIEWPOINT-ORGANIZATION",
+        name: "Organization",
+        allowed_element_types: ConnectorType.values + [
+          Elements::BusinessActor, Elements::BusinessCollaboration,
+          Elements::BusinessInterface, Elements::BusinessRole,
+          Elements::Location
+        ],
+        allowed_relationship_types: Relationships.default - [Relationships::Access, Relationships::Realization]
+      )
+
+      define :Application_platform, Viewpoint.new(
+        id: "VIEWPOINT-APPLICATION_PLATFORM",
+        name: "Application Platform",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      define :Information_structure, Viewpoint.new(
+        id: "VIEWPOINT-INFORMATION_STRUCTURE",
+        name: "Information Structure",
+        allowed_element_types: ConnectorType.values + [
+          Elements::Artifact, Elements::BusinessObject, Elements::DataObject,
+          Elements::Meaning, Elements::Representation
+        ],
+        allowed_relationship_types: Relationships.default - [Relationships::Assignment, Relationships::Serving]
+      )
+
+      define :Technology, Viewpoint.new(
+        id: "VIEWPOINT-TECHNOLOGY",
+        name: "Technology",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      define :Layered, Viewpoint.new(
+        id: "VIEWPOINT-LAYERED",
+        name: "Layered",
+        allowed_element_types: Elements.classes + ConnectorType.values,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      define :Physical, Viewpoint.new(
+        id: "VIEWPOINT-PHYSICAL",
+        name: "Physical",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      # Category:Support Viewpoints where you are looking at elements that are
+      # supported by other elements. Typically from one layer and upwards to an
+      # above layer.
+      define :Product, Viewpoint.new(
+        id: "VIEWPOINT-PRODUCT",
+        name: "Product",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationComponent, Elements::ApplicationInterface,
+          Elements::ApplicationService, Elements::BusinessActor,
+          Elements::BusinessEvent, Elements::BusinessFunction,
+          Elements::BusinessInteraction, Elements::BusinessInterface,
+          Elements::BusinessProcess, Elements::BusinessRole,
+          Elements::BusinessService, Elements::Contract,
+          Elements::Product, Elements::Value
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Application_usage, Viewpoint.new(
+        id: "VIEWPOINT-APPLICATION_USAGE",
+        name: "Application Usage",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationCollaboration, Elements::ApplicationComponent,
+          Elements::ApplicationInterface, Elements::ApplicationService,
+          Elements::BusinessEvent, Elements::BusinessFunction,
+          Elements::BusinessInteraction, Elements::BusinessObject,
+          Elements::BusinessProcess, Elements::BusinessRole,
+          Elements::DataObject
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Technology_usage, Viewpoint.new(
+        id: "VIEWPOINT-TECHNOLOGY_USAGE",
+        name: "Technology Usage",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      # Category:Cooperation Towards peer elements which cooperate with each
+      # other. Typically across aspects.
+      define :Business_process_cooperation, Viewpoint.new(
+        id: "VIEWPOINT-BUSINESS_PROCESS_COOPERATION",
+        name: "Business Process Cooperation",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationService, Elements::BusinessActor,
+          Elements::BusinessCollaboration, Elements::BusinessEvent,
+          Elements::BusinessFunction, Elements::BusinessInteraction,
+          Elements::BusinessObject, Elements::BusinessProcess,
+          Elements::BusinessRole, Elements::BusinessService,
+          Elements::Location, Elements::Representation
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Application_cooperation, Viewpoint.new(
+        id: "VIEWPOINT-APPLICATION_COOPERATION",
+        name: "Application Cooperation",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationCollaboration, Elements::ApplicationComponent,
+          Elements::ApplicationFunction, Elements::ApplicationInteraction,
+          Elements::ApplicationInterface, Elements::ApplicationService,
+          Elements::DataObject, Elements::Location
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      # Category:Realization Viewpoints where you are looking at elements that
+      # realize other elements. Typically from one layer and downwards to a
+      # below layer.
+      define :Service_realization, Viewpoint.new(
+        id: "VIEWPOINT-SERVICE_REALIZATION",
+        name: "Service Realization",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationCollaboration, Elements::ApplicationComponent,
+          Elements::ApplicationService, Elements::BusinessActor,
+          Elements::BusinessCollaboration, Elements::BusinessEvent,
+          Elements::BusinessFunction, Elements::BusinessInteraction,
+          Elements::BusinessObject, Elements::BusinessProcess,
+          Elements::BusinessRole, Elements::BusinessService,
+          Elements::DataObject
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Implementation_and_deployment, Viewpoint.new(
+        id: "VIEWPOINT-IMPLEMENTATION_AND_DEPLOYMENT",
+        name: "Implementation and Deployment",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationCollaboration, Elements::ApplicationComponent,
+          Elements::Artifact, Elements::CommunicationPath,
+          Elements::DataObject, Elements::Device,
+          Elements::InfrastructureService, Elements::Network, Elements::Node,
+          Elements::SystemSoftware
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Goal_realization, Viewpoint.new(
+        id: "VIEWPOINT-GOAL_REALIZATION",
+        name: "Goal Realization",
+        allowed_element_types: [
+          Elements::Constraint, Elements::Goal, Elements::Principle,
+          Elements::Requirement
+        ],
+        allowed_relationship_types: [
+          Relationships::Aggregation, Relationships::Association,
+          Relationships::Composition, Relationships::Influence,
+          Relationships::Realization, Relationships::Specialization
+        ]
+      )
+
+      define :Goal_contribution, Viewpoint.new(
+        id: "VIEWPOINT-GOAL_CONTRIBUTION",
+        name: "Goal Contribution",
+        allowed_element_types: [
+          Elements::Constraint, Elements::Goal, Elements::Principle,
+          Elements::Requirement
+        ],
+        allowed_relationship_types: [
+          Relationships::Aggregation, Relationships::Association,
+          Relationships::Composition, Relationships::Influence,
+          Relationships::Realization, Relationships::Specialization
+        ]
+      )
+
+      define :Principles, Viewpoint.new(
+        id: "VIEWPOINT-PRINCIPLES",
+        name: "Principles",
+        allowed_element_types: [Elements::Goal, Elements::Principle],
+        allowed_relationship_types: [
+          Relationships::Aggregation, Relationships::Association,
+          Relationships::Composition, Relationships::Influence,
+          Relationships::Realization, Relationships::Specialization
+        ]
+      )
+
+      define :Requirements_realization, Viewpoint.new(
+        id: "VIEWPOINT-REQUIREMENTS_REALIZATION",
+        name: "Requirements Realization",
+        allowed_element_types: Elements.core_elements + ConnectorType.values + [
+          Elements::Constraint, Elements::Goal, Elements::Requirement
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Motivation, Viewpoint.new(
+        id: "VIEWPOINT-MOTIVATION",
+        name: "Motivation",
+        allowed_element_types: [
+          Elements::Assessment, Elements::Constraint, Elements::Driver,
+          Elements::Goal, Elements::Principle, Elements::Requirement,
+          Elements::Stakeholder
+        ],
+        allowed_relationship_types: [
+          Relationships::Aggregation, Relationships::Association,
+          Relationships::Composition, Relationships::Flow,
+          Relationships::Influence, Relationships::Realization,
+          Relationships::Specialization
+        ]
+      )
+
+      # Strategy Viewpoints
+      define :Strategy, Viewpoint.new(
+        id: "VIEWPOINT-STRATEGY",
+        name: "Strategy",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      define :Capability_map, Viewpoint.new(
+        id: "VIEWPOINT-CAPABILITY_MAP",
+        name: "Capability Map",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      define :Outcome_realization, Viewpoint.new(
+        id: "VIEWPOINT-OUTCOME_REALIZATION",
+        name: "Outcome Realization",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      define :Resource_map, Viewpoint.new(
+        id: "VIEWPOINT-RESOURCE_MAP",
+        name: "Resource Map",
+        allowed_element_types: Elements.core_elements,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      # Implementation and Migration Viewpoints
+      define :Project, Viewpoint.new(
+        id: "VIEWPOINT-PROJECT",
+        name: "Project",
+        allowed_element_types: ConnectorType.values + [
+          Elements::BusinessActor, Elements::BusinessRole,
+          Elements::Deliverable, Elements::Goal, Elements::WorkPackage
+        ],
+        allowed_relationship_types: Relationships.default - [Relationships::Access]
+      )
+
+      define :Migration, Viewpoint.new(
+        id: "VIEWPOINT-MIGRATION",
+        name: "Migration",
+        allowed_element_types: ConnectorType.values + [Elements::Gap, Elements::Plateau],
+        allowed_relationship_types: [
+          Relationships::AndJunction, Relationships::Association,
+          Relationships::Composition, Relationships::Flow,
+          Relationships::Junction, Relationships::OrJunction,
+          Relationships::Triggering
+        ]
+      )
+
+      define :Implementation_and_migration, Viewpoint.new(
+        id: "VIEWPOINT-IMPLEMENTATION_AND_MIGRATION",
+        name: "Implementation and Migration",
+        allowed_element_types: Elements.core_elements + ConnectorType.values + [
+          Elements::Location, Elements::Requirement, Elements::Constraint,
+          Elements::Goal, Elements::BusinessRole, Elements::WorkPackage,
+          Elements::Deliverable, Elements::BusinessActor, Elements::Plateau,
+          Elements::Gap
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      # Other Viewpoints
+      define :Stakeholder, Viewpoint.new(
+        id: "VIEWPOINT-STAKEHOLDER",
+        name: "Stakeholder",
+        allowed_element_types: [
+          Elements::Assessment, Elements::Driver, Elements::Goal,
+          Elements::Stakeholder
+        ],
+        allowed_relationship_types: [
+          Relationships::Aggregation, Relationships::Association,
+          Relationships::Composition, Relationships::Influence,
+          Relationships::Specialization
+        ]
+      )
+
+      # Other older viewpoints
+      define :Actor_cooperation, Viewpoint.new(
+        id: "VIEWPOINT-ACTOR_COOPERATION",
+        name: "Actor Co-operation",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationComponent, Elements::ApplicationInterface,
+          Elements::ApplicationService, Elements::BusinessActor,
+          Elements::BusinessCollaboration, Elements::BusinessInterface,
+          Elements::BusinessRole, Elements::BusinessService
+        ],
+        allowed_relationship_types: Relationships.default - [Relationships::Access]
+      )
+
+      define :Business_function, Viewpoint.new(
+        id: "VIEWPOINT-BUSINESS_FUNCTION",
+        name: "Business Function",
+        allowed_element_types: ConnectorType.values + [
+          Elements::BusinessActor, Elements::BusinessFunction,
+          Elements::BusinessRole
+        ],
+        allowed_relationship_types: Relationships.default - [Relationships::Access, Relationships::Realization]
+      )
+
+      define :Business_process, Viewpoint.new(
+        id: "VIEWPOINT-BUSINESS_PROCESS",
+        name: "Business Process",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationService, Elements::BusinessActor,
+          Elements::BusinessCollaboration, Elements::BusinessEvent,
+          Elements::BusinessFunction, Elements::BusinessInteraction,
+          Elements::BusinessObject, Elements::BusinessProcess,
+          Elements::BusinessRole, Elements::BusinessService,
+          Elements::Location, Elements::Representation
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Application_behavior, Viewpoint.new(
+        id: "VIEWPOINT-APPLICATION_BEHAVIOR",
+        name: "Application Behavior",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationCollaboration, Elements::ApplicationComponent,
+          Elements::ApplicationFunction, Elements::ApplicationInteraction,
+          Elements::ApplicationInterface, Elements::ApplicationService,
+          Elements::DataObject
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Application_structure, Viewpoint.new(
+        id: "VIEWPOINT-APPLICATION_STRUCTURE",
+        name: "Application Structure",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationCollaboration, Elements::ApplicationComponent,
+          Elements::ApplicationInterface, Elements::DataObject
+        ],
+        allowed_relationship_types: Relationships.default - [Relationships::Realization]
+      )
+
+      define :Infrastructure, Viewpoint.new(
+        id: "VIEWPOINT-INFRASTRUCTURE",
+        name: "Infrastructure",
+        allowed_element_types: ConnectorType.values + [
+          Elements::Artifact, Elements::CommunicationPath, Elements::Device,
+          Elements::InfrastructureFunction, Elements::InfrastructureInterface,
+          Elements::InfrastructureService, Elements::Location,
+          Elements::Network, Elements::Node, Elements::SystemSoftware
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Infrastructure_usage, Viewpoint.new(
+        id: "VIEWPOINT-INFRASTRUCTURE_USAGE",
+        name: "Infrastructure Usage",
+        allowed_element_types: ConnectorType.values + [
+          Elements::ApplicationComponent, Elements::ApplicationFunction,
+          Elements::CommunicationPath, Elements::Device,
+          Elements::InfrastructureFunction, Elements::InfrastructureInterface,
+          Elements::InfrastructureService, Elements::Network, Elements::Node,
+          Elements::SystemSoftware
+        ],
+        allowed_relationship_types: Relationships.default
+      )
+
+      define :Landscape_map, Viewpoint.new(
+        id: "VIEWPOINT-LANDSCAPE_MAP",
+        name: "Landscape Map",
+        allowed_element_types: Elements.classes + ConnectorType.values,
+        allowed_relationship_types: Relationships.classes
+      )
+
+      def self.[](idx)
+        values[idx]
+      end
+
+      def self.with_name(name)
+        values.find { |vp| vp.name == name }
+      end
+
+      VIEWPOINT_CONTENT_ENUM = %w[Details Coherence Overview].freeze
+
+      VIEWPOINT_PURPOSE_ENUM = %w[Designing Deciding Informing].freeze
+    end
+  end
+end

data/lib/archimate/data_model.rb

@@ -30,13 +30,19 @@ module Archimate
     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/viewpoints'
     require 'archimate/data_model/location'
     require 'archimate/data_model/connection'
     require 'archimate/data_model/view_node'
     require 'archimate/data_model/diagram'
     require 'archimate/data_model/model'
+
+    # Returns a lambda that matches entities with the given name
+    def by_name(name)
+      ->(entity) { entity.name == name }
+    end
+    module_function :by_name
   end
 end

data/lib/archimate/derived_relations.rb

@@ -117,20 +117,11 @@ module Archimate
       end
     end
 
-    def element_by_name(name)
-      @model.elements.find { |el| el.name.to_s == name.to_s }
-    end
-
-    def element_relationships(el)
-      @model
-        .relationships
-        .select { |rel| rel.source.id == el.id }
-    end
-
     private
 
     def concrete_relationships(el, relation_filter, from_path)
-      element_relationships(el)
+      el
+        .source_relationships
         .select(&relation_filter)
         .reject { |rel| from_path.include?(rel) }
     end

data/lib/archimate/export/cypher.rb

@@ -49,7 +49,7 @@ module Archimate
         elements.each do |element|
           props = add_docs(
             {
-              layer: element.layer.delete(" "),
+              layer: element.layer.to_s,
               name: element.name.to_s,
               nodeId: element.id
             }.merge(
@@ -99,11 +99,12 @@ module Archimate
       end
 
       def source(rel)
-        "(s #{props(nodeId: rel.source)})"
+        "(s #{props(nodeId: rel.source.id)})"
       end
 
-      def add_docs(h, l)
-        t = l.map(&:text).join("\n").strip
+      def add_docs(h, documentation)
+        return h unless documentation
+        t = documentation.to_s.strip
         return h if t.empty?
         h.merge(documentation: t)
       end
@@ -121,7 +122,7 @@ module Archimate
       end
 
       def target(rel)
-        "(t #{props(nodeId: rel.target)})"
+        "(t #{props(nodeId: rel.target.id)})"
       end
 
       def write(str)

data/lib/archimate/file_format.rb

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

data/lib/archimate/file_formats/archi_file_reader.rb

@@ -13,7 +13,17 @@ module Archimate
         handler_factory = Sax::Archi::ArchiHandlerFactory.new
         parser = Nokogiri::XML::SAX::Parser.new(Sax::Document.new(handler_factory))
         parser.parse(@string_or_io)
-        parser.document.model
+        model = parser.document.model
+        model
+          .diagrams
+          .flat_map(&:connections)
+          .each do |connection|
+            connection.bendpoints.each do |bendpoint|
+              bendpoint.x += connection.start_location.x.to_i
+              bendpoint.y += connection.start_location.y.to_i
+            end
+          end
+        model
       end
     end
   end

data/lib/archimate/file_formats/archi_file_writer.rb

@@ -1,57 +1,26 @@
 # frozen_string_literal: true
-require "nokogiri"
+
+require "forwardable"
 
 module Archimate
   module FileFormats
-    class ArchiFileWriter < Serializer::Writer
-      include Serializer::Archi::Bounds
-      include Serializer::Archi::Connection
-      include Serializer::Archi::Diagram
-      include Serializer::Archi::Documentation
-      include Serializer::Archi::Element
-      include Serializer::Archi::Location
-      include Serializer::Archi::Model
-      include Serializer::Archi::Organization
-      include Serializer::Archi::Property
-      include Serializer::Archi::Relationship
-      include Serializer::Archi::ViewNode
+    class ArchiFileWriter
+      extend Forwardable
 
-      TEXT_SUBSTITUTIONS = [
-        ['&#13;', '&#xD;'],
-        ['"', '&quot;'],
-        ['&gt;', '>'],
-        ['&#38;', '&amp;']
-      ].freeze
+      def_delegators :@writer, :write
 
-      def initialize(model)
-        super
-        @version = "3.1.1"
+      def self.write(model, output_io)
+        writer = new(model)
+        writer.write(output_io)
       end
 
-      def process_text(doc_str)
-        %w(documentation content name).each do |tag|
-          TEXT_SUBSTITUTIONS.each do |from, to|
-            doc_str.gsub!(%r{<#{tag}>([^<]*#{from}[^<]*)</#{tag}>}) do |str|
-              str.gsub(from, to)
-            end
-          end
-        end
-        doc_str.gsub(
-          %r{<(/)?archimate:}, "<\\1"
-        ).gsub(
-          %r{<(/)?model}, "<\\1archimate:model"
-        )
-      end
-
-      def write(archifile_io)
-        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
-          serialize_model(xml, model)
-        end
-        archifile_io.write(
-          process_text(
-            builder.to_xml
-          )
-        )
+      def initialize(model)
+        @writer = case model.version
+                  when /^3\./
+                    Serializer::Archi::ArchiFileWriter3
+                  else
+                    Serializer::Archi::ArchiFileWriter4
+                  end.new(model)
       end
     end
   end

data/lib/archimate/file_formats/archi_file_writer_4.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    class ArchiFileWriter4 < Serializer::Archi::ArchiFileWriter
+      include Serializer::Archi::Viewpoint4
+
+      def initialize(model)
+        super
+        @version = model.version || "4.0.0"
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/model_exchange_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::ModelExchangeFile::ModelExchangeHandlerFactory.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

@@ -26,6 +26,7 @@ module Archimate
       include Serializer::ModelExchangeFile::Relationship
       include Serializer::ModelExchangeFile::Style
       include Serializer::ModelExchangeFile::V21::ViewNode
+      include Serializer::ModelExchangeFile::V21::Viewpoint
 
       def initialize(model)
         super