archimate 1.2.1 → 2.0.0

data/lib/archimate/file_formats/model_exchange_file/xml_lang_string.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Archimate
-  module FileFormats
-    module ModelExchangeFile
-      class XmlLangString
-        def self.parse(node)
-          return nil unless node
-          DataModel::LangString.new(text: node.content, lang: node["xml:lang"])
-        end
-
-        def initialize(lang_str, tag_name)
-          @tag_name = tag_name
-          @lang_strs = Array(lang_str)
-        end
-
-        def serialize(xml)
-          return if @lang_strs.empty?
-
-          @lang_strs.each do |lang_str|
-            attrs = lang_str.lang && !lang_str.lang.empty? ? {"xml:lang" => lang_str.lang} : {}
-            xml.send(@tag_name, attrs) { xml.text text_proc(lang_str) }
-          end
-        end
-
-        # Processes text for text elements
-        private
-
-        def text_proc(str)
-          str.strip.tr("\r", "\n")
-        end
-      end
-    end
-  end
-end

data/lib/archimate/file_formats/model_exchange_file/xml_metadata.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Archimate
-  module FileFormats
-    module ModelExchangeFile
-      class XmlMetadata
-        def self.parse(metadata)
-          return nil unless metadata
-          DataModel::Metadata.new(schema_infos: parse_schema_infos(metadata))
-        end
-
-        def initialize(metadata)
-          @metadata = metadata
-        end
-
-        def serialize(xml)
-          return unless @metadata && @metadata.schema_infos.size > 0
-          xml.metadata do
-            if @metadata.schema_infos.size == 1
-              serialize_schema_info_body(xml, @metadata.schema_infos.first)
-            else
-              @metadata.schema_infos.each do |schema_info|
-                serialize_schema_info(xml, schema_info)
-              end
-            end
-          end
-        end
-
-        private
-
-        def serialize_schema_info(xml, schema_info)
-          xml.schemaInfo do
-            serialize_schema_info_body(xml, schema_info)
-          end
-        end
-
-        def serialize_schema_info_body(xml, schema_info)
-          xml.schema { xml.text (schema_info.schema) } if schema_info.schema
-          xml.schemaversion { xml.text (schema_info.schemaversion) } if schema_info.schemaversion
-          schema_info.elements.each do |el|
-            serialize_any_element(xml, el)
-          end
-        end
-
-        def serialize_any_element(xml, el)
-          if el.prefix && !el.prefix.empty?
-            xml_prefix = xml[el.prefix]
-          else
-            xml_prefix = xml
-          end
-          xml_prefix.send(el.element.to_sym, serialize_any_attributes(el.attributes)) do
-            xml.text(el.content) if el.content&.size > 0
-            el.children.each { |child| serialize_any_element(xml, child) }
-          end
-        end
-
-        def serialize_any_attributes(attrs)
-          attrs.each_with_object({}) do |attr, hash|
-            key = attr.prefix&.size > 0 ? [attr.prefix, attr.attribute].join(":") : attr.attribute
-            hash[key] = attr.value
-          end
-        end
-
-        def self.parse_schema_infos(metadata)
-          schema_infos = metadata.css(">schemaInfo")
-          if schema_infos.size > 0
-            schema_infos.map { |si| parse_schema_info(si) }
-          else
-            [parse_schema_info(metadata)].compact
-          end
-        end
-
-        def self.parse_schema_info(node)
-          els = node.element_children
-          return nil if els.empty?
-          schema_info_attrs = {
-            schema: nil,
-            schemaversion: nil,
-            elements: []
-          }
-          els.each do |el|
-            case(el.name)
-            when "schema"
-              schema_info_attrs[:schema] = el.text
-            when "schemaversion"
-              schema_info_attrs[:schemaversion] = el.text
-            else
-              schema_info_attrs[:elements] << parse_any_element(el)
-            end
-          end
-          DataModel::SchemaInfo.new(schema_info_attrs)
-        end
-
-        def self.parse_any_element(node)
-          return nil unless node && node.is_a?(Nokogiri::XML::Element)
-          DataModel::AnyElement.new(
-            element: node.name,
-            prefix: node.namespace&.prefix,
-            attributes: node.attributes.map { |attr| parse_any_attribute(attr) },
-            content: node.text,
-            children: node.element_children.map { |child| parse_any_element(node) }
-          )
-        end
-
-        def self.parse_any_attribute(attr)
-          DataModel::AnyAttribute.new(
-            attribute: attr.name,
-            prefix: attr.namepace&.prefix,
-            value: attr.text
-          )
-        end
-      end
-    end
-  end
-end

