archimate 1.1.0

data/lib/archimate/export/graph_ml.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+# This module takes an ArchiMate model and builds GraphML representation of it.
+require "set"
+
+module Archimate
+  module Export
+    class GraphML
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def to_graphml
+        @prop_id = 1
+        @edge_id = 1
+        @layers = Hash.new do |hash, key|
+          hash[key] = [] unless hash.key?(key)
+          hash[key]
+        end
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.graphml(
+            "xmlns" => "http://graphml.graphdrawing.org/xmlns",
+            "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+            "xsi:schemaLocation" => "http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd"
+          ) do
+            xml.key(id: "element-type", for: "node", "attr.name" => "type", "attr.type" => "string")
+            xml.key(id: "relationship-type", for: "edge", "attr.name" => "type", "attr.type" => "string")
+            xml.key(id: "name", for: "all", "attr.name" => "name", "attr.type" => "string")
+            xml.key(id: "documentation", for: "all", "attr.name" => "documentation", "attr.type" => "string")
+            xml.key(id: "property-value", for: "all", "attr.name" => "value", "attr.type" => "string")
+            xml.graph(
+              id: model.id,
+              edgedefault: "directed"
+            ) do
+              graph_attrs(xml, model)
+              nodes(xml, model.elements)
+              layers(xml, @layers)
+              relationships(xml, model.relationships)
+            end
+          end
+        end
+        builder.to_xml
+      end
+
+      def next_prop_id
+        @prop_id += 1
+        "property-#{@prop_id}"
+      end
+
+      def next_edge_id
+        @edge_id += 1
+        "edge-#{@edge_id}"
+      end
+
+      def graph_attrs(xml, model)
+        name(xml, model.name)
+        docs(xml, model.documentation)
+        properties(xml, model.id, model.properties)
+      end
+
+      def name(xml, name_str)
+        data(xml, "name", name_str) unless name_str.nil?
+      end
+
+      def data_type(xml, key, type)
+        data(xml, key, type.nil? ? nil : type.sub("archimate:", ""))
+      end
+
+      def data(xml, key, value)
+        xml.data(key: key) { xml.text(value) unless value.nil? }
+      end
+
+      def properties(xml, source_id, properties)
+        properties.each do |property|
+          # TODO: if we want to be slick here, keep a set of property values and point to that instead
+          prop_id = next_prop_id
+          node(xml, prop_id, property.key, "Property", "property-value" => property.value)
+          edge(xml, next_edge_id, source_id, prop_id, "HasProperty", property.key)
+        end
+      end
+
+      def docs(xml, docs)
+        docs.each do |doc|
+          data(xml, "documentation", doc)
+        end
+      end
+
+      def nodes(xml, elements)
+        elements.each do |element|
+          node(xml, element.id, element.name, element.type, element.documentation, element.properties)
+
+          @layers[element.layer] << element.id
+        end
+      end
+
+      def layers(xml, layers)
+        layers.each_with_index do |layer, i|
+          node(xml, "layer-#{i}", layer, "Layer")
+        end
+      end
+
+      def relationships(xml, relationships)
+        relationships.each do |r|
+          edge(xml, r.id, r.source, r.target, r.type, r.name, r.documentation, r.properties)
+        end
+      end
+
+      def node(xml, id, name, type, docs = [], properties = [], other_data = {})
+        xml.node(id: id, label: name, labels: "#{type}:#{name}") do
+          data_type(xml, "element-type", type)
+          name(xml, name)
+          docs(xml, docs)
+          other_data.each do |k, v|
+            xml.data(key: k) { xml.text(v) }
+          end
+        end
+        properties(xml, id, properties)
+      end
+
+      def edge(xml, id, source, target, type, name = nil, docs = [], properties = [])
+        xml.edge(id: id, source: source, target: target, label: type) do
+          data_type(xml, "relationship-type", type)
+          name(xml, name)
+          docs(xml, docs)
+        end
+        properties(xml, id, properties)
+      end
+    end
+  end
+end

