archimate 1.1.0

data/lib/archimate/maybe_io.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+## This class passes an IO (or a fake IO) to the given block based on passing
+# either a filename to permit ouput into or nil for a fake IO.
+#
+module Archimate
+  class MaybeIO
+    # Creates a MaybeIO object passing it yielding it to the given block
+    #
+    # @param filename [String, nil] determines the IO yielded to the given block
+    #   String: filename to make writable IO for
+    #   nil:  - A fake IO
+    # @yieldparam [IO] the given block gets an IO (or fake IO)
+    #
+    # @example Usage
+    #   Archimate::MaybeIO.new(myfile) do |io|
+    #     io.write("Writing away")
+    #   end
+    def initialize(filename)
+      if filename.nil?
+        yield self
+      else
+        File.open(filename, "w") do |io|
+          yield io
+        end
+      end
+    end
+
+    # Implementation of the NilIO write method - effectively passes the input
+    # String to /dev/null
+    #
+    # @param _str [String] - unused, no effect
+    def write(_str); end
+  end
+end

data/lib/archimate/progress_indicator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "ruby-progressbar"
+
+module Archimate
+  class ProgressIndicator
+    class FakeProgressBar
+      def increment; end
+
+      def finish; end
+    end
+
+    def initialize(total: 100, title: "ArchiMate!")
+      @progress = if Config.instance.interactive
+                    ProgressBar.create(total: total, title: title, throttle_rate: 0.5)
+                  else
+                    FakeProgressBar.new
+                  end
+    end
+
+    def increment
+      @progress.increment
+    end
+
+    def finish
+      @progress.finish
+    end
+  end
+end

data/lib/archimate/svg/archimate.css

