archimate 1.2.1 → 2.0.0

data/lib/archimate/export/graph_ml.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 # This module takes an ArchiMate model and builds GraphML representation of it.
 require "set"
+require "nokogiri"
 
 module Archimate
   module Export
@@ -81,14 +82,15 @@ module Archimate
       end
 
       def docs(xml, docs)
-        docs.each do |doc|
-          data(xml, "documentation", doc)
+        return unless docs
+        docs.langs.each do |lang|
+          data(xml, "documentation", docs.by_lang(lang))
         end
       end
 
       def nodes(xml, elements)
         elements.each do |element|
-          node(xml, element.id, element.name, element.type, element.documentation, element.properties)
+          node(xml, element.id, element.name, element.type, docs: element.documentation, properties: element.properties)
 
           @layers[element.layer] << element.id
         end
@@ -106,7 +108,7 @@ module Archimate
         end
       end
 
-      def node(xml, id, name, type, docs = [], properties = [], other_data = {})
+      def node(xml, id, name, type, other_data = {}, docs: nil, properties: [])
         xml.node(id: id, label: name, labels: "#{type}:#{name}") do
           data_type(xml, "element-type", type)
           name(xml, name)
@@ -118,7 +120,7 @@ module Archimate
         properties(xml, id, properties)
       end
 
-      def edge(xml, id, source, target, type, name = nil, docs = [], properties = [])
+      def edge(xml, id, source, target, type, name = nil, docs = nil, properties = [])
         xml.edge(id: id, source: source, target: target, label: type) do
           data_type(xml, "relationship-type", type)
           name(xml, name)

data/lib/archimate/export/jsonl.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# This module takes an ArchiMate model and builds a JSONL representation of it
+# suitable for import into ArangoDB
+#
+# Node Schema:
+#   Properties:
+#     name: Element.name
+#     nodelId: Element.id
+#     layer: Element.layer
+#     documentation: Element.documentation
+#     Element.properties
+#      ("prop:#{Property.key}"): Property.value
+#   Labels:
+#     Element.type
+#
+# Edge Schema:
+#   Properties:
+#     weight (of Relationship Type as in table below)
+#     relationshipId: Relationship.id
+#     name: Relationship.name
+#     documentation: Relationship.documentation
+#     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
+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?) })
+    end
+
+    class PropertiesHash
+      attr_reader :properties
+
+      def initialize(properties)
+        @properties = properties
+      end
+
+      def to_h
+        properties.each_with_object({}) do |property, hash|
+          hash[property.key.to_s] = property.value.to_s
+        end
+      end
+    end
+
+    class JsonlNode
+      attr_reader :element
+
+      def initialize(element)
+        @element = element
+      end
+
+      # n:BusinessActor
+      # `layer`: "Business",
+      # `name`: Felix,
+      # `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
+          }
+        )
+      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)
+        @relationship = relationship
+      end
+
+      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
+          }
+        )
+      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
+      attr_reader :output_io
+
+      def initialize(output_io)
+        @output_io = output_io
+      end
+
+      def to_jsonl(model)
+        write_nodes(model.elements)
+        write_relationships(model.relationships)
+      end
+
+      def write_nodes(elements)
+        elements.each { |element| write(JsonlNode.new(element).to_jsonl) }
+      end
+
+      def write_relationships(relationships)
+        relationships.each { |relationship| write(JsonlEdge.new(relationship).to_jsonl) }
+      end
+
+      private
+
+      def write(str)
+        @output_io.puts(str)
+      end
+    end
+  end
+end

data/lib/archimate/export/n_quads.rb

@@ -94,17 +94,18 @@ module Archimate
 
       def documentation(el)
         docs = []
-        el.documentation.each do |doc|
-          docs << make_quad(el.id, "documentation", doc.text)
+        return docs unless el.documentation && !el.documentation.empty?
+        el.documentation.langs.each do |lang|
+          docs << make_quad(el.id, "documentation", el.documentation.by_lang(lang))
         end
         docs
       end
 
       def relationships(el)
         [
-          make_quad(el.source, predicate(el.type), el.target),
-          make_quad(el.id, "sources", el.source),
-          make_quad(el.id, "target", el.target)
+          make_quad(el.source.id, predicate(el.type), el.target.id),
+          make_quad(el.id, "sources", el.source.id),
+          make_quad(el.id, "target", el.target.id)
         ]
       end
 
@@ -112,6 +113,7 @@ module Archimate
         "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),
         "AssignmentRelationship" => %w(assigned_to assigned_from),
         "AggregationRelationship" => %w(aggregates aggregated_by),
