archimate 1.1.0

data/lib/archimate/cli/conflict_resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "highline"
+
+module Archimate
+  module Cli
+    class ConflictResolver
+      def initialize
+        @config = Config.instance
+        # TODO: pull the stdin/stdout from the app config
+        @hl = HighLine.new(STDIN, STDOUT)
+      end
+
+      # TODO: this implementation has much to be written
+      def resolve(conflict)
+        return [] unless @config.interactive
+        base_local_diffs = conflict.base_local_diffs
+        base_remote_diffs = conflict.base_remote_diffs
+        choice = @hl.choose do |menu|
+          menu.prompt = conflict
+          menu.choice(:local, text: base_local_diffs.map(&:to_s).join("\n\t\t"))
+          menu.choice(:remote, text: base_remote_diffs.map(&:to_s).join("\n\t\t"))
+          # menu.choice(:neither, help: "Don't choose either set of diffs")
+          # menu.choice(:edit, help: "Edit the diffs (coming soon)")
+          # menu.choice(:quit, help: "I'm in over my head. Just stop!")
+          menu.select_by = :index_or_name
+        end
+        case choice
+        when :local
+          base_local_diffs
+        when :remote
+          base_remote_diffs
+        else
+          error "Unexpected choice #{choice.inspect}."
+        end
+      end
+    end
+  end
+end

data/lib/archimate/cli/convert.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Cli
+    class Convert
+      include Archimate::Logging
+
+      SUPPORTED_FORMATS = %w[meff2.1 meff3.0 archi nquads graphml csv cypher].freeze
+
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def convert(export_format, output_io, output_dir)
+        return unless output_io && model
+        case export_format
+        when "archi"
+          Archimate::FileFormats::ArchiFileWriter.new(model).write(output_io)
+        when "meff2.1"
+          Archimate::FileFormats::ModelExchangeFileWriter21.new(model).write(output_io)
+        when "meff3.0"
+          Archimate::FileFormats::ModelExchangeFileWriter30.new(model).write(output_io)
+        when "nquads"
+          output_io.write(Archimate::Export::NQuads.new(model).to_nq)
+        when "graphml"
+          output_io.write(Archimate::Export::GraphML.new(model).to_graphml)
+        when "csv"
+          Archimate::Export::CSVExport.new(model).to_csv(output_dir: output_dir)
+        when "cypher"
+          Archimate::Export::Cypher.new(output_io).to_cypher(model)
+        else
+          error { "Export to '#{export_format}' is not supported yet." }
+        end
+      end
+    end
+  end
+end

data/lib/archimate/cli/diff.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Archimate
+  module Cli
+    class Diff
+      attr_reader :local, :remote
+
+      def self.diff(local_file, remote_file)
+        local = Archimate.read(local_file)
+        remote = Archimate.read(remote_file)
+
+        my_diff = Diff.new(local, remote)
+        my_diff.diff
+      end
+
+      def initialize(local, remote)
+        @local = local
+        @remote = remote
+      end
+
+      def diff
+        diffs = Archimate.diff(local, remote)
+
+        diffs.each { |d| puts d }
+
+        puts "\n\n#{diffs.size} Differences"
+
+        diffs
+      end
+    end
+  end
+end