data/lib/archimate/export/n_quads.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# This module takes an ArchiMate model and builds a set of relationship quads
+# for use in RDF or graph databases.
+#
+# The approach is to as follows:
+#
+# For each element in the model (not under the "Views" organization)
+#   (Which looks like this:
+#     <element xsi:type="archimate:BusinessProcess" id="0f6c2750"
+#       name="Start Provisioning"/>)
+#
+#   <0f6c2750> <named> <Start Provisioning>
+#   <0f6c2750> <typed> <archimate:BusinessProcess>
+#   <0f6c2750> <in_layer> <business>
+#
+#   and for relationship
+#   <element xsi:type="archimate:AssignmentRelationship" id="a7cc2df6"
+#     source="1c524402" target="0f6c2750"/>
+#
+#   a couple of options:
+#
+#   option 1:
+#
+#   <0f6c2750> <targeted_by> <a7cc2df6>
+#   <1c524402> <sourced_by> <a7cc2df6>
+#   <a7cc2df6> <typed> <archimate:AssignmentRelationship>
+#   <a7cc2df6> <sources> <1c524402>
+#   <a7cc2df6> <targets> <0f6c2750>
+#
+#   option 2:
+#
+#   <1c524402> <assigned_to> <0f6c2750>
+#
+#   option 3: combine both so you get easier queries but retain the ability to
+#             look at properties on the relationship itsef.
+#
+# Future ideas:
+#
+# Take views and add to the graph so that we can do
+# queries based on things that should possibly be added to a diagram or make
+# suggestions on things that should be graphed.
+#
+# Add in quads for properties
+module Archimate
+  module Export
+    Quad = Struct.new(:subject, :predicate, :object) do
+      def fmt_obj
+        if object =~ /\s/
+          "\"#{object.gsub('"', '\\"').gsub(/[\n\r]/, '\\n')}\""
+        else
+          "<#{object}>"
+        end
+      end
+
+      def fmt_subject
+        subject.gsub(/\s/, '_').to_s
+      end
+
+      def to_s
+        "<#{fmt_subject}> <#{predicate}> #{fmt_obj} ."
+      end
+    end
+
+    class NQuads
+      def initialize(model)
+        @model = model
+      end
+
+      def to_nq
+        quads = @model.elements.map do |el|
+          [named(el),
+           typed(el),
+           in_layer(el),
+           documentation(el)]
+        end
+        quads << @model.relationships.map { |rel| relationships(rel) }
+        quads.flatten.compact.uniq.join("\n")
+      end
+
+      def named(el)
+        el.name.nil? ? nil : make_quad(el.id, "named", el.name)
+      end
+
+      def typed(el)
+        make_quad(el.id, "typed", el.type)
+      end
+
+      def in_layer(el)
+        layer = el.layer
+        return nil if layer.nil?
+        make_quad(el.id, "in_layer", layer)
+      end
+
+      def documentation(el)
+        docs = []
+        el.documentation.each do |doc|
+          docs << make_quad(el.id, "documentation", doc.text)
+        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)
+        ]
+      end
+
+      PREDICATES = {
+        "AssociationRelationship" => %w(associated_with associated_with),
+        "AccessRelationship" => %w(accesses accessed_by),
+        "UsedByRelationship" => %w(used_by uses),
+        "RealisationRelationship" => %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),
+        "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(
+            ArgumentError,
+            "Invalid: subject, predicate, or object [#{[subject, predicate, object].map(&:inspect).join(', ')}]"
+          )
+        end
+        Quad.new(subject, predicate, object)
+      end
+    end
+  end
+end