data/lib/archimate/file_formats/model_exchange_file/xml_property_definitions.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Archimate
-  module FileFormats
-    module ModelExchangeFile
-      # Property Definitions as defined in ArchiMate 3.0 Model Exchange XSDs
-      class XmlPropertyDefinitions
-        def initialize(property_defs)
-          @property_definitions = property_defs
-        end
-
-        def serialize(xml)
-          return if @property_definitions.empty?
-          xml.propertyDefinitions do
-            @property_definitions.each do |property_def|
-              xml.propertyDefinition(
-                "identifier" => property_def.id,
-                "type" => property_def.value_type
-              ) do
-                ModelExchangeFile::XmlLangString.new(property_def.name, :name).serialize(xml)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/archimate/file_formats/model_exchange_file_reader_21.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-require "nokogiri"
-
-module Archimate
-  module FileFormats
-    # This class implements a file reader for ArchiMate 2.1 Model Exchange Format
-    class ModelExchangeFileReader21 < ModelExchangeFileReader
-      def parse_archimate_version(root)
-        case root.namespace.href
-        when "http://www.opengroup.org/xsd/archimate"
-          :archimate_2_1
-        else
-          raise "Unexpected namespace: #{root.namespace.href}"
-        end
-      end
-
-      def organizations_root_selector
-        ">organization>item"
-      end
-
-      def property_defs_selector
-        ">propertydefs>propertydef"
-      end
-
-      def property_def_attr_name
-        "identifierref"
-      end
-
-      def property_def_name(node)
-        node["name"]
-      end
-
-      def parse_element_name(el)
-        ModelExchangeFile::XmlLangString.parse(el.at_css(">label"))
-      end
-
-      def identifier_ref_name
-        "identifierref"
-      end
-
-      def diagrams_path
-        ">views>view"
-      end
-
-      def view_node_element_ref
-        "elementref"
-      end
-
-      def view_node_type_attr
-        "type"
-      end
-
-      def connection_relationship_ref
-        "relationshipref"
-      end
-
-      def style_to_int(str)
-        case str
-        when nil
-          0
-        when "italic"
-          1
-        when "bold"
-          2
-        when "bold|italic"
-          3
-        else
-          raise "Broken for value: #{str}"
-        end
-      end
-    end
-  end
-end