data/lib/archimate/cli/diff_summary.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require 'forwardable'
+
+module Archimate
+  module Cli
+    class DiffSummary
+      using DataModel::DiffableArray
+      using DataModel::DiffablePrimitive
+
+      DIFF_KINDS = %w(Delete Change Insert).freeze
+
+      attr_reader :local, :remote
+
+      def self.diff(local_file, remote_file, options = { verbose: true })
+        logger.info "Reading #{local_file}"
+        local = Archimate.read(local_file)
+        logger.info "Reading #{remote_file}"
+        remote = Archimate.read(remote_file)
+
+        my_diff = DiffSummary.new(local, remote)
+        my_diff.diff
+      end
+
+      def initialize(local, remote)
+        @local = local
+        @remote = remote
+        @summary = Hash.new { |hash, key| hash[key] = Hash.new { |k_hash, k_key| k_hash[k_key] = 0 } }
+      end
+
+      def diff
+        logger.info "Calculating differences"
+        diffs = Archimate.diff(local, remote)
+
+        puts Color.color("Summary of differences", :headline)
+        puts "\n"
+
+        summary_element_diffs = diffs.group_by { |diff| diff.summary_element.class.to_s.split("::").last }
+        summarize_elements summary_element_diffs["Element"]
+        summarize "Organization", summary_element_diffs["Organization"]
+        summarize "Relationship", summary_element_diffs["Relationship"]
+        summarize_diagrams summary_element_diffs["Diagram"]
+
+        puts "Total Diffs: #{diffs.size}"
+      end
+
+      def summarize(title, diffs)
+        return if diffs.nil? || diffs.empty?
+        by_kind = diffs_by_kind(diffs)
+
+        puts color(title)
+        DIFF_KINDS.each do |kind|
+          puts format("  #{color(kind)}: #{by_kind[kind]&.size}") if by_kind.key?(kind)
+        end
+      end
+
+      def diffs_by_kind(diffs)
+        diffs
+          .group_by(&:summary_element)
+          .each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |(summary_element, element_diffs), a|
+          top_level_diff = element_diffs.find { |diff| summary_element == diff.target.value }
+          if top_level_diff
+            a[top_level_diff.kind] << summary_element
+          else
+            a["Change"] << summary_element
+          end
+        end
+      end
+
+      def summarize_elements(diffs)
+        return if diffs.nil? || diffs.empty?
+        puts Color.color("Elements", :headline)
+        by_layer = diffs.group_by { |diff| diff.summary_element.layer }
+        summarize "Business", by_layer["Business"]
+        summarize "Application", by_layer["Application"]
+        summarize "Technology", by_layer["Technology"]
+        summarize "Motivation", by_layer["Motivation"]
+        summarize "Implementation and Migration", by_layer["Implementation and Migration"]
+        summarize "Connectors", by_layer["Connectors"]
+      end
+
+      def summarize_diagrams(diffs)
+        return if diffs.nil? || diffs.empty?
+        puts Color.color("Diagrams", :headline)
+
+        by_kind = diffs_by_kind(diffs)
+        %w(Delete Change Insert).each do |kind|
+          next unless by_kind.key?(kind)
+          diagram_names = by_kind[kind].uniq.map(&:name)
+          puts "  #{color(kind)}"
+          # TODO: make this magic number an option
+          diagram_names[0..14].each { |diagram_name| puts "    #{diagram_name}" }
+          puts "    ... and #{diagram_names.size - 15} more" if diagram_names.size > 15
+        end
+      end
+
+      def color(kind)
+        Color.color(kind, kind)
+      end
+    end
+  end
+end

data/lib/archimate/cli/duper.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "highline"
+
+module Archimate
+  module Cli
+    class Duper
+      def initialize(model, output, mergeall = false)
+        @model = model
+        @output = output
+        @mergeall = mergeall
+        @cli = HighLine.new
+        @skipall = false
+      end
+
+      def list
+        dupes = Archimate::Lint::DuplicateEntities.new(@model)
+
+        dupes.each do |element_type, _name, entities|
+          @output.puts "#{element_type} has potential duplicates: \n\t#{entities.join(",\n\t")}\n"
+        end
+        @output.puts "Total Possible Duplicates: #{dupes.count}"
+      end
+
+      def merge
+        dupes = Archimate::Lint::DuplicateEntities.new(@model)
+        if dupes.empty?
+          @output.puts "No potential duplicates detected"
+          return
+        end
+
+        dupes.each do |element_type, name, entities|
+          handle_duplicate(element_type, name, entities)
+        end
+
+        # TODO: make the output writer be an argument
+        Archimate::FileFormats::ArchiFileWriter.new(@model).write(@output)
+      end
+
+      # Belongs to merge
+      # 1. Determine which one is the *original*
+      protected def handle_duplicate(element_type, name, entities)
+        return if @skipall
+        first_entity = entities.first
+        choice = @mergeall ? first_entity : choices(element_type, name, entities)
+
+        case choice
+        when :mergeall
+          @mergeall = true
+          choice = first_entity
+        when :skip
+          choice = nil
+          @cli.say("Skipping")
+        when :skipall
+          @skipall = true
+          choice = nil
+          @cli.say("Skipping")
+        end
+
+        return unless choice
+        @model.merge_entities(choice, entities)
+      end
+
+      # Belongs to handle_duplicate
+      protected def choices(element_type, name, entities)
+        @cli.choose do |menu|
+          # TODO: set up a layout that permits showing a repr of the copies
+          # to permit making the choice of the original
+          menu.header = "There are #{entities.size} #{element_type}s that are potentially duplicate"
+          menu.prompt = "What to do with potential duplicates?"
+          entities.each_with_index do |entity, idx|
+            menu.choice(entity, help: "Merge entities into this entity")
+          end
+          # menu.choice(:merge, help: "Merge elements into a single element", text: "Merge elements")
+          menu.choice(:mergeall, help: "Merge all elements from here on", text: "Merge all elements")
+          # menu.choices(:rename, "Rename to eliminate duplicates", "Rename element(s)")
+          menu.choice(:skip, help: "Don't change the elements", text: "Skip")
+          menu.choice(:skipall, help: "Skip the rest of the duplicates", text: "Skip the rest")
+          menu.select_by = :index_or_name
+          menu.help("Help", "don't panic")
+        end
+      end
+    end
+  end
+end

