etassia 0.1.0

data/lib/etassia/notation/plantuml/node_graph/shapes.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require_relative "../../../svg"
+require_relative "archimate"
+require_relative "cloud"
+require_relative "data_shape"
+require_relative "entity_shape"
+require_relative "figures"
+require_relative "../creole"
+require_relative "metrics"
+require_relative "tab"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # Draws one placed node as SVG elements.
+        class Shapes
+          STROKE = "#181818"
+          FILL = "#F1F1F1"
+          FONT = "sans-serif"
+          HEX = /\A[0-9A-Fa-f]{3,8}\z/
+          # The reference draws every leaf with a hairline, a port with a
+          # heavy line, and a container with a plain one.
+          LEAF_WIDTH = "0.5"
+          WIDTHS = { portin: "1.5", portout: "1.5" }.freeze
+          # A package and a folder are the two containers drawn heavy, in
+          # black rather than the plain stroke.
+          HEAVY = { width: "1.5", stroke: "#000000" }.freeze
+          HEAVY_KINDS = %i[package folder].freeze
+          private_constant :LEAF_WIDTH, :WIDTHS, :HEAVY, :HEAVY_KINDS
+
+          # @param placed [Placed]
+          # @return [Array<Svg::Element>]
+          def draw(placed)
+            return DataShape.new(placed).elements if placed.node.kind == :data
+            return entity(placed) if placed.node.kind == :entity
+
+            @p = placed
+            @out = []
+            @icon = false
+            placed.node.container? ? container : figure
+            @out
+          end
+
+          private
+
+          def entity(placed)
+            EntityShape.new(placed).elements
+          end
+
+          def line
+            return HEAVY.transform_keys(width: :stroke_width) if heavy?
+
+            { stroke: STROKE, stroke_width: stroke_width }
+          end
+
+          def heavy?
+            @p.node.container? && HEAVY_KINDS.include?(@p.node.kind)
+          end
+
+          # A container keeps the plain line; so does its icon, drawn as the
+          # hairline of a leaf component.
+          def stroke_width
+            return "0.5" if @icon
+
+            @p.node.container? ? "1" : WIDTHS.fetch(@p.node.kind, LEAF_WIDTH)
+          end
+
+          def add(type, **attrs)
+            @out << type.new.tap do |node|
+              attrs.each { |key, value| node.public_send(:"#{key}=", value) }
+            end
+          end
+
+          def fill
+            color = @p.node.color
+            return container_fill unless color
+
+            color.match?(HEX) ? "##{color}" : color
+          end
+
+          def at(spec)
+            [along(spec[0], spec[2], @p.x, @p.width),
+             along(spec[1], spec[3], @p.y + figure_drop, @p.height)]
+          end
+
+          def along(fraction, offset, origin, extent)
+            origin + (fraction * extent) + offset
+          end
+
+          # An actor's stereotype is written above its figure, which moves
+          # down a line to make room.
+          def figure_drop
+            above_figure? ? Metrics::LINE_HEIGHT : 0
+          end
+
+          def above_figure?
+            @p.node.kind == :actor && @p.node.stereotype
+          end
+
+          def size(spec)
+            [(spec[0] * @p.width) + spec[2], (spec[1] * @p.height) + spec[3]]
+          end
+
+          def figure
+            kind = @p.node.kind
+            Figures.for(kind).each do |type, *args|
+              send(:"draw_#{type}", *args)
+            end
+            label(Figures.label(kind).merge(@p.node.sprite ? { dy: 10 } : {}))
+            draw_sprite if @p.node.sprite
+          end
+
+          # The icon of an archimate element, centred at its top; the label
+          # moves down to make room.
+          def draw_sprite
+            left = @p.x + (@p.width / 2) - 8.5
+            add(Svg::Path, d: @p.node.sprite, fill: "#000000",
+                           transform: "translate(#{left},#{@p.y + 12})")
+          end
+
+          def draw_rect(origin, extent, radius = nil)
+            x, y = at(origin)
+            width, height = size(extent)
+            add(Svg::Rect, x: x, y: y, width: width, height: height,
+                           rx: radius, ry: radius, fill: fill, **line)
+          end
+
+          def draw_circle(center, radius)
+            x, y = at(center)
+            add(Svg::Circle, cx: x, cy: y, r: radius, fill: fill, **line)
+          end
+
+          def draw_line(from, to)
+            x1, y1 = at(from)
+            x2, y2 = at(to)
+            add(Svg::Line, x1: x1, y1: y1, x2: x2, y2: y2, **line)
+          end
+
+          def draw_ellipse
+            add(Svg::Ellipse, cx: @p.x + (@p.width / 2),
+                              cy: @p.y + (@p.height / 2), rx: @p.width / 2,
+                              ry: @p.height / 2, fill: fill, **line)
+          end
+
+          def draw_polygon(points, color = fill)
+            add(Svg::Polygon, points: points.map { |pt| at(pt).join(",") }
+              .join(" "),
+                              fill: color, **line)
+          end
+
+          def draw_path(commands, color = fill)
+            add(Svg::Path, d: commands.map { |cmd| command(*cmd) }.join(" "),
+                           fill: color, **line)
+          end
+
+          def draw_cloud
+            add(Svg::Path, d: Cloud.new(@p).to_d, fill: fill, **line)
+          end
+
+          def command(verb, *args)
+            case verb
+            when :Z then "Z"
+            when :A then arc(*args)
+            else "#{verb}#{at(args.first).join(',')}"
+            end
+          end
+
+          def arc(radii, sweep, target)
+            "A#{size(radii).join(',')} 0 0 #{sweep} #{at(target).join(',')}"
+          end
+
+          def lines
+            Metrics.text_lines(@p.node)
+          end
+
+          def label(options)
+            top = options[:top] ? @p.y + options[:top] : middle(options)
+            anchor, x_pos = label_anchor(options)
+            lines.each_with_index do |line, index|
+              y = top + (index * Metrics::LINE_HEIGHT) + Metrics::ASCENT
+              caption(stereotype?(index), [x_pos, y], line, anchor)
+            end
+          end
+
+          def caption(stereotype, point, line, anchor)
+            return text(*point, line, anchor) unless stereotype
+
+            stereotype_line(*point, line, anchor)
+          end
+
+          def stereotype?(index)
+            index.zero? && @p.node.stereotype
+          end
+
+          # The stereotype line is italic; an actor's goes above its figure,
+          # the name lines staying where they were.
+          def stereotype_line(x_pos, baseline, line, anchor)
+            text(x_pos, above_figure? ? @p.y + Metrics::ASCENT : baseline,
+                 line, anchor)
+            @out.last.font_style = "italic"
+          end
+
+          def label_anchor(options)
+            return ["start", @p.x + options[:left]] if options[:left]
+
+            width = @p.width - options.fetch(:shrink, 0)
+            ["middle", @p.x + options.fetch(:shift, 0) + (width / 2)]
+          end
+
+          def middle(options)
+            @p.y + ((@p.height - Metrics.text_height(lines)) / 2) +
+              options.fetch(:dy, 0)
+          end
+
+          # A container is open: only a colour of its own fills it, so what it
+          # holds shows through.
+          def container_fill
+            @p.node.container? ? "none" : FILL
+          end
+
+          def container
+            outline = Figures.container(@p.node.kind) || Figures::BOX
+            outline.each { |type, *args| send(:"draw_#{type}", *args) }
+            decorate
+            lines.each_with_index { |line, index| header(line, index) }
+          end
+
+          def decorate
+            draw_tab if tabbed?
+            draw_icon if @p.node.kind == :component
+          end
+
+          def tabbed?
+            Figures::TABBED.include?(@p.node.kind)
+          end
+
+          # A component container carries the glyph of a component too.
+          def draw_icon
+            @icon = true
+            Figures::COMPONENT.drop(1).each do |type, *args|
+              send(:"draw_#{type}", *args)
+            end
+          end
+
+          def draw_tab
+            points = Tab.points(@p.x, @p.y, tab_text_width, @p.node.kind)
+            add(Svg::Polygon, points: points, fill: FILL, **line)
+          end
+
+          def tab_text_width
+            TextMeasurement.measure_in(:dejavu_bold, lines.first.to_s,
+                                       font_size: Metrics::FONT_SIZE)[:width]
+          end
+
+          # A header clears the cap of a cylinder, the bumps of a cloud and
+          # the slanted top of a node.
+          HEADER_DROP = { database: 10, cloud: 12, node: 8 }.freeze
+          HEADER_LEFT = { cloud: 24 }.freeze
+          private_constant :HEADER_DROP, :HEADER_LEFT
+
+          def header(line, index)
+            return tab_text(line) if tabbed? && index.zero?
+
+            weight = index.zero? ? "bold" : nil
+            return centred_title(line, index, weight) if centred?
+
+            text(@p.x + 12 + HEADER_LEFT.fetch(@p.node.kind, 0),
+                 header_top(index), line, "start", weight)
+          end
+
+          # A component container names itself in the middle of its top.
+          def centred? = @p.node.kind == :component
+
+          def centred_title(line, index, weight)
+            text(@p.x + (@p.width / 2), header_top(index), line, "middle",
+                 weight)
+          end
+
+          def header_top(index)
+            @p.y + 13 + Metrics::ASCENT + HEADER_DROP.fetch(@p.node.kind, 0) +
+              (index * Metrics::LINE_HEIGHT)
+          end
+
+          def tab_text(line)
+            top = @p.y + Tab.baseline(@p.node.kind)
+            text(@p.x + Tab.indent(@p.node.kind), top, line, "start", "bold")
+          end
+
+          def text(x_pos, y_pos, content, anchor, weight = nil)
+            add(Svg::Text, x: x_pos, y: y_pos, content: content,
+                           text_anchor: anchor, font_family: FONT,
+                           font_size: Metrics::FONT_SIZE.to_s,
+                           font_weight: weight, fill: "#000000")
+            Creole.assign(@out.last, content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/node_graph/skipped_ranks.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # A point a link across several ranks passes through in a rank it
+        # skips, as the JAR's virtual node for it. It has no size: it only
+        # keeps the link's place in the order of the rank.
+        Waypoint = Class.new
+
+        # Gives each link that skips ranks a {Waypoint} in every rank it
+        # skips, and the shorter links of the chain they make.
+        class SkippedRanks
+          # @return [Hash{Array => Array<Waypoint>}] for each `[from, to]`
+          #   that spans more than one rank, its waypoints from the rank
+          #   after `from`
+          attr_reader :chains
+
+          # @return [Array<Array>] the links the order of the ranks is
+          #   settled by, each `[from, to, step]`
+          attr_reader :links
+
+          # @param layers [Array<Array<Object>>] the items of each rank, which
+          #   gain the waypoints
+          # @param rank [Hash{Object => Integer}]
+          # @param pairs [Array<Array>] every link, `[from, to, step]`
+          # @param kept [Array<Array>] the links that close no cycle
+          def initialize(layers, rank, pairs, kept)
+            @layers = layers
+            @rank = rank
+            @kept = kept
+            @chains = {}
+            @links = pairs.flat_map { |pair| chained(pair) }
+          end
+
+          private
+
+          def chained(pair)
+            from, to, = pair
+            span = @rank[to] - @rank[from]
+            return [pair] unless span > 1 && kept?(pair)
+
+            points = @chains[[from, to]] = waypoints(from, span - 1)
+            [from, *points, to].each_cons(2).map { |a, b| [a, b, 1] }
+          end
+
+          def kept?(pair)
+            @kept.any? { |link| link.equal?(pair) }
+          end
+
+          def waypoints(from, count)
+            Array.new(count) { Waypoint.new }.each_with_index do |point, at|
+              @layers[@rank[from] + 1 + at] << point
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/node_graph/tab.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The tab over the top left of a package, folder or frame, which
+        # holds the first line of its name.
+        module Tab
+          HEIGHT = 20.0
+          # A package's and a folder's tab is a line taller than a frame's.
+          LEANING_HEIGHT = 22.49
+          SLANT = 7.0
+          CHAMFER = 10.0
+          # Space left and right of the name inside the tab, as the JAR sets
+          # it: a frame's is wider on the right, where its corner is cut.
+          PADS = { frame: [3.0, 7.0] }.freeze
+          DEFAULT_PADS = [4.0, 2.0].freeze
+          private_constant :PADS, :DEFAULT_PADS
+
+          module_function
+
+          # @param left [Float] the container's left edge
+          # @param top [Float] the container's top edge
+          # @param width [Float] the width of the name
+          # @param kind [Symbol] a frame's tab has its lower right corner cut;
+          #   a package's and a folder's lean out along their right edge
+          # @return [String] the points of the tab's outline
+          def points(left, top, width, kind = :package)
+            right = left + pads(kind).sum + width
+            outline = if kind == :frame
+                        chamfered(right,
+                                  top)
+                      else
+                        leaning(right, top)
+                      end
+            [[left, top], [right, top], *outline, [left, top + height(kind)]]
+              .map { |point| point.join(",") }.join(" ")
+          end
+
+          # @return [Float] how far right of the tab's edge the name starts
+          def indent(kind) = pads(kind).first
+
+          # @return [Float] how tall the tab of a container of `kind` is
+          def height(kind)
+            kind == :frame ? HEIGHT : LEANING_HEIGHT
+          end
+
+          # @return [Float] how far below the tab's top the name sits
+          def baseline(kind)
+            kind == :frame ? 14.5 : 15.5
+          end
+
+          def pads(kind) = PADS.fetch(kind, DEFAULT_PADS)
+
+          def leaning(right, top)
+            [[right + SLANT, top + LEANING_HEIGHT]]
+          end
+
+          def chamfered(right, top)
+            [[right, top + HEIGHT - CHAMFER], [right - CHAMFER, top + HEIGHT]]
+          end
+          private_class_method :pads, :leaning, :chamfered
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/node_graph/usecase_ellipse.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The ellipse of a use case, as the PlantUML JAR sizes it: the
+        # smallest ellipse of a fixed proportion that holds every line of
+        # the label (each a box of its own width, centred), grown by
+        # {GROWTH} all round.
+        module UsecaseEllipse
+          GROWTH = 3.0
+          LEAST_PROPORTION = 0.2
+          MOST_PROPORTION = 0.8
+          TOLERANCE = 1e-9
+
+          module_function
+
+          # @param widths [Array<Float>] the width of each label line
+          # @param line_height [Float]
+          # @return [Array(Float, Float)] the width and height of the ellipse
+          def size(widths, line_height)
+            proportion = proportion(widths.max, widths.size * line_height)
+            radius = enclosing_radius(corners(widths, line_height, proportion))
+            [2 * (radius + GROWTH), 2 * ((proportion * radius) + GROWTH)]
+          end
+
+          # The height of the label over its width, kept within bounds.
+          def proportion(width, height)
+            (height / width).clamp(LEAST_PROPORTION, MOST_PROPORTION)
+          end
+
+          # The corners of each line's box, stretched so the ellipse reads
+          # as a circle.
+          def corners(widths, line_height, proportion)
+            widths.each_with_index.flat_map do |width, index|
+              [index, index + 1].product([-width / 2, width / 2])
+                .map { |row, x| [x, row * line_height / proportion] }
+            end
+          end
+
+          # The radius of the smallest circle holding every point.
+          def enclosing_radius(points)
+            circle = nil
+            points.each_with_index do |point, index|
+              next if circle && holds?(circle, point)
+
+              circle = around(points.first(index), point)
+            end
+            circle.last
+          end
+
+          def around(earlier, point)
+            circle = [point, 0.0]
+            earlier.each_with_index do |other, index|
+              next if holds?(circle, other)
+
+              circle = across(earlier.first(index), point, other)
+            end
+            circle
+          end
+
+          def across(earlier, point, other)
+            circle = diameter(point, other)
+            earlier.each do |third|
+              circle = through(point, other, third) unless holds?(circle, third)
+            end
+            circle
+          end
+
+          def holds?(circle, point)
+            center, radius = circle
+            distance(point, center) <= radius + TOLERANCE
+          end
+
+          def diameter(one, other)
+            center = one.zip(other).map { |pair| pair.sum / 2.0 }
+            [center, distance(one, center)]
+          end
+
+          def distance(one, other)
+            Math.hypot(one[0] - other[0], one[1] - other[1])
+          end
+
+          # The circle through three points, found about the first.
+          def through(one, two, three)
+            origin = Complex(*one)
+            u = centre_from(Complex(*two) - origin, Complex(*three) - origin)
+            [[origin.real + u.real, origin.imag + u.imag], u.abs]
+          end
+
+          def centre_from(first, second)
+            d = 2.0 * (first.conj * second).imag
+            Complex(0, -1) * ((second * first.abs2) - (first * second.abs2)) / d
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/node_graph.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "node_graph/parser"
+require_relative "node_graph/layout"
+require_relative "node_graph/renderer"
+
+module Etassia
+  module Notation
+    module PlantUML
+      # The node-and-link model use case and component diagrams share: a
+      # parser, a ranked layout and a renderer. {Usecase} and {Component}
+      # decide which source they claim.
+      module NodeGraph
+        # Lines another family owns; a source with one is never claimed.
+        FOREIGN = /\A(?:participant|class|abstract|enum|boundary|control|
+                   entity|collections|queue|autonumber|newpage|alt|loop|opt|
+                   par|critical|break|ref|fork|partition|
+                   repeat|while|switch|if)\b|;\z|\A\(\*|\Astate\b|
+                   \A(?:start|stop)\z/xi
+
+        module_function
+
+        # @return [Array<String>] the stripped lines of the first diagram
+        def lines_of(source)
+          Reader.entries(source).map(&:first)
+        end
+
+        # @return [Notation::Parsed]
+        def parsed(source, type:, direction:, default_kind:)
+          graph = Parser.new(direction: direction, default_kind: default_kind)
+            .parse(source)
+          Notation::Parsed.new(type: type, diagram: graph, transform: Layout,
+                               renderer: Renderer)
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/note.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      # A note attached to a class: `side` is :left, :right, :top or
+      # :bottom; `member` is the name after `::` or nil; `color` is the
+      # `#name` or `#hex` written after the target, `stereotype` the
+      # `<<name>>`; `lines` is the note text, one entry per source line.
+      class Note
+        attr_reader :side, :target, :member, :color, :stereotype, :lines
+
+        # @param head [Hash] `:side`, `:target`, `:member`, `:color` and
+        #   `:stereotype`, all required
+        def initialize(head, lines:)
+          @side = head.fetch(:side)
+          @target = head.fetch(:target)
+          @member = head.fetch(:member)
+          @color = head.fetch(:color)
+          @stereotype = head.fetch(:stereotype)
+          @lines = lines
+          freeze
+        end
+      end
+    end
+  end
+end