data/lib/archimate/file_formats/model_exchange_file_reader_30.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-require "nokogiri"
-
-module Archimate
-  module FileFormats
-    class ModelExchangeFileReader30 < ModelExchangeFileReader
-      def parse_archimate_version(root)
-        case root.namespace.href
-        when "http://www.opengroup.org/xsd/archimate/3.0/"
-          :archimate_3_0
-        else
-          raise "Unexpected namespace version: #{root.namespace.href}"
-        end
-      end
-
-      def organizations_root_selector
-        ">organizations"
-      end
-
-      def property_defs_selector
-          ">propertyDefinitions>propertyDefinition"
-      end
-
-      def property_def_attr_name
-        "propertyDefinitionRef"
-      end
-
-      def property_def_name(node)
-        ModelExchangeFile::XmlLangString.parse(node.at_css("name"))
-      end
-
-      def parse_element_name(el)
-        ModelExchangeFile::XmlLangString.parse(el.at_css(">name"))
-      end
-
-      def identifier_ref_name
-        "identifierRef"
-      end
-
-      def diagrams_path
-        ">views>diagrams>view"
-      end
-
-      def view_node_element_ref
-        "elementRef"
-      end
-
-      def view_node_type_attr
-        "xsi:type"
-      end
-
-      def connection_relationship_ref
-        "relationshipRef"
-      end
-
-      def style_to_int(str)
-        case str
-        when nil
-          0
-        when "italic"
-          1
-        when "bold"
-          2
-        when "bold italic"
-          3
-        else
-          raise "Broken for value: #{str}"
-        end
-      end
-
-      # <xs:simpleType name="ViewpointPurposeEnum">
-      #     <xs:restriction base="xs:NMTOKEN">
-      #         <xs:enumeration value="Designing" />
-      #         <xs:enumeration value="Deciding" />
-      #         <xs:enumeration value="Informing" />
-      #     </xs:restriction>
-      # </xs:simpleType>
-
-      # <xs:simpleType name="ViewpointPurposeType">
-      #     <xs:list itemType="ViewpointPurposeEnum" />
-      # </xs:simpleType>
-
-      # <xs:simpleType name="ViewpointContentEnum">
-      #     <xs:restriction base="xs:NMTOKEN">
-      #         <xs:enumeration value="Details" />
-      #         <xs:enumeration value="Coherence" />
-      #         <xs:enumeration value="Overview" />
-      #     </xs:restriction>
-      # </xs:simpleType>
-
-      # <xs:simpleType name="ViewpointContentType">
-      #     <xs:list itemType="ViewpointContentEnum" />
-      # </xs:simpleType>
-
-      # <xs:complexType name="ViewpointType">
-      #     <xs:complexContent>
-      #         <xs:extension base="NamedReferenceableType">
-      #             <xs:sequence>
-      #                 <xs:group ref="PropertiesGroup" />
-      #                 <xs:element name="concern" type="ConcernType" minOccurs="0" maxOccurs="unbounded" />
-      #                 <xs:element name="viewpointPurpose" type="ViewpointPurposeType" minOccurs="0" maxOccurs="1" />
-      #                 <xs:element name="viewpointContent" type="ViewpointContentType" minOccurs="0" maxOccurs="1" />
-      #                 <xs:element name="allowedElementType" type="AllowedElementTypeType" minOccurs="0" maxOccurs="unbounded" />
-      #                 <xs:element name="allowedRelationshipType" type="AllowedRelationshipTypeType" minOccurs="0" maxOccurs="unbounded" />
-      #                 <xs:element name="modelingNote" type="ModelingNoteType" minOccurs="0" maxOccurs="unbounded" />
-      #             </xs:sequence>
-      #         </xs:extension>
-      #     </xs:complexContent>
-      # </xs:complexType>
-      def parse_viewpoints(model)
-        []
-        # model.css("views > viewpoints").map do |i|
-          # attribute :concern, ConcernList
-          # attribute :viewpointPurpose, ViewpointPurpose.optional
-          # attribute :viewpointContent, ViewpointContent.optional
-          # attribute :allowedElementTypes, AllowedElementTypes
-          # attribute :allowedRelationshipTypes, AllowedRelationshipTypes
-          # attribute :modelingNotes, Strict::Array.member(ModelingNote).default([])
-          # DataModel::Viewpoint.new(
-            #     id: identifier_to_id(i["identifier"]),
-            #     name: parse_element_name(i),
-            #     documentation: parse_documentation(i),
-            #     properties: parse_properties(i),
-            #     nodes: nodes,
-            #     connections: connections,
-            #     connection_router_type: i["connectionRouterType"],
-            #     type: i.attr("xsi:type"),
-            #     background: i.attr("background")
-          # )
-        # end
-      end
-    end
-  end
-end

