archimate 1.2.1 → 2.0.0

data/lib/archimate/file_formats/serializer/model_exchange_file/v30/organization_body.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module ModelExchangeFile
+        module V30
+          module OrganizationBody
+            def serialize_organization_body(xml, organization)
+              if organization.items.empty? &&
+                (!organization.documentation || organization.documentation.empty?) &&
+                organization.organizations.empty?
+                return
+              end
+              serialize_label(xml, organization.name, :label)
+              serialize(xml, organization.documentation)
+              serialize(xml, organization.organizations)
+              organization.items.each { |i| serialize_item(xml, i) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/model_exchange_file/v30/property.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module ModelExchangeFile
+        module V30
+          module Property
+            def serialize_property(xml, property)
+              xml.property("propertyDefinitionRef" => property.property_definition.id) do
+                XmlLangString.new(property.value, :value).serialize(xml)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/model_exchange_file/v30/property_definitions.rb

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

data/lib/archimate/file_formats/serializer/model_exchange_file/v30/view_node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      module ModelExchangeFile
+        module V30
+          module ViewNode
+            def serialize_view_node(xml, view_node, x_offset = 0, y_offset = 0)
+              attrs = view_node_attrs(view_node, x_offset, y_offset)
+              xml.node(attrs) do
+                serialize_label(xml, view_node.name, :label)
+                serialize(xml, view_node.style) if view_node.style
+                view_node.nodes.each do |c|
+                  serialize_view_node(xml, c) # , view_node_attrs[:x].to_f, view_node_attrs[:y].to_f)
+                end
+              end
+            end
+
+            def view_node_attrs(view_node, x_offset = 0, y_offset = 0)
+              attrs = {
+                identifier: identifier(view_node.id),
+                elementRef: nil,
+                "xsi:type" => view_node.type,
+                "x" => view_node.bounds ? (view_node.bounds&.x + x_offset).round : nil,
+                "y" => view_node.bounds ? (view_node.bounds&.y + y_offset).round : nil,
+                "w" => view_node.bounds&.width&.round,
+                "h" => view_node.bounds&.height&.round
+              }
+              if view_node.element
+                attrs[:elementRef] = identifier(view_node.element.id)
+              elsif view_node.view_refs
+                # Since it doesn't seem to be forbidden, we just assume we can use
+                # the elementref for views in views
+                attrs[:elementRef] = view_node.view_refs
+                attrs[:type] = "model"
+              end
+              remove_nil_values(attrs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/named_collection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      class NamedCollection
+        def initialize(name, collection)
+          @name = name
+          @collection = collection
+        end
+
+        def serialize(xml, &block)
+          return unless @collection&.size&.positive?
+          xml.send(@name) do
+            block.call(xml, @collection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/serializer/writer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      class Writer
+        attr_reader :model
+
+        def self.write(model, output_io)
+          writer = new(model)
+          writer.write(output_io)
+        end
+
+        def initialize(model)
+          @model = model
+        end
+
+        def serialize(xml, collection)
+          Array(collection).each do |item|
+            case item
+            when DataModel::Element
+              serialize_element(xml, item)
+            when DataModel::Relationship
+              serialize_relationship(xml, item)
+            when DataModel::Organization
+              serialize_organization(xml, item)
+            when DataModel::Diagram
+              serialize_diagram(xml, item)
+            when DataModel::Location
+              serialize_location(xml, item)
+            when DataModel::Bounds
+              serialize_bounds(xml, item)
+            when DataModel::ViewNode
+              serialize_view_node(xml, item)
+            when DataModel::PreservedLangString
+              Serializer::XmlLangString.new(item, :documentation).serialize(xml)
+            when DataModel::Property
+              serialize_property(xml, item)
+            when DataModel::Connection
+              serialize_connection(xml, item)
+            when DataModel::Style
+              serialize_style(xml, item)
+            else
+              raise TypeError, "Unexpected item type #{item.class}"
+            end
+          end
+        end
+
+        def remove_nil_values(h)
+          h.delete_if { |_k, v| v.nil? }
+          h
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      class XmlLangString
+        def initialize(lang_str, tag_name)
+          @tag_name = tag_name
+          @lang_str = lang_str
+        end
+
+        def serialize(xml)
+          return unless @lang_str && !@lang_str.empty?
+
+          @lang_str.langs.each do |lang|
+            attrs = lang && !lang.empty? ? { "xml:lang" => lang } : {}
+            xml.send(@tag_name, attrs) { xml.text text_proc(@lang_str.by_lang(lang)) }
+          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/serializer/xml_metadata.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Archimate
+  module FileFormats
+    module Serializer
+      class XmlMetadata
+        def initialize(metadata)
+          @metadata = metadata
+        end
+
+        def serialize(xml)
+          return unless @metadata && !@metadata.schema_infos.empty?
+          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)
+          xml_prefix(xml, el).send(el.element.to_sym, serialize_any_attributes(el.attributes)) do
+            xml.text(el.content) if el.content&.size&.positive?
+            el.children.each { |child| serialize_any_element(xml, child) }
+          end
+        end
+
+        def xml_prefix(xml, el)
+          if el.prefix && !el.prefix.empty?
+            xml[el.prefix]
+          else
+            xml
+          end
+        end
+
+        def serialize_any_attributes(attrs)
+          attrs.each_with_object({}) do |attr, hash|
+            key = attr.prefix&.size&.positive? ? [attr.prefix, attr.attribute].join(":") : attr.attribute
+            hash[key] = attr.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/{model_exchange_file → serializer}/xml_property_defs.rb

@@ -2,7 +2,7 @@
 
 module Archimate
   module FileFormats
-    module ModelExchangeFile
+    module Serializer
       # Property Definitions as defined in ArchiMate 2.1 Model Exchange XSDs
       class XmlPropertyDefs
         def initialize(property_defs)
@@ -16,7 +16,7 @@ module Archimate
               xml.propertydef(
                 "identifier" => property_def.id,
                 "name" => property_def.name,
-                "type" => property_def.value_type
+                "type" => property_def.type
               )
             end
           end

data/lib/archimate/lint/duplicate_entities.rb

@@ -86,8 +86,8 @@ module Archimate
       end
 
       def entity_hash_name(entity)
-        layer = DataModel::Constants::ELEMENT_LAYER.fetch(entity.type, nil)
-        layer_sort_order = layer ? DataModel::Constants::LAYER_ELEMENTS.keys.index(layer) : 9
+        layer = DataModel::Layers.for_element(entity.type)
+        layer_sort_order = layer ? DataModel::Layers.find_index(layer) : 9
         [
           entity.class.name, # Taking advantage of Element being before Relationship
           layer_sort_order.to_s,
@@ -104,7 +104,7 @@ module Archimate
       # 4. names differ only in punctuation
       # 5. names differ only by stop-words (list of words such as "the", "api", etc.)
       def simplify(entity)
-        name = entity.name&.dup || ""
+        name = entity.name&.dup.to_s || ""
         name.sub!("(copy)", "") # (copy) is a special case inserted by the Archi tool
         name.downcase!
         name.gsub!(/[[:punct:]]/, "") unless entity.is_a?(DataModel::Relationship)

data/lib/archimate/lint/linter.rb

@@ -13,8 +13,6 @@ module Archimate
     # [x] warn about names with (copy)
     # [x] blank element names
     class Linter
-      include FileFormats::ArchimateV2
-
       attr_reader :model
 
       def initialize(model)
@@ -50,18 +48,18 @@ module Archimate
       def report_subsection(issues, output_io)
         issues.each do |sub_issues|
           output_io.puts(sub_issues)
-          output_io.puts("Sub Total: #{sub_issues.size}")
+          output_io.puts("Sub Total: #{sub_issues.size}") unless sub_issues.empty?
         end
       end
 
       def unused_elements
-        referenced_elements = diagram_referenced_ids
-        model.elements.reject { |el| referenced_elements.include?(el.id) }
+        referenced_elements = model.diagrams.inject([]) { |memo, dia| memo.concat(dia.elements) }.uniq
+        model.elements.reject { |el| referenced_elements.include?(el) }
       end
 
       def unused_relationships
-        referenced_ids = diagram_referenced_ids
-        model.relationships.reject { |el| referenced_ids.include?(el.id) }
+        referenced_relationships = model.diagrams.inject([]) { |memo, dia| memo.concat(dia.relationships) }.uniq
+        model.relationships.reject { |el| referenced_relationships.include?(el) }
       end
 
       def empty_views
@@ -88,15 +86,11 @@ module Archimate
           end
       end
 
-      def diagram_referenced_ids
-        @ref_ids ||= model.diagrams.inject([]) { |memo, dia| memo.concat(dia.referenced_identified_nodes) }.uniq
-      end
-
       def invalid_for_viewpoint
         model.diagrams.each_with_object([]) do |diagram, errors|
           next if diagram.total_viewpoint?
-          valid_entity_types = VIEWPOINTS[diagram.viewpoint][:entities]
-          valid_relation_types = VIEWPOINTS[diagram.viewpoint][:relations]
+          valid_entity_types = DataModel::ViewpointType::VIEWPOINTS[diagram.viewpoint_type][:entities]
+          valid_relation_types = DataModel::ViewpointType::VIEWPOINTS[diagram.viewpoint_type][:relations]
           invalid_elements = diagram.all_nodes.reject do |child|
             child.element&.type.nil? || valid_entity_types.include?(child.element&.type)
           end
@@ -113,21 +107,22 @@ module Archimate
         end
       end
 
-      # Nesting is valid for relations:
-      # * CompositionRelationship
-      # * AggregationRelationship
-      # * AssignmentRelationship
       def nesting_without_relation
-        model.find_by_class(DataModel::ViewNode).each_with_object([]) do |parent, errors|
-          missing_relations = parent.nodes.reject do |child|
-            model.relationships.any? do |rel|
-              parent.archimate_element.nil? ||
-                child.archimate_element.nil? ||
-                (rel.source == parent.archimate_element && rel.target == child.archimate_element)
-            end
-          end
-          errors.concat(missing_relations.map { |child| "#{child.element} should not nest in #{parent.element} without valid relationship" })
-        end
+        model
+          .diagrams
+          .flat_map(&:all_nodes) # These are top level view nodes
+          .reject { |view_node| !view_node.element || view_node.nodes.empty? } # reject the ones with no child view nodes
+          .flat_map { |parent|
+            parent
+              .nodes
+              .select(&:element)
+              .map { |child| [parent, child] } } # map into parent-child pairs for children that are elements
+          .select { |pair|
+            model.relationships.none? { |rel|
+              (rel.source.equal?(pair[0]) && rel.target.equal?(pair[1]))
+            }
+          }
+          .map { |pair| "#{pair[1].element} should not nest in #{pair[0].element} without valid relationship"}
       end
 
       def entity_naming_rules
@@ -135,9 +130,9 @@ module Archimate
           if entity.name.nil? || entity.name.empty?
             errors << "#{entity} name is empty"
           elsif entity.name.size < 2
-            errors << "#{entity} name #{entity.name.inspect} is too short"
+            errors << "#{entity} name #{entity.name} is too short"
           elsif entity.name.include?("(copy)")
-            errors << "#{entity} name #{entity.name.inspect} contains '(copy)'"
+            errors << "#{entity} name #{entity.name} contains '(copy)'"
           end
         end
       end

data/lib/archimate/svg/connection.rb

@@ -8,6 +8,7 @@ module Archimate
 
       def initialize(connection)
         @connection = connection
+        @path = Path.new(@connection)
         @css_style = CssStyle.new(connection.style)
       end
 
@@ -19,22 +20,22 @@ module Archimate
       end
 
       def to_svg(xml)
-        return if connection.source_element.nodes.include?(connection.target_element)
+        return if connection.source.nodes.include?(connection.target)
         xml.path(path_attrs) do
           xml.title @connection.description
         end
 
-        name = connection&.relationship_element&.name&.strip
+        name = connection&.relationship&.name&.strip
         return if name.nil? || name.empty?
+        pt = @path.point(text_position)
         xml.text_(
           class: "archimate-relationship-name",
-          dy: -2,
+          x: pt.x,
+          y: pt.y,
           "text-anchor" => "middle",
           style: css_style.text
         ) do
-          xml.textPath(startOffset: text_position, "xlink:href" => "##{id}") do
-            xml.text name
-          end
+          xml.text name
         end
       end
 
@@ -52,11 +53,11 @@ module Archimate
       def text_position
         case connection.style
         when 0
-          "10%"
+          0.1 # "10%"
         when 1
-          "90%"
+          0.9 # "90%"
         else
-          "50%"
+          0.5 # "50%"
         end
       end
 
@@ -64,20 +65,20 @@ module Archimate
         {
           id: id,
           class: path_class,
-          d: path_d,
+          d: @path.d,
           style: line_style
         }
       end
 
       def id
-        connection.relationship_element&.id || connection.id
+        connection.relationship&.id || connection.id
       end
 
       # Look at the type (if any of the path and set the class appropriately)
       def path_class
         [
           "archimate",
-          css_classify(connection&.relationship_element&.type || "default")
+          css_classify(connection&.relationship&.type || "default")
         ].join("-") + " archimate-relationship"
       end
 
@@ -88,97 +89,6 @@ module Archimate
            .gsub(/([a-z\d])([A-Z])/, '\1-\2')
            .downcase
       end
-
-      def ranges_overlap(r1, r2)
-        begin_max = [r1, r2].map(&:begin).max
-        end_min = [r1, r2].map(&:end).min
-        return nil if begin_max > end_min
-        (begin_max + end_min) / 2.0
-      end
-
-      # builds the line coordinates for the path
-      # rough drawing is the point at center of first element, point of each bendpoint, and center of end element
-      # First naive implementation
-      # if left/right range of both overlap, use centerpoint of overlap range as x val
-      # if top/bottom range of both overlap, use centerpoint of overlap range as y val
-      def path_d
-        source_bounds = connection.source_element&.absolute_position || DataModel::Bounds.zero
-        target_bounds = connection.target_element&.absolute_position || DataModel::Bounds.zero
-
-        start_point = DataModel::Bounds.new(
-          x: source_bounds.left + source_bounds.width / 2.0,
-          y: source_bounds.top + source_bounds.height / 2.0,
-          width: 0,
-          height: 0
-        )
-        bp_bounds = connection.bendpoints.map do |bp|
-          DataModel::Bounds.new(
-            x: start_point.x + (bp.x || 0),
-            y: start_point.y + (bp.y || 0),
-            width: 0,
-            height: 0
-          )
-        end
-        bp_bounds = bp_bounds.reject do |bounds|
-          bounds.inside?(source_bounds) || bounds.inside?(target_bounds)
-        end
-
-        bounds = [source_bounds].concat(bp_bounds) << target_bounds
-
-        points = []
-        a = bounds.shift
-        until bounds.empty?
-          b = bounds.shift
-          points.concat(calc_points(a, b))
-          a = b
-        end
-        points.uniq!
-        [move_to(points.shift)].concat(points.map { |pt| line_to(pt) }).join(" ")
-      end
-
-      # a: Bounds
-      # b: Bounds
-      def calc_points(a, b)
-        ax_range = a.x_range
-        bx_range = b.x_range
-
-        overlap_x_center = ranges_overlap(ax_range, bx_range)
-
-        if overlap_x_center
-          ax = bx = overlap_x_center
-        elsif b.is_right_of?(a)
-          ax = a.right
-          bx = b.left
-        else
-          ax = a.left
-          bx = b.right
-        end
-
-        ay_range = a.y_range
-        by_range = b.y_range
-
-        overlap_y_center = ranges_overlap(ay_range, by_range)
-
-        if overlap_y_center
-          ay = by = overlap_y_center
-        elsif b.is_above?(a)
-          ay = a.top
-          by = b.bottom
-        else
-          ay = a.bottom
-          by = b.top
-        end
-
-        [Point.new(ax, ay), Point.new(bx, by)]
-      end
-
-      def move_to(point)
-        "M #{point.x} #{point.y}"
-      end
-
-      def line_to(point)
-        "L #{point.x} #{point.y}"
-      end
     end
   end
 end