etassia 0.1.0

data/lib/etassia/notation/plantuml/activity/legacy_row_gaps.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # The space above each row in the legacy syntax, where PlantUML
+        # ranks every node two half-steps apart. An arrow's label takes the
+        # half-step in the middle of the arrow, and so does a node parked
+        # there; a gap is as tall as the tallest thing in its half-step.
+        class LegacyRowGaps
+          # Two half-step separations.
+          STEP = 40.5
+          private_constant :STEP
+
+          def initialize(diagram, ranking, metrics)
+            @ranking = ranking
+            @metrics = metrics
+            @contents = Array.new(ranking.rank.values.max.to_i + 1) { [0.0] }
+            diagram.edges.each { |edge| label(edge) }
+            diagram.nodes.each { |node| park(node) }
+          end
+
+          # @return [Array<Float>] the space above each row; the first is 0
+          def to_a
+            @contents.each_with_index.map do |own, row|
+              row.zero? ? 0.0 : STEP + own.max
+            end
+          end
+
+          private
+
+          # An arrow that spans an odd number of rows has its label in a
+          # gap; over an even number it falls on a row, which it does not
+          # grow.
+          def label(edge)
+            row = middle_gap(edge)
+            @contents[row] << label_height(edge) if row
+          end
+
+          # @return [Integer, nil] the row a gap lies above
+          def middle_gap(edge)
+            return if @ranking.back?(edge)
+
+            from = @ranking.rank[edge.from]
+            span = @ranking.rank[edge.to] - from
+            from + ((span + 1) / 2) if span.odd?
+          end
+
+          def park(node)
+            return unless @ranking.parked?(node)
+
+            @contents[@ranking.rank[node] + 1] <<
+              @metrics.box_for(node).height
+          end
+
+          def label_height(edge)
+            lines = edge.label.to_s.split("\n")
+            lines.empty? ? 0.0 : @metrics.text_height(lines, role: :arrow)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/activity/mark.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # One thing the renderer draws, in final coordinates.
+        class Mark
+          # @return [Symbol] :rect, :circle, :polygon, :path or :text
+          attr_reader :kind
+          # @return [Hash{Symbol => Object}] the attributes for that kind
+          attr_reader :attrs
+
+          def initialize(kind, **attrs)
+            @kind = kind
+            @attrs = attrs.freeze
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/activity/marks.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "canvas"
+require_relative "edge_marks"
+require_relative "frame_marks"
+require_relative "node_marks"
+require_relative "scene"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # Turns a placed diagram into {Mark}s, back to front: lanes,
+        # partitions, edges, nodes, notes, title.
+        class Marks
+          # @return [Scene]
+          attr_reader :scene
+
+          def initialize(diagram, placement, router, metrics)
+            @diagram = diagram
+            @placement = placement
+            @canvas = Canvas.new(metrics)
+            @frames = FrameMarks.new(diagram, placement, @canvas, metrics)
+            @edges = EdgeMarks.new(router, @canvas, curved: diagram.legacy)
+            @nodes = NodeMarks.new(placement.boxes, @canvas, metrics)
+          end
+
+          # @return [Float] the leftmost x any mark reaches
+          def min_x
+            @canvas.min_x
+          end
+
+          # Fills {#scene}.
+          def build
+            @frames.title
+            @frames.warnings
+            @frames.lanes unless @placement.bands.empty?
+            @frames.partitions
+            @diagram.edges.each { |edge| @edges.draw(edge) }
+            @diagram.nodes.each { |node| @nodes.draw(node) }
+            notes
+            @scene = scene_of(@canvas)
+          end
+
+          private
+
+          def notes
+            @placement.notes.each do |node, pairs|
+              pairs.each { |note, box| @nodes.note(node, note, box) }
+            end
+          end
+
+          def scene_of(canvas)
+            Scene.new(width: canvas.max_x + Layout::MARGIN,
+                      height: canvas.max_y + Layout::MARGIN,
+                      marks: canvas.marks)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/activity/metrics.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "../../../text_measurement"
+require_relative "../creole"
+require_relative "../style"
+require_relative "box"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # Sizes of the shapes, from the text they carry and the font size
+        # the source gives each role (action, diamond, note, arrow,
+        # partition). A larger font grows the box, never overflows it.
+        class Metrics
+          # The action's size; the other roles' own defaults are
+          # ROLE_SIZES, which is what PlantUML draws for an unstyled source.
+          FONT_SIZE = 12
+          ROLE_SIZES = { diamond: 11, arrow: 11, note: 13,
+                         partition: 14 }.freeze
+          # The line pitch and baseline of a font size, as PlantUML's
+          # default face lays them out (14.1328 and 11.6016 at 12).
+          LINE_RATIO = 1.1777
+          ASCENT_RATIO = 0.9668
+          PAD_X = 10.0
+          PAD_Y = 10.0
+          NOTE_PAD = 7.0
+          # A decision is a hexagon: the text's own width and height, at
+          # least this wide and tall, with a point of this reach each side.
+          DECISION_POINT = 12.0
+          DECISION_MIN = 24.0
+          FIXED = { start: [20.0, 20.0], stop: [24.0, 24.0], kill: [24.0, 24.0],
+                    end: [24.0, 24.0],
+                    merge: [24.0, 24.0], bar: [40.0, 6.0] }.freeze
+          # PlantUML draws a legacy bar at this size however many branches
+          # it joins.
+          LEGACY_BAR = [80.0, 8.0].freeze
+
+          # Skinparam names PlantUML reads for a role, besides the role.
+          SKIN_ALIASES = { diamond: :activitydiamond,
+                           arrow: :activityarrow }.freeze
+          private_constant :SKIN_ALIASES
+
+          # @param style [Style::Sheet]
+          def initialize(style = Style::Sheet.new)
+            @style = style
+          end
+
+          # PlantUML cascades `activityDiagram` down to every role from
+          # `<style>` only; skinparam `activityFontSize` is the action's
+          # and the decision's.
+          #
+          # @param role [Symbol, nil] :diamond, :note, :arrow, :partition;
+          #   nil is an action
+          # @return [Numeric] the font size of the role's text
+          def size(role = nil)
+            written = role ? role_size(role) : activity_size
+            return ROLE_SIZES.fetch(role, FONT_SIZE) unless written
+
+            written.to_i == written ? written.to_i : written
+          end
+
+          # @return [Float] the distance between the baselines of two lines
+          def line_height(role = nil)
+            LINE_RATIO * size(role)
+          end
+
+          # @return [Float] the baseline of a line below the top of its row
+          def ascent(role = nil)
+            ASCENT_RATIO * size(role)
+          end
+
+          # @return [Float] the width of the widest of the lines
+          def text_width(lines, role: nil, size: size(role))
+            face = face(role)
+            lines.map { |line| line_width(line, face, size) }.max.to_f
+          end
+
+          def line_width(line, face, size)
+            Creole.parse(line).sum do |run|
+              if Creole.monospace?(run.style)
+                TextMeasurement.measure(run.text, font_size: size,
+                                                  monospace: true)[:width]
+              else
+                TextMeasurement.measure_in(face, run.text,
+                                           font_size: size)[:width]
+              end
+            end
+          end
+
+          def text_height(lines, role: nil)
+            [lines.size, 1].max * line_height(role)
+          end
+
+          # @param node [Node]
+          # @return [Box] a box of the node's size, not yet placed
+          def box_for(node)
+            return fixed_box(fixed_size(node)) if FIXED.key?(node.kind)
+            return fixed_box(FIXED[:merge]) if node.bare
+            return decision_box(node.lines) if node.kind == :decision
+
+            action_box(node.lines)
+          end
+
+          def fixed_size(node)
+            node.kind == :bar && node.legacy ? LEGACY_BAR : FIXED[node.kind]
+          end
+
+          def action_box(lines)
+            Box.new(width: text_width(lines) + (2 * PAD_X),
+                    height: text_height(lines) + (2 * PAD_Y))
+          end
+
+          def fixed_box(size)
+            Box.new(width: size.first, height: size.last)
+          end
+
+          def decision_box(lines)
+            Box.new(width: [text_width(lines, role: :diamond),
+                            DECISION_MIN].max + (2 * DECISION_POINT),
+                    height: [text_height(lines, role: :diamond),
+                             DECISION_MIN].max)
+          end
+
+          # @return [Box] a note's box
+          def note_box(note)
+            Box.new(width: text_width(note.lines, role: :note) +
+                           (2 * NOTE_PAD) + 6,
+                    height: text_height(note.lines, role: :note) +
+                            (2 * NOTE_PAD))
+          end
+
+          # @return [Symbol] the face the role's text is measured in: the
+          #   source's FontName when etassia has the table for it, else the
+          #   default face
+          def face(role = nil)
+            name = written_face(role).to_s.downcase
+            TextMeasurement::FACE_TABLES.keys.find do |face|
+              name.include?(face.to_s)
+            end || :dejavu
+          end
+
+          private
+
+          def written_face(role)
+            (role && @style.explicit(role, :font_name)) ||
+              @style.explicit(:activity, :font_name)
+          end
+
+          def activity_size
+            @style.explicit(:activity, :font_size)
+          end
+
+          def role_size(role)
+            @style.from_style(role, :font_size) ||
+              @style.from_style(:activity, :font_size) || skin_size(role)
+          end
+
+          def skin_size(role)
+            own = [role, SKIN_ALIASES[role]].compact.filter_map do |name|
+              @style.explicit(name, :font_size)
+            end.first
+            own || (activity_size if role == :diamond)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/activity/new_parser/blocks.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        class NewParser
+          # The statements that open and close a branching construct. Each
+          # keeps a frame on `@frames`; a frame remembers the branches
+          # closed so far, and closing the construct joins them.
+          module Blocks
+            PATTERNS = [
+              [/\A(?<kw>if|elseif)\s*\((?<cond>.*?)\)\s*
+                (?:is\s*\((?<is>.*?)\)\s*)?
+                then\s*(?:\((?<then>.*)\))?\z/xi, :on_if],
+              [/\Aelse\s*(?:\((?<label>.*)\))?\z/i, :on_else],
+              [/\Aend\s*if\z/i, :on_endif],
+              [/\Awhile\s*\((?<cond>.*?)\)\s*(?:is\s*\((?<is>.*?)\))?\z/i,
+               :on_while],
+              [/\Aend\s*while\s*(?:\((?<label>.*)\))?\z/i, :on_endwhile],
+              [/\Arepeat\z/i, :on_repeat],
+              [/\Arepeat\s+while\s*\((?<cond>.*?)\)\s*
+                (?:is\s*\((?<is>.*?)\)\s*)?
+                (?:not\s*\((?<not>.*?)\))?\z/xi, :on_repeat_while],
+              [/\Afork\z/i, :on_fork],
+              [/\Afork\s+again\z/i, :on_fork_again],
+              [/\Aend\s+(?<word>fork|merge)(?:\s*\{.*\})?\z/i, :on_end_fork],
+              [/\Aswitch\s*\((?<cond>.*)\)\z/i, :on_switch],
+              [/\Acase\s*\((?<label>.*)\)\z/i, :on_case],
+              [/\Aend\s*switch\z/i, :on_endswitch],
+            ].freeze
+
+            private
+
+            def on_if(match)
+              label = label_text(match[:then] || match[:is])
+              return elseif(match, label) unless match[:kw].casecmp?("if")
+
+              decision = add(decision_node(match))
+              @frames << { kind: "if", branches: [], decision: decision,
+                           else: false }
+              @ends = [[decision, label]]
+            end
+
+            def elseif(match, label)
+              frame = top("if")
+              frame[:branches].concat(@ends)
+              decision = decision_node(match)
+              @builder.connect(frame[:decision], decision)
+              frame[:decision] = decision
+              @ends = [[decision, label]]
+            end
+
+            def on_else(match)
+              frame = top("if")
+              frame[:branches].concat(@ends)
+              frame[:else] = true
+              @ends = [[frame[:decision], label_text(match[:label])]]
+            end
+
+            def on_endif(_match)
+              frame = pop("if")
+              branches = frame[:branches] + @ends
+              branches << [frame[:decision], nil] unless frame[:else]
+              join(branches, lane: frame[:decision].lane)
+            end
+
+            def on_while(match)
+              decision = add(decision_node(match))
+              @frames << { kind: "while", decision: decision }
+              @ends = [[decision, label_text(match[:is])]]
+            end
+
+            def on_endwhile(match)
+              decision = pop("while")[:decision]
+              @ends.each do |from, label|
+                @builder.connect(from, decision, label: label)
+              end
+              @ends = [[decision, label_text(match[:label])]]
+            end
+
+            def on_repeat(_match)
+              @frames << { kind: "repeat", start: add(@builder.node(:merge)) }
+            end
+
+            def on_repeat_while(match)
+              start = pop("repeat")[:start]
+              decision = add(decision_node(match))
+              @builder.connect(decision, start, label: label_text(match[:is]))
+              @ends = [[decision, label_text(match[:not])]]
+            end
+
+            def on_fork(_match)
+              head = add(@builder.node(:bar))
+              @frames << { kind: "fork", branches: [], head: head }
+            end
+
+            def on_fork_again(_match)
+              frame = top("fork")
+              frame[:branches].concat(@ends)
+              @ends = [[frame[:head], nil]]
+            end
+
+            def on_end_fork(match)
+              frame = pop("fork")
+              kind = match[:word].casecmp?("merge") ? :merge : :bar
+              join(frame[:branches] + @ends, kind: kind)
+            end
+
+            def on_switch(match)
+              decision = add(decision_node(match))
+              @frames << { kind: "switch", decision: decision, branches: [] }
+              @ends = []
+            end
+
+            def on_case(match)
+              frame = top("switch")
+              frame[:branches].concat(@ends)
+              @ends = [[frame[:decision], label_text(match[:label])]]
+            end
+
+            def on_endswitch(_match)
+              frame = pop("switch")
+              join(frame[:branches] + @ends, lane: frame[:decision].lane)
+            end
+
+            def decision_node(match)
+              @builder.node(:decision, text: clean(match[:cond]))
+            end
+
+            # Closes a branching construct: many open ends become one
+            # merge node, one stays as it is, none means the flow ended. The
+            # diamond stays in the swimlane of the decision it closes, as
+            # PlantUML draws it, whichever lane the branches ended in.
+            def join(branches, kind: :merge, lane: nil)
+              return @ends = branches if branches.size < 2
+
+              merge = @builder.node(kind)
+              merge.lane = lane if lane
+              branches.each do |from, label|
+                @builder.connect(from, merge, label: label)
+              end
+              @ends = [[merge, nil]]
+            end
+
+            def label_text(text)
+              text.nil? || text.strip.empty? ? nil : clean(text)
+            end
+
+            def top(kind)
+              frame = @frames.last
+              return frame if frame && frame[:kind] == kind
+
+              refuse("#{@line.split.first} outside #{kind}", @line)
+            end
+
+            def pop(kind)
+              top(kind)
+              @frames.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/activity/new_parser.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "builder"
+require_relative "text"
+require_relative "arrow_style"
+require_relative "new_parser/blocks"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module Activity
+        # Reads the new activity syntax: `start`, `:action;`, `if` ...
+        # `endif`, `while`, `repeat`, `switch`, `fork`, partitions, swimlanes
+        # and notes. The open ends of the flow are kept in `@ends` as
+        # [node, label] pairs; a `stop` leaves none.
+        class NewParser
+          include Blocks
+
+          SIMPLE = [
+            [/\Astart\z/i, :on_start],
+            [/\Astop\z/i, :on_stop],
+            [/\Aend\z/i, :on_end],
+            [/\Akill\z/i, :on_kill],
+            [/\Atitle\s+(.+)\z/i, :on_title],
+            [/\A(?<colour>#\w+)?:(?<text>.*)\z/m, :on_action],
+            [/\A-+(?:\[(?<spec>[^\]]*)\])?-*>\s*(?<text>.*)\z/m, :on_arrow],
+            [/\A\|(?:(?<colour>#\w+)\|)?(?<name>[^|]+)\|\z/, :on_lane],
+            [/\Anote\s+(?<side>left|right)\s*(?:of\s+\S+\s*)?
+             (?::(?<text>.*))?\z/xi, :on_note],
+            [/\Apartition\s+(?<name>.*?)\s*\{\z/i, :on_partition],
+            [/\A\}\z/, :on_close_partition],
+          ].freeze
+          STATEMENTS = (SIMPLE + Blocks::PATTERNS).freeze
+          private_constant :SIMPLE, :STATEMENTS
+
+          # @param entries [Array<Array(String, Integer)>] lines and numbers
+          # @return [Diagram]
+          def parse(entries)
+            @builder = Builder.new
+            @ends = []
+            @frames = []
+            @arrow = {}
+            @entries = entries.each
+            loop { statement(*@entries.next) }
+            refuse("unclosed #{@frames.last[:kind]}", @line) if @frames.any?
+            @builder.diagram
+          end
+
+          private
+
+          def statement(line, number)
+            @line = line
+            @number = number
+            STATEMENTS.each do |pattern, handler|
+              match = pattern.match(line)
+              return send(handler, match) if match
+            end
+            refuse("statement", line)
+          end
+
+          def on_start(_match)
+            add(@builder.node(:start))
+          end
+
+          def on_stop(_match)
+            add(@builder.node(:stop))
+            @ends = []
+          end
+
+          # `end` ends the flow at a crossed circle.
+          def on_end(_match)
+            add(@builder.node(:end))
+            @ends = []
+          end
+
+          # `kill` ends the flow at a cross, as `stop` ends it at a circle.
+          def on_kill(_match)
+            add(@builder.node(:kill))
+            @ends = []
+          end
+
+          def on_title(match)
+            @builder.title = clean(match[1])
+          end
+
+          def on_action(match)
+            text = clean(collect(match[:text]))
+            deprecate_colour(match[:colour]) if match[:colour]
+            add(@builder.node(:action, text: text))
+          end
+
+          # PlantUML draws no colour from the old `#colour:` prefix; it
+          # prints a notice that names the suffix to use instead.
+          def deprecate_colour(colour)
+            @builder.warn("This syntax is deprecated, you must add " \
+                          "<<#{colour}>> at the end of the line, after " \
+                          "the ';'")
+          end
+
+          def on_arrow(match)
+            @arrow = ArrowStyle.parse(match[:spec], line: @number)
+            text = match[:text]
+            @arrow[:label] = text.empty? ? nil : clean(collect(text))
+          end
+
+          def on_lane(match)
+            colour = match[:colour] && ArrowStyle.colour(match[:colour])
+            @builder.lane(match[:name].strip, colour)
+          end
+
+          def on_note(match)
+            text = match[:text] ? match[:text].strip : collect_note
+            node = @builder.nodes.last
+            refuse("note without a preceding activity", @line) unless node
+            node.notes << Note.new(side: match[:side].downcase.to_sym,
+                                   text: clean(text))
+          end
+
+          def on_partition(match)
+            title = match[:name].gsub(/#\w+/, "").delete('"').strip
+            @builder.partition(title, line: @number, text: @line)
+          end
+
+          def on_close_partition(_match)
+            @builder.partition(nil)
+          end
+
+          # Text that runs to the next line ending in `;`.
+          def collect(first)
+            text = first.dup
+            text << "\n" << next_line until text.end_with?(";")
+            text.chomp(";")
+          end
+
+          def collect_note
+            lines = []
+            while (line = next_line) && !line.match?(/\Aend\s*note\z/i)
+              lines << line
+            end
+            lines.join("\n")
+          end
+
+          def next_line
+            @entries.next.first
+          rescue StopIteration
+            refuse("unterminated activity (missing `;`)", @line)
+          end
+
+          # Joins every open end to the new node, then makes it the only
+          # open end.
+          def add(node)
+            @ends.each do |from, label|
+              @builder.connect(from, node, **edge_options(label))
+            end
+            @arrow = {}
+            @ends = [[node, nil]]
+            node
+          end
+
+          def edge_options(label)
+            { label: @arrow[:label] || label, colour: @arrow[:colour],
+              style: @arrow[:style] }
+          end
+
+          def clean(text)
+            Text.clean(text, line: @number)
+          end
+
+          def refuse(construct, text)
+            raise UnsupportedConstructError.new(construct: construct,
+                                                line: @number, text: text)
+          end
+        end
+      end
+    end
+  end
+end