archimate 1.1.0

data/lib/archimate/file_formats/model_exchange_file_writer_21.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    # Archimate version 2.1 Model Exchange Format Writer
+    class ModelExchangeFileWriter21 < ModelExchangeFileWriter
+      def initialize(model)
+        super
+      end
+
+      def model_attrs
+        model_namespaces.merge(
+          "xsi:schemaLocation" => model.schema_locations.join(" "),
+          "identifier" => identifier(model.id)
+        )
+      end
+
+      def serialize_model(xml)
+        xml.model(model_attrs) do
+          ModelExchangeFile::XmlMetadata.new(model.metadata).serialize(xml)
+          ModelExchangeFile::XmlLangString.new(model.name, :name).serialize(xml)
+          ModelExchangeFile::XmlLangString.new(model.documentation, :documentation).serialize(xml)
+          serialize_properties(xml, model)
+          serialize_elements(xml)
+          serialize_relationships(xml)
+          serialize_organization_root(xml, model.organizations)
+          serialize_property_defs(xml)
+          serialize_views(xml)
+        end
+      end
+
+      def serialize_property_defs(xml)
+        return if model.property_definitions.empty?
+        ModelExchangeFile::XmlPropertyDefs.new(model.property_definitions).serialize(xml)
+      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_organization_root(xml, organizations)
+        return unless organizations && organizations.size > 0
+        xml.organization do
+          serialize(xml, organizations)
+        end
+      end
+
+      def serialize_item(xml, item)
+        xml.item(identifierref: identifier(item))
+      end
+
+      def serialize_property(xml, property)
+        xml.property(identifierref: property.property_definition.id) do
+          ModelExchangeFile::XmlLangString.new(property.value, :value).serialize(xml)
+        end
+      end
+
+      def serialize_views(xml)
+        return if model.diagrams.empty?
+        xml.views do
+          serialize(xml, model.diagrams)
+        end
+      end
+
+      def serialize_diagram(xml, diagram)
+        xml.view(
+          remove_nil_values(
+            identifier: identifier(diagram.id),
+            viewpoint: diagram.viewpoint_type,
+            "xsi:type": diagram.type
+          )
+        ) do
+          elementbase(xml, diagram)
+          serialize(xml, diagram.nodes)
+          serialize(xml, diagram.connections)
+        end
+      end
+
+      def view_node_attrs(view_node, x_offset = 0, y_offset = 0)
+        attrs = {
+          identifier: identifier(view_node.id),
+          elementref: nil,
+          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,
+          type: nil
+        }
+        if view_node.archimate_element
+          attrs[:elementref] = identifier(view_node.archimate_element)
+        elsif view_node.model
+          # Since it doesn't seem to be forbidden, we just assume we can use
+          # the elementref for views in views
+          attrs[:elementref] = view_node.model
+          attrs[:type] = "model"
+        else
+          attrs[:type] = "group"
+        end
+        remove_nil_values(attrs)
+      end
+
+      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) if attrs[:type] == "group"
+          serialize(xml, view_node.style) if view_node.style
+          view_node.nodes.each do |c|
+            serialize_view_node(xml, c) # , attrs[:x].to_f, attrs[:y].to_f)
+          end
+        end
+      end
+
+      def font_style_string(font)
+        font&.style_string
+      end
+
+      def serialize_connection(xml, sc)
+        xml.connection(
+          identifier: identifier(sc.id),
+          relationshipref: identifier(sc.relationship),
+          source: identifier(sc.source),
+          target: identifier(sc.target)
+        ) do
+          serialize(xml, sc.bendpoints)
+          serialize(xml, sc.style)
+        end
+      end
+
+      def meff_type(el_type)
+        el_type = el_type.sub(/^/, "")
+        case el_type
+        when 'AndJunction', 'OrJunction'
+          'Junction'
+        else
+          el_type
+        end
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/model_exchange_file_writer_30.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+require "nokogiri"
+
+module Archimate
+  module FileFormats
+    class ModelExchangeFileWriter30 < ModelExchangeFileWriter
+      def initialize(model)
+        super
+      end
+
+      def model_attrs
+        remove_nil_values(
+          model_namespaces.merge(
+            "xsi:schemaLocation" => model.schema_locations.join(" "),
+            "identifier" => identifier(model.id),
+            "version" => model.version
+          )
+        )
+      end
+
+      def serialize_model(xml)
+        xml.model(model_attrs) do
+          ModelExchangeFile::XmlLangString.new(model.name, :name).serialize(xml)
+          ModelExchangeFile::XmlLangString.new(model.documentation, :documentation).serialize(xml)
+          ModelExchangeFile::XmlMetadata.new(model.metadata).serialize(xml)
+          serialize_properties(xml, model)
+          serialize_elements(xml)
+          serialize_relationships(xml)
+          serialize_organization_root(xml, model.organizations)
+          serialize_property_defs(xml)
+          serialize_views(xml)
+        end
+      end
+
+      def serialize_property_defs(xml)
+        return if model.property_definitions.empty?
+        ModelExchangeFile::XmlPropertyDefinitions.new(model.property_definitions).serialize(xml)
+      end
+
+      def serialize_label(xml, str, tag = :name)
+        return if str.nil? || str.strip.empty?
+        name_attrs = str.lang && !str.lang.empty? ? {"xml:lang" => str.lang} : {}
+        xml.send(tag, name_attrs) { xml.text text_proc(str) }
+      end
+
+      def relationship_attributes(relationship)
+        attrs = super
+        attrs["accessType"] = relationship.access_type if relationship.access_type
+        attrs
+      end
+
+      def serialize_organization_root(xml, organizations)
+        return unless organizations && organizations.size > 0
+        xml.organizations do
+          serialize_organization_body(xml, organizations[0])
+        end
+      end
+
+      def serialize_item(xml, item)
+        xml.item(identifierRef: identifier(item))
+      end
+
+      def serialize_property(xml, property)
+        xml.property("propertyDefinitionRef" => property.property_definition.id) do
+          ModelExchangeFile::XmlLangString.new(property.value, :value).serialize(xml)
+        end
+      end
+
+      def serialize_views(xml)
+        return if model.diagrams.empty?
+        xml.views do
+          xml.diagrams {
+            serialize(xml, model.diagrams)
+          }
+        end
+      end
+
+      def serialize_diagram(xml, diagram)
+        xml.view(
+          remove_nil_values(
+            identifier: identifier(diagram.id),
+            "xsi:type": diagram.type,
+            viewpoint: diagram.viewpoint_type
+          )
+        ) do
+          elementbase(xml, diagram)
+          serialize(xml, diagram.nodes)
+          serialize(xml, diagram.connections)
+        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.archimate_element
+          attrs[:elementRef] = identifier(view_node.archimate_element)
+        elsif view_node.model
+          # Since it doesn't seem to be forbidden, we just assume we can use
+          # the elementref for views in views
+          attrs[:elementRef] = view_node.model
+          attrs[:type] = "model"
+        end
+        remove_nil_values(attrs)
+      end
+
+      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 font_style_string(font)
+        case font&.style
+        when 1
+          "italic"
+        when 2
+          "bold"
+        when 3
+          "bold italic"
+        end
+      end
+
+      def serialize_connection(xml, sc)
+        xml.connection(
+          identifier: identifier(sc.id),
+          relationshipRef: identifier(sc.relationship),
+          "xsi:type": sc.type,
+          source: identifier(sc.source),
+          target: identifier(sc.target)
+        ) do
+          serialize(xml, sc.style)
+          serialize(xml, sc.bendpoints)
+        end
+      end
+
+      def meff_type(el_type)
+        el_type.sub(/^/, "")
+      end
+    end
+  end
+end