data/lib/archimate/cli/lint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Cli
+    class Lint
+      def initialize(model, output_io)
+        @model = model
+        @output_io = output_io
+      end
+
+      def lint
+        Archimate::Lint::Linter.new(@model).report(@output_io)
+      end
+    end
+  end
+end

data/lib/archimate/cli/mapper.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Cli
+    class Mapper
+      HEADERS = %w[id name viewpoint].freeze
+      COL_DIVIDER = " | "
+
+      attr_reader :model
+
+      def initialize(model, output_io)
+        @model = model
+        @output = output_io
+      end
+
+      def header_row(widths, headers)
+        titles = []
+        widths.each_with_index { |w, i| titles << format("%-#{w}s", headers[i]) }
+        @output.puts titles.map { |t| Color.color(t.capitalize, %i[bold blue]) }.join(Color.color(COL_DIVIDER, :light_black))
+        @output.puts Color.color(widths.map { |w| "-" * w }.join("-+-"), :light_black)
+      end
+
+      def process_diagrams(diagrams)
+        diagrams.map { |e| [e.id, e.name, e.viewpoint, e.type] }.map do |row|
+          row[2] = case row[3]
+                   when "canvas:CanvasModel"
+                     ["Canvas", row[4]].compact.join(": ")
+                   when "archimate:SketchModel"
+                     "Sketch"
+                   when "archimate:ArchimateDiagramModel"
+                     DataModel::Constants::VIEWPOINTS[(row[2] || 0).to_i]
+                   else
+                     row[3]
+                   end
+          row[0] = Color.color("#{row[0]}.png", :underline)
+          row
+        end
+      end
+
+      def compute_column_widths(diagrams, headers)
+        initial_widths = headers.map(&:size)
+        diagrams.each_with_object(initial_widths) do |diagram, memo|
+          diagram.slice(0, headers.size).each_with_index do |o, i|
+            memo[i] = !o.nil? && Color.uncolor(o).size > memo[i] ? Color.uncolor(o).size : memo[i]
+          end
+          memo
+        end
+      end
+
+      def output_diagrams(diagrams, widths)
+        diagrams.sort_by { |a| a[1] }.each do |m|
+          row = []
+          m.slice(0, widths.size).each_with_index { |c, i| row << format("%-#{widths[i]}s", c) }
+          @output.puts row.join(Color.color(COL_DIVIDER, :light_black))
+        end
+      end
+
+      def build_organization_hash(organizations, parent = "", hash = {})
+        organizations.each_with_object(hash) do |i, a|
+          organization_path = [parent, i.name].join("/")
+          a[organization_path] = i
+          build_organization_hash(i.organizations, organization_path, a)
+        end
+      end
+
+      def map
+        widths = compute_column_widths(process_diagrams(model.diagrams), HEADERS)
+        adjusted_widths = widths.inject(COL_DIVIDER.size * (HEADERS.size - 1), &:+)
+        header_row(widths, HEADERS)
+        organization_paths = build_organization_hash(model.organizations)
+        organization_paths.keys.sort.each do |organization_name|
+          diagrams = organization_paths[organization_name].items.map { |i| model.lookup(i) }.select { |i| i.is_a?(DataModel::Diagram) }
+          next if diagrams.empty?
+          @output.puts(Color.color(format("%-#{adjusted_widths}s", organization_name), %i[bold green on_light_black]))
+          output_diagrams(process_diagrams(diagrams), widths)
+        end
+
+        @output.puts "\n#{model.diagrams.size} Diagrams"
+      end
+    end
+  end
+end

