etassia 0.1.0

data/lib/etassia/notation/plantuml/network/placement.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Network
+        # Where each node sits: the network it first appears in (its box
+        # hangs just below that bar), the last one it reaches, and a column
+        # no other node uses in the same stretch.
+        class Placement
+          Span = Struct.new(:name, :entry, :exit, :column,
+                            keyword_init: true) do
+            # The gaps between bars the node's box and line pass through.
+            def gaps
+              (entry..[exit - 1, entry].max).to_a
+            end
+          end
+
+          # @param diagram [Diagram]
+          def initialize(diagram)
+            @spans = spans_of(diagram).each_with_object([]) do |span, placed|
+              span.column = free_column(placed, span)
+              placed << span
+            end
+            @by_name = @spans.to_h { |span| [span.name, span] }
+          end
+
+          # @return [Array<Span>] in order of first appearance
+          attr_reader :spans
+
+          # @return [Span]
+          def [](name)
+            @by_name.fetch(name)
+          end
+
+          # @return [Integer]
+          def columns
+            (@spans.map(&:column).max || -1) + 1
+          end
+
+          private
+
+          def spans_of(diagram)
+            rows = {}
+            diagram.networks.each_with_index do |network, index|
+              network.nodes.each do |member|
+                span = (rows[member.name] ||= Span.new(
+                  name: member.name, entry: index, exit: index,
+                ))
+                span.exit = index
+              end
+            end
+            rows.values
+          end
+
+          def free_column(placed, span)
+            taken = placed.select { |other| other.gaps.intersect?(span.gaps) }
+            (0..).find { |column| taken.none? { |t| t.column == column } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/network/reader.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "../state/reader"
+require_relative "../unsupported_construct_error"
+require_relative "../../../error/parse_error"
+require_relative "model"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Network
+        # Reads an `nwdiag { ... }` block: networks, the nodes each holds with
+        # their attributes, and groups. A node's shape is the first one given
+        # for it. A line outside this subset raises
+        # {UnsupportedConstructError}.
+        class Reader
+          NAME = /[A-Za-z_][\w.-]*/
+          RULES = [
+            [/\Anwdiag\s*\{\z/, :open_diagram],
+            [/\Anetwork\s+(#{NAME})\s*\{\z/o, :open_network],
+            [/\Agroup\s*(#{NAME})?\s*\{\z/o, :open_group],
+            [/\A\}\z/, :close],
+            [/\A(address|color|description)\s*=\s*(.+?);?\z/, :setting],
+            [/\A(#{NAME})\s*(?:\[(.*)\])?\s*;?\z/o, :node],
+          ].freeze
+          ATTRIBUTE = /(\w+)\s*=\s*("[^"]*"|[^,\]]+)/
+          private_constant :NAME, :RULES, :ATTRIBUTE
+
+          # @param source [String] PlantUML source
+          # @return [Diagram]
+          # @raise [UnsupportedConstructError] on a line outside the subset
+          # @raise [Etassia::Parser::ParseError] when a `{` is never closed
+          def parse(source)
+            @diagram = Diagram.new(networks: [], shapes: {})
+            @scopes = []
+            State::Reader.lines_of(source).each { |line| read(*line) }
+            raise unclosed unless @scopes.empty?
+
+            @diagram
+          end
+
+          private
+
+          def read(text, number)
+            text = text.sub(%r{\s*//.*\z}, "")
+            return if text.empty?
+
+            RULES.each do |pattern, handler|
+              match = pattern.match(text)
+              return send(handler, *match.captures) if match
+            end
+            raise unsupported(text, number)
+          end
+
+          def open_diagram
+            @scopes.push(@diagram)
+          end
+
+          def open_network(name)
+            network = Network.new(name: name, nodes: [], groups: [])
+            @diagram.networks << network
+            @scopes.push(network)
+          end
+
+          def open_group(name)
+            group = Group.new(name: name, names: [])
+            network.groups << group
+            @scopes.push(group)
+          end
+
+          def close
+            @scopes.pop
+          end
+
+          def network
+            @scopes.reverse.find { |scope| scope.is_a?(Network) } ||
+              raise(unsupported("group outside a network", 0))
+          end
+
+          def setting(key, value)
+            scope = @scopes.last
+            return unless scope.respond_to?(:"#{key}=")
+
+            scope.public_send(:"#{key}=", unquote(value))
+          end
+
+          def node(name, attributes)
+            return unless @scopes.last.is_a?(Network) ||
+              @scopes.last.is_a?(Group)
+
+            fields = attributes ? attribute_hash(attributes) : {}
+            @diagram.shapes[name] ||= fields["shape"] || "box"
+            join(name, fields["address"])
+          end
+
+          def join(name, address)
+            group = @scopes.last
+            group.names << name if group.is_a?(Group)
+            return if network.nodes.any? { |m| m.name == name }
+
+            network.nodes << Member.new(name: name, address: address)
+          end
+
+          def attribute_hash(text)
+            text.scan(ATTRIBUTE).to_h do |key, value|
+              [key, unquote(value.strip)]
+            end
+          end
+
+          def unquote(value)
+            value.strip.delete_prefix('"').delete_suffix('"')
+          end
+
+          def unsupported(text, number)
+            UnsupportedConstructError.new(construct: "nwdiag statement",
+                                          line: number, text: text)
+          end
+
+          def unclosed
+            Etassia::Parser::ParseError.new("nwdiag block is never closed")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Network
+        # How a node's `shape` is sized and drawn into a pen, as the JAR
+        # draws it.
+        module Shapes
+          PAPER = "#F1F1F1"
+          HEIGHT = 34.1328
+          # The slant of a cube's side, and the rim a cylinder's lid adds.
+          DEPTH = 10.0
+          LID = 10.0
+          PAD = 10.0
+          CYLINDER_EXTRA = 9.0
+          # Where the name's baseline sits below the top of its flat face.
+          DROP = 21.6
+          private_constant :PAPER, :DEPTH, :LID, :PAD, :DROP, :CYLINDER_EXTRA
+
+          module_function
+
+          # @param text [Float] the name's width
+          # @return [Array(Float, Float)] the shape's width and height
+          def size(shape, text)
+            case shape
+            when "database" then [text + (2 * PAD), HEIGHT + CYLINDER_EXTRA]
+            when "node" then [text + (4 * PAD), HEIGHT + DEPTH]
+            else [text + (2 * PAD), HEIGHT]
+            end
+          end
+
+          # @param pen [Drawing::Pen]
+          # @param box [Drawing::Box]
+          def draw(pen, shape, box)
+            case shape
+            when "database" then database(pen, box)
+            when "node" then cube(pen, box)
+            else pen.rect(box.left, box.top, box.width, box.height,
+                          fill: PAPER, stroke_width: "0.5")
+            end
+          end
+
+          # @return [Float] the baseline of the name
+          def baseline(shape, box)
+            case shape
+            when "database" then box.top + DROP + LID + 4.0
+            when "node" then box.top + DEPTH + DROP
+            else box.top + DROP
+            end
+          end
+
+          # @return [Float] the middle of the name's x
+          def label_x(shape, box)
+            shape == "node" ? box.left + ((box.width - DEPTH) / 2) : box.centre
+          end
+
+          def cube(pen, box)
+            face = box.right - DEPTH
+            level = box.top + DEPTH
+            pen.polygon(outline(box, face, level), fill: PAPER,
+                                                   stroke_width: "0.5")
+            pen.path([[:move, face, level], [:line, box.right, box.top]],
+                     stroke_width: "0.5")
+            pen.path([[:move, box.left, level], [:line, face, level],
+                      [:line, face, box.bottom]], stroke_width: "0.5")
+          end
+
+          def outline(box, face, level)
+            [[box.left, level], [box.left + DEPTH, box.top],
+             [box.right, box.top], [box.right, box.bottom - DEPTH],
+             [face, box.bottom], [box.left, box.bottom]]
+          end
+
+          # A cylinder: a body whose foot bulges and a lid's front edge.
+          def database(pen, box)
+            pen.path(body(box), fill: PAPER, stroke_width: "0.5")
+            pen.path(lid(box), stroke_width: "0.5")
+          end
+
+          def lid(box)
+            rim = box.top + LID
+            [[:move, box.left, rim],
+             [:curve, box.left, rim + LID, box.centre, rim + LID],
+             [:curve, box.right, rim + LID, box.right, rim]]
+          end
+
+          def body(box)
+            rim = box.top + LID
+            foot = box.bottom - LID
+            cap(box, rim) + [[:line, box.right, foot]] + base(box, foot) +
+              [[:close]]
+          end
+
+          def cap(box, rim)
+            [[:move, box.left, rim],
+             [:curve, box.left, box.top, box.centre, box.top],
+             [:curve, box.right, box.top, box.right, rim]]
+          end
+
+          def base(box, foot)
+            [[:curve, box.right, box.bottom, box.centre, box.bottom],
+             [:curve, box.left, box.bottom, box.left, foot]]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "network/reader"
+require_relative "network/layout"
+require_relative "drawing"
+
+module Etassia
+  module Notation
+    module PlantUML
+      # The PlantUML network diagram (`nwdiag`): networks as horizontal bars
+      # with the nodes that belong to them hanging below. PlantUML wants
+      # `@startnwdiag`; the same block inside `@startuml` is read too.
+      module Network
+        extend self
+
+        OPENER = /^[ \t]*nwdiag[ \t]*\{/
+        STARTER = /\A(?:\xEF\xBB\xBF)?(?:[ \t]*(?:'[^\n]*)?\r?\n)*
+                   [ \t]*@startnwdiag/xn
+        private_constant :OPENER, :STARTER
+
+        # @return [Boolean] whether the source holds an `nwdiag` block
+        def network?(source)
+          source.b.match?(STARTER) ||
+            source.dup.force_encoding(Encoding::UTF_8).scrub.match?(OPENER)
+        end
+
+        # @return [Notation::Parsed]
+        def parse(source)
+          Notation::Parsed.new(
+            type: :network_diagram, diagram: Reader.new.parse(source),
+            transform: Layout, renderer: Drawing::Renderer
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # `archimate #Layer "Name" as id <<archimate-type>>`. The layer name
+        # is a colour in PlantUML, filled as the JAR 1.2026.6 fills it. Only
+        # the technology device's icon is drawn; any other element is a
+        # plain box carrying its label.
+        module Archimate
+          LAYERS = {
+            "business" => "#FFFFCC", "application" => "#C2F0FF",
+            "technology" => "#C9FFC9", "physical" => "#97FF97",
+            "motivation" => "#CCCCFF", "strategy" => "#F8E7C0",
+            "implementation" => "#FFE0E0", "migration" => "#FFE0E0",
+            "other" => "#FFFFFF"
+          }.freeze
+
+          # The device icon in its own coordinates, 17 wide and 14 tall,
+          # as PlantUML draws it for `<<technology-device>>`.
+          DEVICE = "M0.59,0 A0.5,0.5 0 0 0 0.09,0.5 L0,10.42 A0.5,0.5 0 0 0 " \
+                   "0.5,10.92 L3.54,10.92 L1.28,13.05 A0.5,0.5 0 0 0 1.62," \
+                   "13.91 L15.56,13.96 A0.5,0.5 0 0 0 15.94,13.13 L14,10.92 " \
+                   "L16.68,10.92 A0.5,0.5 0 0 0 17.18,10.42 L17.14,0.5 A0.5," \
+                   "0.5 0 0 0 16.64,0 M1.09,1 L16.14,1 L16.18,9.92 L1,9.92 " \
+                   "M4.47,11.42 L13.11,11.42 L14.46,12.95 L2.88,12.91"
+          SPRITES = { "technology-device" => DEVICE }.freeze
+          SPRITE_ROOM = 20.0
+
+          module_function
+
+          # @param stereotype [String, nil] the `<<archimate-type>>` text
+          # @return [String, nil] the path of the type's icon, when drawn
+          def sprite(stereotype)
+            SPRITES[stereotype.to_s.strip.downcase]
+          end
+
+          # @param color [String, nil] a layer name or an ordinary colour
+          # @return [String, nil] the colour the layer stands for, else
+          #   `color` itself
+          def color(color)
+            LAYERS.fetch(color.to_s.downcase, color)&.delete_prefix("#")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../objects/map_rows"
+require_relative "../../plantuml_data/boxes/table"
+require_relative "link"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # What the node parser needs for a `map` or `object` element mixed
+        # into a use case, component or deployment diagram after
+        # `allowmixing`. The element is drawn as the box an object diagram
+        # draws, and a link may start or end at one of its rows
+        # (`Element::key`).
+        module BoxReader
+          Boxes = PlantUMLData::Boxes
+          NAME = /(?:"(?<label>[^"]+)"\s+as\s+)?(?<id>\w[\w.]*)/
+          MAP_OPEN = /\Amap\s+#{NAME}\s*\{\z/
+          OBJECT_OPEN = /\Aobject\s+#{NAME}(?:\s*(?<open>\{))?\z/
+          FIELD = /\A[[:alpha:]_][[:alnum:]_]*/
+
+          private
+
+          def take_map(text)
+            return unless (match = text.match(MAP_OPEN))
+
+            rows, links = Objects::MapRows.call(body_lines)
+            node = box_node(match, :map, rows)
+            links.each { |link| row_edge(node, *link) }
+            node
+          end
+
+          def take_object(text)
+            return unless (match = text.match(OBJECT_OPEN))
+
+            rows = match[:open] ? body_lines.map { |line| box_row(line) } : []
+            box_node(match, :object, rows)
+          end
+
+          def box_row(line)
+            Boxes::Row.new(value: line, port: line[FIELD])
+          end
+
+          def body_lines
+            lines = []
+            while (entry = @entries[@index])
+              @index += 1
+              return lines if entry.first == "}"
+
+              lines << entry.first
+            end
+            raise Etassia::Parser::ParseError,
+                  "Parse error: unclosed { at line #{@number}"
+          end
+
+          def box_node(match, kind, rows)
+            title = match[:label] || match[:id]
+            data_node(match[:id], match[:label],
+                      Boxes::Table.new(id: match[:id], title: title, rows: rows,
+                                       kind: kind))
+          end
+
+          # The edge a `key *-> target` row of `node` stands for.
+          def row_edge(node, key, arrow, target)
+            name, port = target.split("::")
+            to = resolve(name)
+            @graph.edges << Link.new(arrow).edge(
+              node, to, from_row: row_index(node, key),
+                        to_row: row_index(to, port)
+            )
+          end
+
+          # @return [Integer, nil] the row of a map or object box that
+          #   `port` names; any other box has no rows to end a line at
+          def row_index(node, port)
+            table = node.table
+            return unless port && %i[map object].include?(table&.kind)
+
+            table.rows.index { |row| row.port == port }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The outline of a cloud as PlantUML draws it: the box's rectangle
+        # with its corners cut, every side a run of small outward bumps.
+        class Cloud
+          BUMP = 11.0
+          PUSH = 8.0
+          RISE = 4.0
+          CUT = 9.0
+
+          # @param box [Placed]
+          def initialize(box)
+            @left = box.x + RISE
+            @top = box.y + RISE
+            @right = box.x + box.width - RISE
+            @bottom = box.y + box.height - RISE
+          end
+
+          # @return [String] SVG path data
+          def to_d
+            "M#{coords(corners.first)} #{sides.join(' ')} Z"
+          end
+
+          private
+
+          def corners
+            [[@left + CUT, @top], [@right - CUT, @top], [@right, @top + CUT],
+             [@right, @bottom - CUT], [@right - CUT, @bottom],
+             [@left + CUT, @bottom], [@left, @bottom - CUT],
+             [@left, @top + CUT]]
+          end
+
+          def sides
+            corners.zip(corners.rotate).map { |from, to| side(from, to) }
+          end
+
+          # Bumps along one side, each a quadratic curve whose control point
+          # lies outside the side.
+          def side(from, to)
+            count = [(Math.hypot(*delta(from, to)) / BUMP).round, 1].max
+            Array.new(count) { |index| bump(from, to, index, count) }.join(" ")
+          end
+
+          def bump(from, to, index, count)
+            control = point(from, to, (index + 0.5) / count, PUSH)
+            stop = point(from, to, (index + 1.0) / count, 0)
+            "Q#{coords(control)} #{coords(stop)}"
+          end
+
+          # The point `along` the side, `push` to the outside of it.
+          def point(from, to, along, push)
+            dx, dy = delta(from, to)
+            unit = push / Math.hypot(dx, dy)
+            [from[0] + (dx * along) + (dy * unit),
+             from[1] + (dy * along) - (dx * unit)]
+          end
+
+          def delta(from, to)
+            [to[0] - from[0], to[1] - from[1]]
+          end
+
+          def coords(point)
+            point.map { |value| value.round(2) }.join(",")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../../../svg"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The cardinality ends of an entity link: `}|` one or many, `}o`
+        # zero or many, `||` exactly one, `|o` zero or one, and the
+        # mirrored forms on the right.
+        module CrowsFoot
+          GLYPHS = { "}|" => %i[many one], "}o" => %i[many zero],
+                     "||" => %i[one one], "|o" => %i[one zero] }.freeze
+          REACH = 10.0
+          SPREAD = 6.0
+          BAR = 5.0
+          RING = 4.0
+
+          module_function
+
+          # @param left [String] the glyph left of the line, e.g. `}|`
+          # @param right [String] the glyph right of it, e.g. `||`
+          # @return [Array<Array<Symbol>>] each end's markers, box outward
+          def parse(left, right)
+            [GLYPHS.fetch(left), GLYPHS.fetch(right.reverse.tr("{", "}"))]
+          end
+
+          # @param markers [Array<Symbol>] one end's markers, box outward
+          # @param tip [Array(Float, Float)] where the line meets the box
+          # @param vec [Array(Float, Float)] unit vector along the line,
+          #   away from the box
+          # @return [Array<Svg::Element>]
+          def draw(markers, tip, vec, color)
+            offset = 0.0
+            markers.flat_map do |marker|
+              shapes = send(marker, tip, vec, offset, color)
+              offset += marker == :many ? REACH + 4 : BAR + 1
+              shapes
+            end
+          end
+
+          def many(tip, vec, offset, color)
+            apex = step(tip, vec, offset + REACH)
+            side = [-vec[1], vec[0]]
+            [-SPREAD, SPREAD].map do |spread|
+              stroke(apex, step(step(tip, vec, offset), side, spread), color)
+            end
+          end
+
+          def one(tip, vec, offset, color)
+            mid = step(tip, vec, offset + BAR)
+            side = [-vec[1], vec[0]]
+            [stroke(step(mid, side, SPREAD), step(mid, side, -SPREAD), color)]
+          end
+
+          def zero(tip, vec, offset, color)
+            cx, cy = step(tip, vec, offset + RING)
+            [Svg::Circle.new.tap do |ring|
+              ring.cx = cx
+              ring.cy = cy
+              ring.r = RING
+              ring.fill = "#FFFFFF"
+              ring.stroke = color
+              ring.stroke_width = "1"
+            end]
+          end
+
+          def stroke(from, to, color)
+            Svg::Line.new.tap do |line|
+              line.x1, line.y1 = from
+              line.x2, line.y2 = to
+              line.stroke = color
+              line.stroke_width = "1"
+            end
+          end
+
+          def step(from, vec, distance)
+            [from[0] + (vec[0] * distance), from[1] + (vec[1] * distance)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module NodeGraph
+        # The path a link is drawn as: a straight line between two points,
+        # a smooth curve through every point when the route bends, as the
+        # PlantUML JAR draws splines.
+        module Curve
+          # A bend closer than this to the point before it would only make
+          # the curve hook.
+          MIN_GAP = 12.0
+
+          extend self
+
+          # @param points [Array<Array(Float, Float)>] a route
+          # @return [String] SVG path data
+          def path(points)
+            route = spaced(points)
+            "M #{write(route.first)} " \
+              "#{route.size < 3 ? "L #{write(route.last)}" : curves(route)}"
+          end
+
+          private
+
+          def curves(route)
+            route.each_cons(2).with_index.map do |(from, to), index|
+              segment(from, to, route[[index - 1, 0].max],
+                      route[[index + 2, route.size - 1].min])
+            end.join(" ")
+          end
+
+          def segment(from, to, before, after)
+            "C #{write(control(from, to, before))} " \
+              "#{write(control(to, from, after))} #{write(to)}"
+          end
+
+          def spaced(points)
+            kept = points[0...-1].each_with_object([]) do |point, found|
+              found << point if found.empty? || far?(found.last, point)
+            end
+            kept.pop if kept.size > 1 && !far?(kept.last, points.last)
+            [*kept, points.last]
+          end
+
+          def far?(from, to)
+            Math.hypot(to[0] - from[0], to[1] - from[1]) >= MIN_GAP
+          end
+
+          # The control point a sixth of the way along the chord between
+          # the neighbours of `anchor`, on the side of `ahead`.
+          def control(anchor, ahead, behind)
+            anchor.zip(ahead, behind).map do |here, forward, back|
+              here + ((forward - back) / 6.0)
+            end
+          end
+
+          def write(point)
+            point.map { |value| value.round(2) }.join(" ")
+          end
+        end
+      end
+    end
+  end
+end