@@ -120,6 +122,7 @@ module Archimate
         "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
 

data/lib/archimate/file_format.rb

@@ -18,12 +18,11 @@ module Archimate
     def self.parse(str)
       doc = Nokogiri::XML(str)
       case doc.namespaces["xmlns"]
-      when "http://www.opengroup.org/xsd/archimate/3.0/"
-        FileFormats::ModelExchangeFileReader30.new.parse(doc)
-      when "http://www.opengroup.org/xsd/archimate"
-        FileFormats::ModelExchangeFileReader21.new.parse(doc)
+      when "http://www.opengroup.org/xsd/archimate/3.0/",
+           "http://www.opengroup.org/xsd/archimate"
+        FileFormats::ModelExchangeFileReader.new(str).parse
       else
-        FileFormats::ArchiFileReader.new.parse(doc)
+        FileFormats::ArchiFileReader.new(str).parse
       end
     end
   end

data/lib/archimate/file_formats/archi_file_reader.rb

@@ -4,248 +4,15 @@ require "nokogiri"
 module Archimate
   module FileFormats
     class ArchiFileReader
-      def initialize
-        @progress = nil
-        @random ||= Random.new
+      def initialize(doc)
+        @string_or_io = doc
       end
 
-      def parse(doc)
-        @size = 0
-        doc.traverse { |_n| @size += 1 }
-        @progress = ProgressIndicator.new(total: @size, title: "Parsing")
-        @property_defs = {}
-        tick
-        diagrams = parse_diagrams(doc.root)
-        DataModel::Model.new(
-          id: doc.root["id"],
-          name: doc.root["name"],
-          documentation: parse_documentation(doc.root, "purpose"),
-          properties: parse_properties(doc.root),
-          elements: parse_elements(doc.root),
-          organizations: parse_organizations(doc.root),
-          relationships: parse_relationships(doc.root),
-          diagrams: diagrams,
-          viewpoints: [],
-          property_definitions: @property_defs.values,
-          namespaces: {},
-          schema_locations: []
-        )
-      ensure
-        @progress&.finish
-        @progress = nil
-      end
-
-      def parse_documentation(node, element_name = "documentation")
-        node.css(">#{element_name}").each_with_object([]) do |i, a|
-          tick
-          a << DataModel::Documentation.new(text: i.content)
-        end
-      end
-
-      def parse_properties(node)
-        node.css(">property").each_with_object([]) do |i, a|
-          tick
-          key = i["key"]
-          next unless key
-          if @property_defs.key?(key)
-            prop_def = @property_defs[key]
-          else
-            @property_defs[key] = prop_def = DataModel::PropertyDefinition.new(
-              id: DataModel::PropertyDefinition.identifier_for_key(key),
-              name: key,
-              documentation: [],
-              value_type: "string"
-            )
-          end
-          a << DataModel::Property.new(
-            values: [
-              DataModel::LangString.new(text: i["value"] || "en")
-            ],
-            property_definition: prop_def
-          )
-        end
-      end
-
-      def parse_elements(model)
-        model.css(ArchiFileFormat::FOLDER_XPATHS.join(",")).css('element[id]').map do |i|
-          tick
-          DataModel::Element.new(
-            id: i["id"],
-            name: i["name"],
-            organization_id: i.parent["id"],
-            type: i["xsi:type"].sub("archimate:", ""),
-            documentation: parse_documentation(i),
-            properties: parse_properties(i)
-          )
-        end
-      end
-
-      def parse_organizations(node)
-        node.css("> folder").each_with_object([]) do |i, a|
-          tick
-          a << DataModel::Organization.new(
-            id: i.attr("id"),
-            name: i.attr("name"),
-            type: i.attr("type"),
-            documentation: parse_documentation(i),
-            properties: parse_properties(i),
-            items: child_element_ids(i),
-            organizations: parse_organizations(i)
-          )
-        end
-      end
-
-      def child_element_ids(node)
-        node.css(">element[id]").each_with_object([]) do |i, a|
-          tick
-          a << i.attr("id")
-        end
-      end
-
-      def parse_relationships(model)
-        model.css(ArchiFileFormat::RELATION_XPATHS.join(",")).css("element").map do |i|
-          tick
-          DataModel::Relationship.new(
-            id: i["id"],
-            type: i.attr("xsi:type").sub("archimate:", ""),
-            source: i.attr("source"),
-            target: i.attr("target"),
-            name: i["name"],
-            access_type: parse_access_type(i["accessType"]),
-            documentation: parse_documentation(i),
-            properties: parse_properties(i)
-          )
-        end
-      end
-
-      def parse_access_type(val)
-        return nil unless val && val.size > 0
-        i = val.to_i
-        return nil unless i >= 0 && i < DataModel::AccessType.size
-        DataModel::AccessType[i]
-      end
-
-      def parse_diagrams(model)
-        model.css(ArchiFileFormat::DIAGRAM_XPATHS.join(",")).css(
-          'element[xsi|type="archimate:ArchimateDiagramModel"]',
-          'element[xsi|type="archimate:SketchModel"]'
-        ).map do |i|
-          tick
-          viewpoint_idx = i["viewpoint"]
-          viewpoint_idx = viewpoint_idx.to_i unless viewpoint_idx.nil?
-          viewpoint_type = viewpoint_idx.nil? ? nil : ArchiFileFormat::VIEWPOINTS[viewpoint_idx]
-          DataModel::Diagram.new(
-            id: i["id"],
-            name: i["name"],
-            viewpoint_type: viewpoint_type,
-            viewpoint: nil,
-            documentation: parse_documentation(i),
-            properties: parse_properties(i),
-            nodes: parse_nodes(i),
-            connections: parse_all_connections(i),
-            connection_router_type: i["connectionRouterType"],
-            type: i.attr("xsi:type"),
-            background: i.attr("background"),
-            organization_id: nil
-          )
-        end
-      end
-
-      def parse_nodes(node)
-        node.css("> child").each_with_object([]) do |child_node, a|
-          tick
-          a << DataModel::ViewNode.new(
-            id: child_node.attr("id"),
-            type: child_node.attr("xsi:type"),
-            model: child_node.attr("model"),
-            name: child_node.attr("name"),
-            target_connections: parse_target_connections(child_node.attr("targetConnections")),
-            archimate_element: child_node.attr("archimateElement"),
-            bounds: parse_bounds(child_node),
-            nodes: parse_nodes(child_node),
-            connections: parse_connections(child_node),
-            documentation: parse_documentation(child_node),
-            properties: parse_properties(child_node),
-            style: parse_style(child_node),
-            content: child_node.at_css("> content")&.text,
-            child_type: child_node.attr("type")
-          )
-        end
-      end
-
-      def parse_target_connections(str)
-        return [] if str.nil?
-        str.split(" ")
-      end
-
-      def parse_style(style)
-        tick
-        DataModel::Style.new(
-          text_alignment: style["textAlignment"],
-          fill_color: DataModel::Color.rgba(style["fillColor"]),
-          line_color: DataModel::Color.rgba(style["lineColor"]),
-          font_color: DataModel::Color.rgba(style["fontColor"]),
-          font: DataModel::Font.archi_font_string(style["font"]),
-          line_width: style["lineWidth"],
-          text_position: style["textPosition"]
-        )
-      end
-
-      def parse_bounds(node)
-        bounds = node.at_css("> bounds")
-        tick
-        unless bounds.nil?
-          DataModel::Bounds.new(
-            x: bounds.attr("x"),
-            y: bounds.attr("y"),
-            width: bounds.attr("width"),
-            height: bounds.attr("height")
-          )
-        end
-      end
-
-      def parse_all_connections(node)
-        node.css("sourceConnection").each_with_object([]) do |i, a|
-          tick
-          a << parse_connection(i)
-        end
-      end
-
-      def parse_connections(node)
-        node.css("> sourceConnection").each_with_object([]) { |i, a| a << parse_connection(i) }
-      end
-
-      def parse_connection(i)
-        DataModel::Connection.new(
-          id: i["id"],
-          type: i.attr("xsi:type"),
-          source: i["source"],
-          target: i["target"],
-          relationship: i["relationship"] || i["archimateRelationship"],
-          name: i["name"],
-          style: parse_style(i),
-          bendpoints: parse_bendpoints(i),
-          documentation: parse_documentation(i),
-          properties: parse_properties(i)
-          )
-      end
-
-      # startX = location.x - source_attachment.x
-      # startY = location.y - source_attachment.y
-      # endX = location.x - target_attachment.x
-      # endY = location.y - source_attachment.y
-      def parse_bendpoints(node)
-        node.css("bendpoint").each_with_object([]) do |i, a|
-          tick
-          a << DataModel::Location.new(
-            x: i.attr("startX") || 0, y: i.attr("startY") || 0,
-            end_x: i.attr("endX"), end_y: i.attr("endY")
-          )
-        end
-      end
-
-      def tick
-        @progress&.increment
+      def parse()
+        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
       end
     end
   end