data/lib/archimate/file_format.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  # This File Format class supports reading and parsing from a number of ArchiMate formats
+  class FileFormat
+    def self.read(filename)
+      case File.extname(filename)
+      when ".marshal"
+        File.open(filename, "rb") do |marshal_file|
+          Marshal.load(marshal_file)
+        end
+      else
+        parse(File.read(filename))
+      end
+    end
+
+    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)
+      else
+        FileFormats::ArchiFileReader.new.parse(doc)
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/archi_file_format.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+module Archimate
+  module FileFormats
+    module ArchiFileFormat
+      # strategy_folder_xpath = "/archimate:model/folder[@type='strategy']"
+      application_folder_xpath = "/archimate:model/folder[@type='application']"
+      business_folder_xpath = "/archimate:model/folder[@type='business']"
+      technology_folder_xpath = "/archimate:model/folder[@type='technology']"
+      # physical_folder_xpath = "/archimate:model/folder[@type='physical']"
+      motivation_folder_xpath = "/archimate:model/folder[@type='motivation']"
+      implementation_migration_folder_xpath = "/archimate:model/folder[@type='implementation_migration']"
+      connectors_folder_xpath = "/archimate:model/folder[@type='connectors']"
+      relations_folder_xpath = "/archimate:model/folder[@type='relations']"
+      diagrams_folder_xpath = "/archimate:model/folder[@type='diagrams']"
+
+      ELEMENT_TYPE_TO_PARENT_XPATH = {
+        "archimate:BusinessActor" => business_folder_xpath,
+        "archimate:BusinessCollaboration" => business_folder_xpath,
+        "archimate:BusinessEvent" => business_folder_xpath,
+        "archimate:BusinessFunction" => business_folder_xpath,
+        "archimate:BusinessInteraction" => business_folder_xpath,
+        "archimate:BusinessInterface" => business_folder_xpath,
+        "archimate:BusinessObject" => business_folder_xpath,
+        "archimate:BusinessProcess" => business_folder_xpath,
+        "archimate:BusinessRole" => business_folder_xpath,
+        "archimate:BusinessService" => business_folder_xpath,
+        "archimate:Contract" => business_folder_xpath,
+        "archimate:Location" => business_folder_xpath,
+        "archimate:Meaning" => business_folder_xpath,
+        "archimate:Value" => business_folder_xpath,
+        "archimate:Product" => business_folder_xpath,
+        "archimate:Representation" => business_folder_xpath,
+
+        "archimate:ApplicationCollaboration" => application_folder_xpath,
+        "archimate:ApplicationComponent" => application_folder_xpath,
+        "archimate:ApplicationFunction" => application_folder_xpath,
+        "archimate:ApplicationInteraction" => application_folder_xpath,
+        "archimate:ApplicationInterface" => application_folder_xpath,
+        "archimate:ApplicationService" => application_folder_xpath,
+        "archimate:DataObject" => application_folder_xpath,
+
+        "archimate:Artifact" => technology_folder_xpath,
+        "archimate:CommunicationPath" => technology_folder_xpath,
+        "archimate:Device" => technology_folder_xpath,
+        "archimate:InfrastructureFunction" => technology_folder_xpath,
+        "archimate:InfrastructureInterface" => technology_folder_xpath,
+        "archimate:InfrastructureService" => technology_folder_xpath,
+        "archimate:Network" => technology_folder_xpath,
+        "archimate:Node" => technology_folder_xpath,
+        "archimate:SystemSoftware" => technology_folder_xpath,
+
+        "archimate:Assessment" => motivation_folder_xpath,
+        "archimate:Constraint" => motivation_folder_xpath,
+        "archimate:Driver" => motivation_folder_xpath,
+        "archimate:Goal" => motivation_folder_xpath,
+        "archimate:Principle" => motivation_folder_xpath,
+        "archimate:Requirement" => motivation_folder_xpath,
+        "archimate:Stakeholder" => motivation_folder_xpath,
+
+        "archimate:Deliverable" => implementation_migration_folder_xpath,
+        "archimate:Gap" => implementation_migration_folder_xpath,
+        "archimate:Plateau" => implementation_migration_folder_xpath,
+        "archimate:WorkPackage" => implementation_migration_folder_xpath,
+
+        "archimate:AndJunction" => connectors_folder_xpath,
+        "archimate:Junction" => connectors_folder_xpath,
+        "archimate:OrJunction" => connectors_folder_xpath,
+
+        "archimate:AccessRelationship" => relations_folder_xpath,
+        "archimate:AggregationRelationship" => relations_folder_xpath,
+        "archimate:AssignmentRelationship" => relations_folder_xpath,
+        "archimate:AssociationRelationship" => relations_folder_xpath,
+        "archimate:CompositionRelationship" => relations_folder_xpath,
+        "archimate:FlowRelationship" => relations_folder_xpath,
+        "archimate:InfluenceRelationship" => relations_folder_xpath,
+        "archimate:RealisationRelationship" => relations_folder_xpath,
+        "archimate:SpecialisationRelationship" => relations_folder_xpath,
+        "archimate:TriggeringRelationship" => relations_folder_xpath,
+        "archimate:UsedByRelationship" => relations_folder_xpath,
+
+        "archimate:SketchModel" => diagrams_folder_xpath,
+        "archimate:ArchimateDiagramModel" => diagrams_folder_xpath
+      }.freeze
+
+      FOLDER_XPATHS = [
+        "folder[type=\"strategy\"]",
+        "folder[type=\"business\"]",
+        "folder[type=\"application\"]",
+        "folder[type=\"technology\"]",
+        "folder[type=\"physical\"]",
+        "folder[type=\"motivation\"]",
+        "folder[type=\"implementation_migration\"]",
+        "folder[type=\"other\"]",
+        "folder[type=\"connectors\"]"
+      ].freeze
+
+      ELEMENT_FOLDER_TYPES = %w(
+        strategy
+        business
+        application
+        technology
+        physical
+        motivation
+        implementation_migration
+        connectors
+      ).freeze
+
+      RELATION_XPATHS = [
+        "folder[type=\"relations\"]",
+        "folder[type=\"derived\"]"
+      ].freeze
+
+      RELATION_FOLDER_TYPES = %w(relations derived).freeze
+
+      DIAGRAM_XPATHS = [
+        "folder[type=\"diagrams\"]"
+      ].freeze
+
+      DIAGRAM_FOLDER_TYPES = %w(diagrams).freeze
+
+      VIEWPOINTS = [
+        "",
+        "Actor Co-operation",
+        "Application Behavior",
+        "Application Co-operation",
+        "Application Structure",
+        "Application Usage",
+        "Business Function",
+        "Business Process Co-operation",
+        "Business Process",
+        "Product",
+        "Implementation and Deployment",
+        "Information Structure",
+        "Infrastructure Usage",
+        "Infrastructure",
+        "Layered",
+        "Organization",
+        "Service Realization",
+        "Stakeholder",
+        "Goal Realization",
+        "Goal Contribution",
+        "Principles",
+        "Requirements Realization",
+        "Motivation",
+        "Project",
+        "Migration",
+        "Implementation and Migration"
+      ].freeze
+    end
+  end
+end