@@ -0,0 +1,232 @@
+svg {
+    font-family: "Lucida Grande";
+    font-size: 11px;
+}
+
+p {
+    fill: black;
+    margin: 0;
+    stroke: none;
+}
+
+path {
+    fill: inherit;
+    stroke: inherit;
+    stroke-width: 1px;
+}
+
+.entity-name {
+    text-align: center;
+    vertical-align: top;
+}
+
+.entity>.properties {
+    visibility: hidden;
+}
+
+.entity:hover>.properties {
+    visibility: visible;
+    z-index: 1000;
+}
+
+table.properties {
+    background-color: whitesmoke;
+    border: 2px solid gray;
+}
+
+table.properties>caption {
+    background-color: gray;
+    border: 2px solid gray;
+    border-top-left-radius: 8px;
+    border-top-right-radius: 8px;
+}
+
+.archimate-decoration {
+    fill:rgba(0,0,0,0.1);
+    stroke: inherit;
+}
+
+.archimate-badge {
+    fill: none;
+    stroke: black;
+    stroke-width: 1px;
+}
+
+.archimate-badge-spacer {
+    float: right;
+    height: 20px;
+    width: 20px;
+    /*border: 1px solid red;*/
+}
+
+.archimate-icon {
+    fill: none;
+    stroke: black;
+}
+
+.archimate-default-element {
+    fill: #ddd;
+    stroke: #999;
+}
+
+.archimate-strategy-background {
+    fill: #eddfac;
+    stroke: #44423b;
+}
+
+.archimate-business-background {
+    fill: #fffeb9;
+    stroke: #b2b181;
+}
+
+.archimate-business-decoration {
+    fill: rgb(229, 229, 162);
+    stroke: rgb(178, 178, 126);
+}
+
+.archimate-application-background {
+    fill: #ccfdfe;
+    stroke: #80b2b2;
+}
+
+.archimate-application-decoration {
+    fill: rgb(162, 229, 229);
+    stroke: rgb(126, 178, 178);
+}
+
+.archimate-infrastructure-background {
+    fill: #cae6b9;
+    stroke: #8ca081;
+}
+
+.archimate-infrastructure-decoration {
+    fill: #b4cfa4;
+    stroke: #9bb28d;
+}
+
+.archimate-physical-background {
+    fill: #cdfeb2;
+    stoke: #313331;
+}
+
+.archimate-motivation-background {
+    fill: #fecdfe;
+    stroke: #b18fb1;
+}
+
+.archimate-motivation2-background {
+    fill: #cccdfd;
+    stroke: #8e8fb1;
+}
+
+.archimate-implementation-background {
+    fill: #fee0e0;
+    stroke: #b19c9c;
+}
+
+.archimate-implementation2-background {
+    fill: #e0ffe0;
+    stroke: #9cb29c;
+}
+
+.archimate-implementation2-decoration {
+    fill: #c9e5c9;
+    stroke: #9cb29c;
+}
+
+.archimate-note-background {
+    fill: #fff;
+    stroke: #b2b2b2;
+}
+
+.archimate-group-background {
+    fill: #d2d7d7;
+    stroke: #939696;
+}
+
+.archimate-sticky-background {
+    fill: #fffeb9;
+    stroke: #b2b181;
+}
+
+.archimate-junction-background {
+    fill: black;
+    stroke: black;
+}
+
+.archimate-or-junction-background {
+    fill: white;
+    stroke: black;
+}
+
+.archimate-diagram-model-reference-background {
+    fill: #dcebeb;
+    stroke: #9aa4a4;
+}
+
+.archimate-default-background {
+    fill: #ddd;
+    stroke: #999;
+}
+
+/* Relationships */
+.archimate-relationship {
+    fill: none;
+    stroke: black;
+    stroke-width: 1px;
+}
+
+.archimate-relationship-name {
+    font-size: 9px;
+}
+
+.archimate-assignment-relationship {
+    marker-end: url(#archimate-dot-marker);
+    marker-start: url(#archimate-dot-marker);
+}
+
+.archimate-composition-relationship {
+    marker-start: url(#archimate-filled-diamond);
+}
+
+.archimate-used-by-relationship {
+    marker-end: url(#archimate-used-by-arrow);
+}
+
+.archimate-serving-relationship {
+    marker-end: url(#archimate-used-by-arrow);
+}
+
+.archimate-aggregation-relationship {
+    marker-start: url(#archimate-hollow-diamond);
+}
+
+.archimate-access-relationship {
+    marker-end: url(#archimate-open-arrow);
+    stroke-dasharray: 2, 3;
+}
+
+.archimate-realisation-relationship {
+    marker-end: url(#archimate-hollow-arrow);
+    stroke-dasharray: 5, 3;
+}
+
+.archimate-specialisation-relationship {
+    marker-end: url(#archimate-hollow-arrow);
+}
+
+/*.archimate-influence-relationship, .archimate-association-relationship {
+}
+*/
+.archimate-triggering-relationship {
+    marker-end: url(#archimate-filled-arrow);
+}
+
+.archimate-flow-relationship {
+    marker-end: url(#archimate-filled-arrow);
+    stroke-dasharray: 3, 3;
+}
+
+/*.archimate-default-connection {
+}
+*/

data/lib/archimate/svg/child.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Svg
+    class Child
+      attr_reader :todos
+      attr_reader :child
+
+      def initialize(child)
+        @child = child
+        @todos = Hash.new(0)
+      end
+
+      # The info needed to render is contained in the child with the exception of
+      # any offset needed. So this will need to be included in the recursive drawing of children
+      def render_elements(svg)
+        Nokogiri::XML::Builder.with(svg) do |xml|
+          entity = EntityFactory.make_entity(child, nil)
+          if entity.nil?
+            puts "Unable to make an SVG Entity for Child:\n#{child}"
+          else
+            entity.to_svg(xml)
+          end
+        end
+        svg
+      end
+    end
+  end
+end

data/lib/archimate/svg/connection.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Svg
+    class Connection
+      attr_reader :connection
+      attr_reader :css_style
+
+      def initialize(connection)
+        @connection = connection
+        @css_style = CssStyle.new(connection.style)
+      end
+
+      def render(svg)
+        Nokogiri::XML::Builder.with(svg) do |xml|
+          to_svg(xml)
+        end
+        svg
+      end
+
+      def to_svg(xml)
+        return if connection.source_element.nodes.include?(connection.target_element)
+        xml.path(path_attrs) do
+          xml.title @connection.description
+        end
+
+        name = connection&.relationship_element&.name&.strip
+        return if name.nil? || name.empty?
+        xml.text_(
+          class: "archimate-relationship-name",
+          dy: -2,
+          "text-anchor" => "middle",
+          style: css_style.text
+        ) do
+          xml.textPath(startOffset: text_position, "xlink:href" => "##{id}") do
+            xml.text name
+          end
+        end
+      end
+
+      def line_style
+        style = connection.style
+        return "" if style.nil?
+        {
+          "stroke": style.line_color&.to_rgba,
+          "stroke-width": style.line_width
+        }.delete_if { |_key, value| value.nil? }
+          .map { |key, value| "#{key}:#{value};" }
+          .join("")
+      end
+
+      def text_position
+        case connection.style
+        when 0
+          "10%"
+        when 1
+          "90%"
+        else
+          "50%"
+        end
+      end
+
+      def path_attrs
+        {
+          id: id,
+          class: path_class,
+          d: path_d,
+          style: line_style
+        }
+      end
+
+      def id
+        connection.relationship_element&.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")
+        ].join("-") + " archimate-relationship"
+      end
+
+      # TODO: StringRefinements refinement isn't working in this class, so added this method here. Investigate.
+      def css_classify(str)
+        str.gsub(/::/, '/')
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1-\2')
+           .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

data/lib/archimate/svg/css_style.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Svg
+    class CssStyle
+      attr_reader :style
+
+      def initialize(style)
+        @style = style
+      end
+
+      def text
+        return "" if style.nil?
+        to_css(
+          "fill": style.font_color&.to_rgba,
+          "color": style.font_color&.to_rgba,
+          "font-family": style.font&.name,
+          "font-size": style.font&.size,
+          "text-align": style.text_align
+        )
+      end
+
+      def to_css(style_hash)
+        style_hash
+          .delete_if { |_key, value| value.nil? }
+          .map { |key, value| "#{key}:#{value};" }
+          .join("")
+      end
+    end
+  end
+end

data/lib/archimate/svg/diagram.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "erb"
+require "nokogiri"
+
+module Archimate
+  module Svg
+    class Diagram
+      attr_reader :diagram
+
+      def initialize(diagram)
+        @diagram = diagram
+        @svg_template = Nokogiri::XML(SvgTemplate.new.to_s).freeze
+      end
+
+      def to_svg
+        svg_doc = @svg_template.clone
+        set_title(svg_doc)
+        top_group = svg_doc.at_css("#archimate-diagram")
+        render_connections(
+          render_elements(top_group)
+        )
+        update_viewbox(svg_doc.at_css("svg"))
+        format_node(top_group)
+        svg_doc.to_xml(encoding: 'UTF-8', indent: 2)
+      end
+
+      def set_title(svg)
+        svg.at_css("title").content = diagram.name || "untitled"
+        svg.at_css("desc").content = diagram.documentation.first&.text || ""
+      end
+
+      # Scan the SVG and figure out min & max
+      def update_viewbox(svg)
+        extents = calculate_max_extents(svg).expand(10)
+        svg.set_attribute(:width, extents.width)
+        svg.set_attribute(:height, extents.height)
+        svg.set_attribute("viewBox", "#{extents.min_x} #{extents.min_y} #{extents.width} #{extents.height}")
+        svg
+      end
+
+      def format_node(node, depth = 4)
+        node.children.each do |child|
+          child.add_previous_sibling("\n#{ ' ' * depth }")
+          format_node(child, depth + 2)
+          child.add_next_sibling("\n#{ ' ' * (depth - 2) }") if node.children.last == child
+        end
+      end
+
+      def calculate_max_extents(doc)
+        node_vals =
+          doc
+          .xpath("//*[@x or @y]")
+          .map { |node| %w[x y width height].map { |attr| node.attr(attr).to_i } }
+        doc.css(".archimate-relationship")
+          .each { |path|
+            path.attr("d").split(" ").each_slice(3) do |point|
+              node_vals << [point[1].to_i, point[2].to_i, 0, 0]
+            end
+          }
+        Extents.new(
+          node_vals.map(&:first).min,
+          node_vals.map { |v| v[0] + v[2] }.max,
+          node_vals.map { |v| v[1] }.min,
+          node_vals.map { |v| v[1] + v[3] }.max
+        )
+      end
+
+      def attr_to_i(node, attr)
+        ival = node.attr(attr)
+        ival.to_i unless ival.nil? || ival.strip.empty?
+      end
+
+      def render_elements(svg_node)
+        diagram
+          .nodes
+          .reduce(svg_node) { |svg, child| Child.new(child).render_elements(svg) }
+      end
+
+      def render_connections(svg_node)
+        diagram
+          .connections
+          .reduce(svg_node) { |svg, connection| Connection.new(connection).render(svg) }
+      end
+    end
+  end
+end

data/lib/archimate/svg/entity/and_junction.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Svg
+    module Entity
+      class AndJunction < RectEntity
+        def initialize(child, bounds_offset)
+          super
+          @background_class = "archimate-junction-background"
+        end
+      end
+    end
+  end
+end

data/lib/archimate/svg/entity/application_collaboration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Svg
+    module Entity
+      class ApplicationCollaboration < RectEntity
+        def initialize(child, bounds_offset)
+          super
+          @badge = "#archimate-collaboration-badge"
+        end
+      end
+    end
+  end
+end

data/lib/archimate/svg/entity/application_component.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Svg
+    module Entity
+      # TODO: support alternate appearance
+      class ApplicationComponent < BaseEntity
+        def initialize(child, bounds_offset)
+          super
+        end
+
+        def entity_shape(xml, bounds)
+          component_path(xml, bounds)
+        end
+
+        def component_path(xml, bounds)
+          main_box_x = bounds.left + 21.0 / 2
+          main_box_width = bounds.width - 21 / 2
+          set_text_bounds(bounds, main_box_x)
+          xml.rect(x: main_box_x, y: bounds.top, width: main_box_width, height: bounds.height, class: background_class, style: shape_style)
+          component_decoration(xml, bounds.left, bounds.top + 10)
+          component_decoration(xml, bounds.left, bounds.top + 30)
+        end
+
+        def component_decoration(xml, left, top)
+          xml.rect(x: left, y: top, width: "21", height: "13", class: background_class, style: shape_style)
+          xml.rect(x: left, y: top, width: "21", height: "13", class: "archimate-decoration")
+        end
+
+        def set_text_bounds(bounds, main_box_x)
+          @text_bounds = DataModel::Bounds.new(
+            x: main_box_x + 21 / 2,
+            y: bounds.top + 1,
+            width: bounds.width - 22,
+            height: bounds.height - 2
+          )
+        end
+      end
+    end
+  end
+end

data/lib/archimate/svg/entity/application_event.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Archimate
+  module Svg
+    module Entity
+      class ApplicationEvent < EventEntity
+        def initialize(child, bounds_offset)
+          super
+        end
+      end
+    end
+  end
+end