data/lib/archimate/cli/merge.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "parallel"
+
+module Archimate
+  module Cli
+    class Merge
+      include Logging
+
+      attr_reader :base, :local, :remote, :merged_file
+
+      def self.merge(base_file, remote_file, local_file, merged_file)
+        Logging.debug { "Reading base file: #{base_file}, local file: #{local_file}, remote file: #{remote_file}" }
+        base, local, remote = Parallel.map([base_file, local_file, remote_file], in_processes: 3) do |file|
+          Archimate.read(file)
+        end
+        Logging.debug { "Merged file is #{merged_file}" }
+
+        Merge.new(base, local, remote, merged_file).run_merge
+      end
+
+      def initialize(base, local, remote, merged_file)
+        @base = base
+        @local = local
+        @remote = remote
+        @merged_file = merged_file
+        @merge = Archimate::Diff::Merge.new
+      end
+
+      def run_merge
+        debug { "Starting merging" }
+        merged, conflicts = @merge.three_way(base, local, remote)
+        # TODO: there should be no conflicts here
+        debug do
+          <<~MSG
+            Done merging
+            #{conflicts}
+          MSG
+        end
+
+        File.open(merged_file, "w") do |file|
+          # TODO: this should be controlled by the options and the defaulted to the read format
+          debug { "Serializing" }
+          Archimate::FileFormats::ArchiFileWriter.write(merged, file)
+        end
+      end
+    end
+  end
+end

data/lib/archimate/cli/merger.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Cli
+    # Merger is a class that is a decorator on Archimate::DataModel::Model
+    # to provide the capability to merge another model into itself
+    #
+    # TODO: provide for a conflict resolver instance
+    # TODO: provide an option to determine if potential matches are merged
+    #       or if the conflict resolver should be asked.
+    class Merger # < SimpleDelegator
+      # def initialize(primary_model, conflict_resolver)
+      #   super(primary_model)
+      #   @resolver = conflict_resolver
+      # end
+
+      # What merge does:
+      # For all entities: (other than Model...):
+      #   - PropertyDefinition
+      #   - View
+      #   - Viewpoint
+      # Entity:
+      #   look for a matching entity: with result
+      #     1. Found a matching entity: goto entity merge
+      #     2. Found no matching entity, but id conflicts: gen new id, goto add entity
+      #     3. Found no matching entity: goto add entity
+      #   entity merge:
+      #     1. merge (with func from deduper)
+      #   add entity:
+      #     1. add entity to model
+      #   add remapping entry to map from entities other model id to id in this model
+      # Relationship:
+      # def merge(other_model)
+      #   other_model.entities.each do |entity|
+      #     # TODO: matching entity should use the same criteria that DuplicateEntities uses.
+      #     my_entity = find_matching_entity(entity)
+      #     if my_entity
+      #   end
+      # end
+
+      # TODO: handle inner text of elements
+      # TODO: handle merging by element type
+
+      def hash_to_attr(h)
+        h.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+      end
+
+      def e_to_s(e)
+        "#{e.name} #{hash_to_attr(e.attributes)}"
+      end
+
+      # Merge node1, node2
+      # For node
+      #   For each child
+      #     If has a matching child
+      def merge(doc1, doc2)
+        doc2.children.each do |e|
+          next if e.name == "text" && e.text.strip.empty?
+          # p = e.path
+          # if p =~ /\[\d+\]$/
+          #   p = p.gsub(/\[\d+\]$/, "[@name=\"#{e.attr("name")}\"]")
+          # end
+          # puts "Looking for #{p}"``
+          # matches = doc1.xpath(p)
+          css = ">#{e.name}"
+          # puts css
+          css += "[name=\"#{e.attr('name')}\"]" if e.attributes.include?("name")
+          css += "[xsi|type=\"#{e.attr('xsi:type')}\"]" if e.attributes.include?("xsi:type")
+          matches = doc1.css(css)
+          if !matches.empty? # We have a potential match
+            # puts "Match?"
+            # puts "  Doc2: #{e_to_s(e)}"
+            # matches.each do |e1|
+            #   puts "  Doc1: #{e_to_s(e1)}"
+            # end
+            merge(matches[0], e) unless matches.size > 1
+          else # No match insert the node into the tree TODO: handle id conflicts
+            doc1.add_child(e)
+          end
+        end
+        doc1
+      end
+
+      def id_hash_for(doc)
+        doc.css("[id]").each_with_object({}) do |obj, memo|
+          memo[obj["id"]] = obj
+          memo
+        end
+      end
+
+      def conflicting_ids(doc1, doc2)
+        doc_id_hash1 = id_hash_for(doc1)
+        doc_id_hash2 = id_hash_for(doc2)
+        cids = Set.new(doc_id_hash1.keys) & doc_id_hash2.keys
+        # puts "ID Conflicts:"
+        # puts cids.to_a.join(",")
+        cids
+      end
+
+      def merge_files(file1, file2)
+        doc1 = Nokogiri::XML(File.open(file1))
+        doc2 = Nokogiri::XML(File.open(file2))
+
+        # cids = conflicting_ids(doc1, doc2)
+        merge(doc1.root, doc2.root).document
+      end
+    end
+  end
+end