data/lib/archimate/file_formats/writer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'archimate/file_formats/model_exchange_file/xml_lang_string'
+
+module Archimate
+  module FileFormats
+    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::Location
+            serialize_location(xml, item)
+          when DataModel::Bounds
+            serialize_bounds(xml, item)
+          when DataModel::ViewNode
+            serialize_view_node(xml, item)
+          when DataModel::Diagram
+            serialize_diagram(xml, item)
+          when DataModel::Documentation
+            ModelExchangeFile::XmlLangString.new(item, :documentation).serialize(xml)
+          when DataModel::Element
+            serialize_element(xml, item)
+          when DataModel::Organization
+            serialize_organization(xml, item)
+          when DataModel::Property
+            serialize_property(xml, item)
+          when DataModel::Relationship
+            serialize_relationship(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

data/lib/archimate/lint/duplicate_entities.rb

@@ -0,0 +1,121 @@
+module Archimate
+  module Lint
+    STOP_WORDS = %w(
+          a able about above according accordingly across actually after afterwards again against all allow allows
+          almost alone along already also although always am among amongst amoungst amount an and another any anybody
+          anyhow anyone anything anyway anyways anywhere apart appear appreciate appropriate are around as aside ask
+          asking associated at available away awfully back be became because become becomes becoming been before
+          beforehand behind being believe below beside besides best better between beyond bill both bottom brief but
+          by call came can can't cannot cant cause causes certain certainly changes clearly co com come comes computer
+          con concerning consequently consider considering contain containing contains corresponding could couldn't
+          couldnt course cry currently de dear definitely describe described despite detail did didn't different do
+          does doesn't doing don't done down downwards due during each edu eg eight either eleven else elsewhere empty
+          enough entirely especially et etc even ever every everybody everyone everything everywhere ex exactly example
+          except far few fifteen fifth fify fill find fire first five followed following follows for former formerly
+          forth forty found four from front full further furthermore get gets getting give given gives go goes going
+          gone got gotten greetings had hadn't happens hardly has hasn't hasnt have haven't having he he's hello help
+          hence her here here's hereafter hereby herein hereupon hers herself hi him himself his hither hopefully how
+          howbeit however hundred i i'd i'll i'm i've ie if ignored immediate in inasmuch inc indeed indicate indicated
+          indicates inner insofar instead interest into inward is isn't it it'd it'll it's its itself just keep keeps
+          kept know known knows last lately later latter latterly least less lest let let's like liked likely little
+          look looking looks ltd made mainly many may maybe me mean meanwhile merely might mill mine more moreover most
+          mostly move much must my myself name namely nd near nearly necessary need needs neither never nevertheless
+          new next nine no nobody non none noone nor normally not nothing novel now nowhere obviously of off often oh
+          ok okay old on once one ones only onto or other others otherwise ought our ours ourselves out outside over
+          overall own part particular particularly per perhaps placed please plus possible presumably probably provides
+          put que quite qv rather rd re really reasonably regarding regardless regards relatively respectively right
+          said same saw say saying says second secondly see seeing seem seemed seeming seems seen self selves sensible
+          sent serious seriously seven several shall she should shouldn't show side since sincere six sixty so some
+          somebody somehow someone something sometime sometimes somewhat somewhere soon sorry specified specify
+          specifying still sub such sup sure system take taken tell ten tends th than thank thanks thanx that that's
+          thats the their theirs them themselves then thence there there's thereafter thereby therefore therein theres
+          thereupon these they they'd they'll they're they've thick thin think third this thorough thoroughly those
+          though three through throughout thru thus tis to together too took top toward towards tried tries truly try
+          trying twas twelve twenty twice two un under unfortunately unless unlikely until unto up upon us use used
+          useful uses using usually value various very via viz vs want wants was wasn't way we we'd we'll we're we've
+          welcome well went were weren't what what's whatever when whence whenever where where's whereafter whereas
+          whereby wherein whereupon wherever whether which while whither who who's whoever whole whom whose why will
+          willing wish with within without won't wonder would wouldn't yes yet you you'd you'll you're you've your
+          yours yourself yourselves zero).freeze
+
+    class DuplicateEntities
+      attr_reader :word_count
+      # TODO: Add option to permit additional project specific stop words
+      # TODO: Do relationships after elements are merged
+      def initialize(model)
+        @model = model
+        @dupes = nil
+        @count = nil
+        @word_count = {}
+        @ignored_entity_types = %w(Junction AndJunction OrJunction)
+        dupe_list
+      end
+
+      def count
+        @dupes.reduce(0) { |total, (_tag, ary)| total + ary.size }
+      end
+
+      def empty?
+        count.zero?
+      end
+
+      def each(&block)
+        @dupes.keys.sort.each do |name|
+          ary = @dupes[name]
+          element_type = ary.first.type
+          block.call(element_type, name, ary)
+        end
+      end
+
+      protected
+      def candidate_entities
+        @model.entities.select do |entity|
+          (entity.is_a?(DataModel::Element) || entity.is_a?(DataModel::Relationship)) &&
+            !@ignored_entity_types.include?(entity.type)
+        end
+      end
+
+      def dupe_list
+        @dupes = candidate_entities.each_with_object({}) do |entity, hash|
+          tag = entity_hash_name(entity)
+          hash[tag] = hash.fetch(tag, []) << entity
+        end
+        @dupes.delete_if { |_tag, entities| entities.size <= 1 }
+        # @word_count.sort_by(&:last).reverse.each { |ak, av| puts "#{ak}: #{av}" }
+        @dupes
+      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
+        [
+          entity.class.name, # Taking advantage of Element being before Relationship
+          layer_sort_order.to_s,
+          entity.type,
+          simplify(entity)
+        ].join("/")
+      end
+
+      # This method takes an entity name and simplifies it for duplicate determination
+      # This might be configurable in the future
+      # 1. names are explicitly identical
+      # 2. names differ only in case
+      # 3. names differ only in whitespace
+      # 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.sub!("(copy)", "") # (copy) is a special case inserted by the Archi tool
+        name.downcase!
+        name.gsub!(/[[:punct:]]/, "") unless entity.is_a?(DataModel::Relationship)
+        name.strip!
+        words = name.split(/\s/)
+        words.each { |word| @word_count[word] = @word_count.fetch(word, 0) + 1 }
+        name = words.reject { |word| STOP_WORDS.include?(word) }.join("")
+        name.delete!(" \t\n\r")
+        name = "#{name}:#{entity.source}:#{entity.target}" if entity.is_a?(DataModel::Relationship)
+        name
+      end
+    end
+  end
+end

data/lib/archimate/lint/linter.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+module Archimate
+  module Lint
+    # lint notes
+    #
+    # [x] Unused element (not used in a view)
+    # [x] Unused relation (not used in a view)
+    # [x] Object in a Viewpoint (invalid object for viewpoint)
+    # [x] Duplicate same name for type
+    # [x] empty view
+    # [?] visual nesting without relationship
+    # [ ] Warn about sketch model
+    # [x] warn about names with (copy)
+    # [x] blank element names
+    class Linter
+      include FileFormats::ArchimateV2
+
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+        @indent = "\n" + " " * 8
+      end
+
+      # TODO: consider a means to sort lint issues by entity instead of lint category
+      #       this would point out the particularly problematic items that could be
+      #       dealt with appropriately.
+      def report(output_io)
+        [
+          [unused_elements, "Unused Element"],
+          [duplicate_elements, "Duplicate Items"],
+          [entity_naming_rules, "Naming Rules"],
+          [unused_relationships, "Unused Relationship"],
+          [duplicate_relationships, "Duplicate Relationships"],
+          [empty_views, "Empty View"],
+          [invalid_for_viewpoint, "Invalid Type for Viewpoint"],
+          [nesting_without_relation, "Visual Nesting"]
+        ]
+          .map { |issues, title| issues.map { |issue| "#{title}: #{format_issue(issue)}" } }
+          .tap { |issues| report_subsection(issues, output_io) }
+          .tap { |issues| output_io.puts("Total Issues: #{issues.flatten.size}") }
+      end
+
+      def format_issue(issue)
+        ary = Array(issue)
+        return issue if ary.size == 1
+        "#{@indent}#{ary.join(@indent)}"
+      end
+
+      def report_subsection(issues, output_io)
+        issues.each do |sub_issues|
+          output_io.puts(sub_issues)
+          output_io.puts("Sub Total: #{sub_issues.size}")
+        end
+      end
+
+      def unused_elements
+        referenced_elements = diagram_referenced_ids
+        model.elements.reject { |el| referenced_elements.include?(el.id) }
+      end
+
+      def unused_relationships
+        referenced_ids = diagram_referenced_ids
+        model.relationships.reject { |el| referenced_ids.include?(el.id) }
+      end
+
+      def empty_views
+        model.diagrams.select { |diagram| diagram.nodes.empty? }
+      end
+
+      def duplicate_elements
+        duplicates(model.elements, ->(el) { [el.type, name_for_comparison(el.name)] })
+      end
+
+      def duplicate_relationships
+        duplicates(model.relationships, ->(el) { [el.type, el.source, el.target, name_for_comparison(el.name)] })
+      end
+
+      def name_for_comparison(name)
+        name&.strip&.downcase
+      end
+
+      def duplicates(array, group_by_proc)
+        array
+          .group_by { |el| group_by_proc.call(el) }
+          .each_with_object([]) do |(_key, ary), dupes|
+            dupes << ary.map(&:to_s) if ary.size > 1
+          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]
+          invalid_elements = diagram.all_nodes.reject do |child|
+            child.element&.type.nil? || valid_entity_types.include?(child.element&.type)
+          end
+          invalid_relations = diagram.connections.reject do |sc|
+            sc.element&.type.nil? || valid_relation_types.include?(sc.element&.type)
+          end
+          next unless !invalid_elements.empty? || !invalid_relations.empty?
+          errors << format(
+            "%s viewpoint %s#{@indent}%s",
+            diagram,
+            diagram.viewpoint,
+            (invalid_elements + invalid_relations).map(&:element).map(&:to_s).join(@indent)
+          )
+        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
+      end
+
+      def entity_naming_rules
+        model.elements.each_with_object([]) do |entity, errors|
+          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"
+          elsif entity.name.include?("(copy)")
+            errors << "#{entity} name #{entity.name.inspect} contains '(copy)'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archimate/logging.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Archimate
+  # This is a helper module to make logging calls a little less clunky
+  module Logging
+    def update(sym, val)
+      @logger = val if sym == :logger
+    end
+
+    def logger
+      unless defined?(@logger)
+        config = Archimate::Config.instance
+        config.add_observer(self)
+        @logger = config.logger
+      end
+      @logger
+    end
+
+    def debug(progname = nil, &block)
+      logger.debug(progname, &block)
+    end
+
+    def error(progname = nil, &block)
+      logger.error(progname, &block)
+    end
+
+    def fatal(progname = nil, &block)
+      logger.fatal(progname, &block)
+    end
+
+    def info(progname = nil, &block)
+      logger.info(progname, &block)
+    end
+
+    def self.logger
+      Archimate::Config.instance.logger
+    end
+
+    def self.debug(progname = nil, &block)
+      logger.debug(progname, &block)
+    end
+
+    def self.error(progname = nil, &block)
+      logger.error(progname, &block)
+    end
+
+    def self.fatal(progname = nil, &block)
+      logger.fatal(progname, &block)
+    end
+
+    def self.info(progname = nil, &block)
+      logger.info(progname, &block)
+    end
+  end
+end