data/lib/archimate/file_formats/model_exchange_file_writer.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-require "nokogiri"
-
-module Archimate
-  module FileFormats
-    class ModelExchangeFileWriter < Writer
-      attr_reader :model
-
-      def initialize(model)
-        super
-      end
-
-      def write(output_io)
-        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
-          serialize_model(xml)
-        end
-        output_io.write(builder.to_xml)
-      end
-
-      def serialize_elements(xml)
-        xml.elements { serialize(xml, model.elements) } unless model.elements.empty?
-      end
-
-      def serialize_element(xml, element)
-        return if element.type == "SketchModel" # TODO: print a warning that data is lost
-        xml.element(identifier: identifier(element['id']),
-                    "xsi:type" => meff_type(element.type)) do
-          elementbase(xml, element)
-        end
-      end
-
-      def elementbase(xml, element)
-        serialize_label(xml, element.name)
-        serialize(xml, element.documentation)
-        serialize_properties(xml, element)
-      end
-
-      def serialize_label(xml, str)
-        return if str.nil? || str.strip.empty?
-        name_attrs = str.lang && !str.lang.empty? ? {"xml:lang" => str.lang} : {}
-        xml.label(name_attrs) { xml.text text_proc(str) }
-      end
-
-      def serialize_relationships(xml)
-        return if model.relationships.empty?
-        xml.relationships { serialize(xml, model.relationships) }
-      end
-
-      def relationship_attributes(relationship)
-        {
-          identifier: identifier(relationship.id),
-          source: identifier(relationship.source),
-          target: identifier(relationship.target),
-          "xsi:type" => meff_type(relationship.type)
-        }
-      end
-
-      def serialize_relationship(xml, relationship)
-        xml.relationship(
-          relationship_attributes(relationship)
-        ) do
-          elementbase(xml, relationship)
-        end
-      end
-
-      def serialize_organization_root(xml, organizations)
-        return unless organizations && organizations.size > 0
-        xml.organization do
-          serialize(xml, organizations)
-        end
-      end
-
-      def serialize_organization(xml, organization)
-        return if organization.items.empty? && organization.documentation.empty? && organization.organizations.empty?
-        item_attrs = organization.id.nil? || organization.id.empty? ? {} : {identifier: organization.id}
-        xml.item(item_attrs) do
-          serialize_organization_body(xml, organization)
-        end
-      end
-
-      def serialize_organization_body(xml, organization)
-        return if organization.items.empty? && organization.documentation.empty? && organization.organizations.empty?
-        str = organization.name
-        label_attrs = organization.name&.lang && !organization.name.lang.empty? ? {"xml:lang" => organization.name.lang} : {}
-        xml.label(label_attrs) { xml.text text_proc(str) } unless str.nil? || str.strip.empty?
-        serialize(xml, organization.documentation)
-        serialize(xml, organization.organizations)
-        organization.items.each { |i| serialize_item(xml, i) }
-      end
-
-      def serialize_properties(xml, element)
-        return if element.properties.empty?
-        xml.properties do
-          serialize(xml, element.properties)
-        end
-      end
-
-      def serialize_style(xml, style)
-        return unless style
-        xml.style(
-          remove_nil_values(
-            lineWidth: style.line_width
-          )
-        ) do
-          serialize_color(xml, style.fill_color, :fillColor)
-          serialize_color(xml, style.line_color, :lineColor)
-          serialize_font(xml, style)
-          # TODO: complete this
-        end
-      end
-
-      def serialize_font(xml, style)
-        return unless style && (style.font || style.font_color)
-        xml.font(
-          remove_nil_values(
-            name: style.font&.name,
-            size: style.font&.size&.round,
-            style: font_style_string(style.font)
-          )
-        ) { serialize_color(xml, style&.font_color, :color) }
-      end
-
-      def serialize_color(xml, color, sym)
-        return if color.nil?
-        h = {
-          r: color.r,
-          g: color.g,
-          b: color.b,
-          a: color.a
-        }
-        h.delete(:a) if color.a.nil? || color.a == 100
-        xml.send(sym, h)
-      end
-
-      def serialize_location(xml, location)
-        xml.bendpoint(x: location.x.round, y: location.y.round)
-      end
-
-      # # Processes text for text elements
-      def text_proc(str)
-        str.strip.tr("\r", "\n")
-      end
-
-      # TODO: this should replace namespaces as appropriate for the desired export version
-      def model_namespaces
-        model.namespaces
-      end
-
-      # TODO: Archi uses hex numbers for ids which may not be valid for
-      # identifer. If we are converting from Archi, decorate the IDs here.
-      def identifier(str)
-        return "id-#{str}" if str =~ /^\d/
-        str
-      end
-    end
-  end
-end