etassia 0.1.0

data/lib/etassia/notation/plantuml/ir_reader/index.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      module IRReader
+        # Looks up the nodes of one graph by role, parent and id.
+        class Index
+          # @param graph [IR::Graph]
+          def initialize(graph)
+            @graph = graph
+            @children = graph.nodes.group_by(&:parent_id)
+            @by_id = graph.nodes.to_h { |node| [node.id, node] }
+          end
+
+          def edges
+            @graph.edges
+          end
+
+          def node(id)
+            @by_id.fetch(id)
+          end
+
+          # @return [Array<IR::Node>] the nodes whose role is one of `roles`,
+          #   in graph order
+          def with_role(*roles)
+            @graph.nodes.select { |node| roles.include?(node.role) }
+          end
+
+          # @return [Array<String>] the labels of `parent`'s `role` children
+          def details(parent, role)
+            children(parent, role).map(&:label)
+          end
+
+          # @return [String, nil] the label of the first such child
+          def detail(parent, role)
+            details(parent, role).first
+          end
+
+          def children(parent, *roles)
+            @children.fetch(parent.id, []).select do |node|
+              roles.include?(node.role)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/ir_reader/links.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "../junction"
+require_relative "../note"
+require_relative "../relation"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module IRReader
+        # Rebuilds the relations, association classes and notes from the
+        # edges between class nodes.
+        module Links
+          NON_RELATION_ROLES = %w[
+            association_end association_owner note_link
+          ].freeze
+          private_constant :NON_RELATION_ROLES
+
+          module_function
+
+          # @return [Array<Relation>] the edges that are relations
+          def relations(index)
+            relation_edges(index).map { |edge| relation(edge, index) }
+          end
+
+          # @return [Array<Junction>]
+          def junctions(index)
+            index.with_role("association_class").map do |node|
+              junction(node, index)
+            end
+          end
+
+          # @return [Array<Note>]
+          def notes(index)
+            index.with_role("note").map { |node| note(node, index) }
+          end
+
+          def relation_edges(index)
+            index.edges.reject do |edge|
+              NON_RELATION_ROLES.include?(edge.role)
+            end
+          end
+
+          def relation(edge, index)
+            node = edge.parent_id && index.node(edge.parent_id)
+            Relation.new(
+              left: name_of(edge.source_id, index),
+              right: name_of(edge.target_id, index),
+              arrow: arrow(edge, node, index),
+              ends: ends(node, index), label: edge.label,
+              layout_only: flagged?(node, "layout_only", index)
+            )
+          end
+
+          def arrow(edge, node, index)
+            markers = markers(edge)
+            { kind: edge.role&.to_sym, head: head(markers), markers: markers,
+              dashed: flagged?(node, "dashed", index),
+              plain: flagged?(node, "plain", index),
+              direction: detail(node, "direction", index)&.to_sym,
+              length: Integer(detail(node, "length", index) || 2),
+              dotted: flagged?(node, "dotted", index) }
+              .merge(stroke(node, index))
+          end
+
+          def stroke(node, index)
+            width = detail(node, "width", index)
+            { color: detail(node, "color", index),
+              width: (Integer(width) if width) }
+          end
+
+          def markers(edge)
+            properties = edge.properties
+            { left: properties.source_marker,
+              right: properties.target_marker }.compact
+              .transform_values(&:to_sym)
+          end
+
+          def head(markers)
+            return :both if markers.size == 2
+
+            markers.keys.first
+          end
+
+          def ends(node, index)
+            {
+              left: detail(node, "left_multiplicity", index),
+              right: detail(node, "right_multiplicity", index),
+              left_role: detail(node, "left_role", index),
+              right_role: detail(node, "right_role", index),
+            }
+          end
+
+          # A class is named by its label, a package by its source id.
+          def name_of(node_id, index)
+            node = index.node(node_id)
+            return node.label unless node.role == "package"
+
+            index.detail(node, "source_id")
+          end
+
+          def detail(node, role, index)
+            node && index.detail(node, role)
+          end
+
+          def flagged?(node, role, index)
+            !detail(node, role, index).nil?
+          end
+
+          def junction(node, index)
+            ends = index.edges.select { |edge| edge.source_id == node.id }
+            names = ends.map { |edge| name_of(edge.target_id, index) }
+            Junction.new(from: names[0], to: names[1], owner: names[2])
+          end
+
+          def note(node, index)
+            link = index.edges.find { |edge| edge.source_id == node.id }
+            Note.new(note_head(node, link, index),
+                     lines: index.details(node, "line").freeze)
+          end
+
+          def note_head(node, link, index)
+            { side: index.detail(node, "side").to_sym,
+              target: link && name_of(link.target_id, index),
+              member: index.detail(node, "member"),
+              color: index.detail(node, "color"),
+              stereotype: index.detail(node, "stereotype") }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/notation/plantuml/ir_reader/structure.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../klass"
+require_relative "../member"
+require_relative "../package"
+
+module Etassia
+  module Notation
+    module PlantUML
+      module IRReader
+        # Rebuilds the packages, classes and members.
+        module Structure
+          KINDS = {
+            "class" => :class, "abstract_class" => :abstract,
+            "interface" => :interface, "enum" => :enum,
+            "annotation" => :annotation
+          }.freeze
+          private_constant :KINDS
+
+          module_function
+
+          # @return [Array<Package>]
+          def packages(index)
+            index.with_role("package").map do |node|
+              package(node, index)
+            end
+          end
+
+          # @return [Array<Klass>]
+          def classes(index)
+            index.with_role(*KINDS.keys).map { |node| klass(node, index) }
+          end
+
+          def package(node, index)
+            Package.new(
+              id: index.detail(node, "source_id"), title: node.label,
+              shape: index.detail(node, "shape").to_sym,
+              icon: !index.detail(node, "icon").nil?,
+              parent: source_id(node.parent_id, index),
+              color: index.detail(node, "color")
+            )
+          end
+
+          def klass(node, index)
+            Klass.new(
+              name: node.label, kind: KINDS.fetch(node.role),
+              body: members(node, index).freeze,
+              package: source_id(node.parent_id, index),
+              stereotypes: index.details(node, "stereotype").freeze,
+              generics: index.detail(node, "generics"),
+              tags: index.details(node, "tag").freeze
+            )
+          end
+
+          def members(node, index)
+            index.children(node, "field", "method", "separator").map do |member|
+              member(member, index)
+            end
+          end
+
+          def member(node, index)
+            Member.new(
+              kind: node.role.to_sym, name: node.label,
+              visibility: index.detail(node, "visibility")&.to_sym,
+              type: index.detail(node, "type"),
+              type_position: index.detail(node, "type_position")&.to_sym ||
+                :suffix,
+              type_separator: index.detail(node, "type_separator") || ": ",
+              parameters: index.detail(node, "parameters"),
+              modifiers: index.details(node, "modifier").map(&:to_sym).freeze
+            )
+          end
+
+          def source_id(node_id, index)
+            return if node_id.nil?
+
+            index.detail(index.node(node_id), "source_id")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "diagram"
+require_relative "ir_reader/index"
+require_relative "ir_reader/structure"
+require_relative "ir_reader/links"
+require_relative "ir_reader/annotations"
+
+module Etassia
+  module Notation
+    module PlantUML
+      # Rebuilds the private class Diagram from the IR::Graph {IRAdapter}
+      # emitted, so layout can keep measuring and placing PlantUML's own
+      # boxes. Nothing outside this notation reads the Diagram.
+      module IRReader
+        module_function
+
+        # @param graph [IR::Graph] a graph from {IRAdapter.call}
+        # @return [Diagram]
+        def call(graph)
+          index = Index.new(graph)
+          Diagram.new(
+            classes: Structure.classes(index).freeze,
+            relations: Links.relations(index).freeze,
+            packages: Structure.packages(index).freeze,
+            **recorded(index),
+          )
+        end
+
+        def recorded(index)
+          {
+            junctions: Links.junctions(index).freeze,
+            notes: Links.notes(index).freeze,
+            directives: Annotations.directives(index).freeze,
+            captions: Annotations.captions(index).freeze,
+            style: Annotations.style(index),
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      # An association class: `(from, to) .. owner`. The `owner` class hangs
+      # off the relation between `from` and `to`.
+      class Junction
+        attr_reader :from, :to, :owner
+
+        def initialize(from:, to:, owner:)
+          @from = from
+          @to = to
+          @owner = owner
+          freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      # A class, abstract class or interface and the Members of its
+      # body, in the order they were written. `kind` is :class, :abstract or
+      # :interface; `stereotypes` holds the text of each `<<...>>` and
+      # `generics` the text of `<...>` after the name, or nil and `tags` the
+      # names written as `$name` after the header and `package` the id of the
+      # Package it was declared in, or nil. A body with no `--`-style rule
+      # lists its fields before its methods whatever order they were written
+      # in, as PlantUML draws it; a body with a rule keeps the written order.
+      class Klass
+        attr_reader :name, :kind, :body, :stereotypes, :generics, :tags,
+                    :package
+
+        # @param header [Hash] optional `:stereotypes`, `:generics` and
+        #   `:tags`; each defaults to empty
+        def initialize(name:, kind:, body:, package: nil, **header)
+          @name = name
+          @kind = kind
+          @body = grouped(body)
+          @package = package
+          @stereotypes = header.fetch(:stereotypes, [].freeze)
+          @generics = header[:generics]
+          @tags = header.fetch(:tags, [].freeze)
+          freeze
+        end
+
+        private
+
+        def grouped(body)
+          return body if body.any? { |member| member.kind == :separator }
+
+          body.partition { |member| member.kind == :field }.flatten(1).freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Etassia
+  module Notation
+    module PlantUML
+      # Where a link's label can sit without its own line running through the
+      # text. The JAR keeps a label beside its line: above a flat one, to the
+      # right of a steep one. A line that slopes under the label's width, or
+      # across its height, reaches further than the middle the label is
+      # centred on, so the label moves clear of the line's furthest point
+      # under it.
+      module LabelClearance
+        extend self
+
+        # @param from [Array(Float, Float)] one end of the line
+        # @param to [Array(Float, Float)] the other end
+        # @return [Float] the y of the line's highest point between the
+        #   x values `left` and `right`
+        def top_between(from, to, left, right)
+          lowest = [from[1], to[1]].min
+          [left, right].map { |x_pos| across(from, to, 0, x_pos, lowest) }.min
+        end
+
+        # @return [Float] the x of the line's rightmost point between the
+        #   y values `top` and `bottom`
+        def right_between(from, to, top, bottom)
+          widest = [from[0], to[0]].max
+          [top, bottom].map { |y_pos| across(from, to, 1, y_pos, widest) }.max
+        end
+
+        # @return [Float] the y of the line's lowest point between the x
+        #   values `left` and `right`
+        def bottom_between(from, to, left, right)
+          highest = [from[1], to[1]].max
+          [left, right].map { |x_pos| across(from, to, 0, x_pos, highest) }.max
+        end
+
+        # @return [Float] the x of the line's leftmost point between the y
+        #   values `top` and `bottom`
+        def left_between(from, to, top, bottom)
+          narrowest = [from[0], to[0]].min
+          [top, bottom].map do |y_pos|
+            across(from, to, 1, y_pos, narrowest)
+          end.min
+        end
+
+        private
+
+        # The line's coordinate on the other axis where `axis` is `value`,
+        # held to the ends of the line; `flat` when the line does not move
+        # along `axis`.
+        def across(from, to, axis, value, flat)
+          share = share_of(from[axis], to[axis], value)
+          return flat unless share
+
+          other = 1 - axis
+          from[other] + ((to[other] - from[other]) * share)
+        end
+
+        def share_of(start, stop, value)
+          span = stop - start
+          ((value - start) / span).clamp(0, 1) unless span.zero?
+        end
+      end
+    end
+  end
+end