data/lib/archimate/cli/stats.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Cli
+    class Stats
+      attr_reader :output_io
+      attr_reader :model
+
+      def initialize(model, output_io)
+        @model = model
+        @output_io = output_io
+      end
+
+      def statistics
+        output_io.puts Color.color("#{model.name} ArchiMate Model Statistics\n", :headline)
+
+        output_io.puts "Elements:"
+        elements_by_layer.each do |layer, elements|
+          output_io.puts row(layer, elements.size, layer)
+        end
+        output_io.puts row("Total Elements", model.elements.size, :horizontal_line)
+        output_io.puts row("Relationships", model.relationships.size, :Relationship)
+        output_io.puts row("Diagrams", model.diagrams.size, :Diagram)
+      end
+
+      def elements_by_layer
+        @elements_by_layer ||= model.elements.group_by(&:layer)
+      end
+
+      def title_width
+        @title_width ||= (elements_by_layer.keys + ["Total Elements"]).map(&:size).max
+      end
+
+      def row(title, size, color)
+        @title_format_str ||= "%#{title_width}s"
+        @count_format_str ||= "%7d"
+
+        Color.color(format(@title_format_str, title), color) + format(@count_format_str, size)
+      end
+    end
+  end
+end

data/lib/archimate/cli/svger.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Cli
+    # This class is used to export SVG diagrams as defined in the given model
+    class Svger
+      def self.export_svgs(archi_file, output_dir)
+        new(Archimate.read(archi_file).diagrams, output_dir).export_svgs
+      end
+
+      def initialize(diagrams, output_dir)
+        @diagrams = diagrams
+        @output_dir = output_dir
+      end
+
+      def export_svgs
+        progress = ProgressIndicator.new(total: @diagrams.size, title: "Writing SVGs")
+        @diagrams.each do |diagram|
+          export(diagram)
+          progress.increment
+        end
+      ensure
+        progress.finish
+      end
+
+      def export(diagram, file_name = nil)
+        file_name = Cli.process_svg_filename(file_name || diagram.id)
+        File.open(File.join(@output_dir, file_name), "wb") do |svg_file|
+          svg_file.write(Svg::Diagram.new(diagram).to_svg)
+        end
+      end
+    end
+
+    def self.process_svg_filename(name)
+      file_name = name.strip.tr("/", "-")
+      file_name += ".svg" unless file_name =~ /\.svg$/
+      file_name
+    end
+  end
+end

data/lib/archimate/color.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "highline"
+
+HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
+  cs[:headline]                       = %i[underline bold yellow on_black]
+  cs[:horizontal_line]                = %i[bold white]
+  cs[:even_row]                       = [:green]
+  cs[:odd_row]                        = [:magenta]
+  cs[:error]                          = %i[bold red]
+  cs[:warning]                        = %i[bold yellow]
+  cs[:debug]                          = [:gray]
+  cs[:insert]                         = %i[bold green]
+  cs[:change]                         = %i[bold yellow]
+  cs[:move]                           = %i[bold yellow]
+  cs[:delete]                         = %i[bold red]
+  cs[:Business]                       = %i[black on_light_yellow]
+  cs[:Application]                    = %i[black on_light_blue]
+  cs[:Technology]                     = %i[black on_light_green]
+  cs[:Motivation]                     = %i[black on_light_magenta]
+  cs[:"Implementation and Migration"] = %i[black on_light_red]
+  cs[:Physical]                       = %i[black on_light_green]
+  cs[:Connectors]                     = %i[black on_light_gray]
+  cs[:unknown_layer]                  = %i[black on_gray]
+  cs[:Model]                          = [:cyan]
+  cs[:Connection]               = [:blue]
+  cs[:Organization]                   = [:cyan]
+  cs[:Relationship]                   = %i[black on_light_gray]
+  cs[:Diagram]                        = %i[black on_cyan]
+  cs[:path]                           = [:light_blue]
+end
+
+module Archimate
+  class Color
+    def self.layer_color(layer, str)
+      layer_sym = layer.to_sym
+      sym = HighLine.color_scheme.include?(layer_sym) ? layer_sym : :unknown_layer
+      color(str, sym)
+    end
+
+    def self.data_model(str)
+      layer_color(str, str)
+    end
+
+    def self.color(str, args)
+      HighLine.color(str, args)
+    end
+
+    def self.uncolor(str)
+      HighLine.uncolor(str)
+    end
+  end
+end