archsight 0.5.4 → 0.5.5

data/lib/archsight/diagram/parser.rb

@@ -14,12 +14,15 @@ module Archsight
     #
     # Grammar (informal):
     #   program    := statement*
-    #   statement  := block | dataflow | edge | setting | include
+    #   statement  := block | dataflow | edge | setting | include | definition
+    #   definition := ("badge" | "line") STRING "{" attr* "}"   -- top level only
     #   include    := "include" STRING ["{" "namespace" STRING "}"] [";"]
     #                 -- top level, or where a container may hold blocks and edges
     #   setting    := ("theme" | "legend" | "ranks") STRING [";"]   -- top level only
-    #   block      := (CONTAINER_KEYWORD | LEAF_KEYWORD) [STRING] "{" (attr | block | edge | include)* "}"
-    #                 -- the id is required except for ANONYMOUS_KEYWORDS
+    #   block      := (CONTAINER_KEYWORD | LEAF_KEYWORD) [STRING] "{" (attr | block | edge | include | port)* "}"
+    #                 -- the id is required except for ANONYMOUS_KEYWORDS; a leaf holds
+    #                    only attrs and ports, a container no ports
+    #   port       := "port" STRING "{" attr* "}"
     #   dataflow   := "dataflow" STRING "{" (hop | hop_group | attr)* "}"
     #                 -- needs >= 2 hops (per branch, if a hop_group is present);
     #                    at most one hop_group per dataflow
@@ -50,6 +53,7 @@ module Archsight
       NAMESPACE = /\A[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)*\z/
       ANONYMOUS_KEYWORDS = %w[layer stack].freeze
       SETTING_KEYWORDS = %w[theme legend ranks].freeze
+      DEFINITION_KEYWORDS = %w[badge line].freeze
       EDGE_ARROWS = {
         arrow: :directed,
         biarrow: :bidirectional,
@@ -89,6 +93,8 @@ module Archsight
           edge
         elsif SETTING_KEYWORDS.any? { |k| cursor.check(:ident, k) } && cursor.peek_type(1) == :string
           setting
+        elsif definition?
+          definition
         else
           t = cursor.current
           raise ParseError, "expected #{BLOCK_KEYWORDS.map(&:inspect).join(", ")}, 'dataflow', or an edge " \
@@ -123,10 +129,14 @@ module Archsight
 
         cursor.expect(:rbrace, "expected '}' to close #{label}")
 
-        if LEAF_KEYWORDS.include?(kind_token.value) && !children.empty?
+        leaf = LEAF_KEYWORDS.include?(kind_token.value)
+        if leaf && children.any? { |c| !c.is_a?(AST::Port) }
           raise ParseError, "#{label} at line #{kind_token.line} cannot " \
                             "contain nested blocks, edges or includes (did you mean 'group'?)"
         end
+        if !leaf && (port = children.find { |c| c.is_a?(AST::Port) })
+          raise ParseError, "port #{port.id.inspect} at line #{port.line}: only a leaf (component, database, ...) has ports, not #{label}"
+        end
 
         raise ParseError, "#{label} at line #{kind_token.line}: columns only applies to containers" if LEAF_KEYWORDS.include?(kind_token.value) && attrs.key?("columns")
 
@@ -135,10 +145,12 @@ module Archsight
         AST::Block.new(kind: kind, id: id, anonymous: anonymous, attrs: attrs, children: children, line: kind_token.line)
       end
 
-      # The nested block, edge or include at the cursor, nil if it is something else (an attribute)
+      # The nested block, edge, include or port at the cursor, nil if it is something else (an attribute)
       def container_child
         if check_block_keyword?
           block
+        elsif keyword_block?("port")
+          port
         elsif include_directive?
           include_statement
         elsif cursor.check(:ident) && EDGE_ARROWS.key?(cursor.peek_type(1))
@@ -185,6 +197,45 @@ module Archsight
         AST::Setting.new(key: key_token.value, value: value_token.value, line: key_token.line)
       end
 
+      # `port "id" { ... }` -- `port "x"` without a block stays an (unknown) attribute, so it is reported as one
+      def port
+        keyword = cursor.advance
+        id = cursor.advance
+        label = "port #{id.value.inspect}"
+        raise ParseError, "port at line #{keyword.line} has an empty id" if id.value.strip.empty?
+        raise ParseError, "#{label} at line #{keyword.line}: a port id cannot contain '.'" if id.value.include?(".")
+
+        attrs = read_attr_block(label)
+        AST::Port.new(id: id.value, attrs: attrs, line: keyword.line)
+      end
+
+      def definition?
+        DEFINITION_KEYWORDS.any? { |k| keyword_block?(k) }
+      end
+
+      # `badge "id" { ... }` / `line "dashed" { ... }` at the top level
+      def definition
+        keyword = cursor.advance
+        id = cursor.advance
+        attrs = read_attr_block("#{keyword.value} #{id.value.inspect}")
+        AST::Definition.new(kind: keyword.value.to_sym, id: id.value, attrs: attrs, line: keyword.line)
+      end
+
+      # `KEYWORD STRING {` -- the brace tells it apart from an attribute (`badge "x"`) or an edge (`line -> x`)
+      def keyword_block?(keyword)
+        cursor.check(:ident, keyword) && cursor.peek_type(1) == :string && cursor.peek_type(2) == :lbrace
+      end
+
+      # `{ attr* }`, read into a fresh hash
+      def read_attr_block(label)
+        cursor.expect(:lbrace, "expected '{' to open #{label}")
+        attrs = {}
+        parse_attrs_until_rbrace(attrs, label, expected: "an attribute") { false }
+        cursor.expect(:rbrace, "expected '}' to close #{label}")
+        cursor.consume(:semi)
+        attrs
+      end
+
       def next_anonymous_id
         @anon_counter += 1
         "__asd_anon_#{@anon_scope}#{@anon_counter}"

data/lib/archsight/diagram/renderer/edge_renderer.rb

@@ -29,7 +29,7 @@ module Archsight
             @path_renderer.draw_relation_path(body, points, edge.relation,
                                               marker_end: edge.direction != :undirected,
                                               marker_start: edge.direction == :bidirectional,
-                                              curve: curve, color: color, id: @ids.part(edge, "line"))
+                                              curve: curve, color: color, id: @ids.part(edge, "line"), line_style: edge.line_style)
             @path_renderer.draw_hit_path(body, points, curve: curve, id: @ids.part(edge, "hit"))
           end
 

data/lib/archsight/diagram/renderer/node_renderer.rb

@@ -15,8 +15,12 @@ module Archsight
         # `Stylesheet#edge_hover_css`), so its hover target -- a leaf's own
         # `<g>`, a container's frame -- and its label are marked for the
         # stylesheet's dim-everything-else rule.
-        def initialize(boxes, text_renderer, ids:, theme:, hover_sources: Set.new)
+        # `ports` are the port tabs (`Layout::Result#ports`), `graph` names the badges' tints.
+        def initialize(boxes, text_renderer, ids:, theme:, hover_sources: Set.new, ports: {}, graph: nil)
           @boxes = boxes
+          @ports = ports
+          @graph = graph
+          @port_metrics = Layout::PortMetrics.new(theme)
           @text_renderer = text_renderer
           @ids = ids
           @hover_sources = hover_sources
@@ -47,6 +51,9 @@ module Archsight
         end
 
         HOVER_SOURCE_CLASS = "asd-hover-source"
+        # How far a node's badge dot sits from its top-right corner, and its radius.
+        BADGE_INSET = 9.0
+        BADGE_RADIUS = 4.0
         # A node whose `resource` reference didn't resolve (see `ResourceLinks`)
         BROKEN_LINK_CLASS = "asd-broken-link"
 
@@ -104,6 +111,33 @@ module Archsight
           body.raw(@text_renderer.label_text(representer.label_x(box), representer.label_y(box, @theme), node.label,
                                              font_size: representer.label_font_size(@theme), link: node.link,
                                              attrs: @ids.label_attrs(node), extra_class: label_class(node)))
+          badge_dot(body, box.right - BADGE_INSET, box.top + BADGE_INSET, node.badge, id: @ids.part(node, "badge")) if node.badge
+          render_ports(body, node, style[:stroke_class])
+        end
+
+        # Each port as a small white tab straddling the border, its label in monospace, its badge at its right end.
+        def render_ports(body, node, stroke_class)
+          node.ports.each do |port|
+            tab = @ports[port.ref]
+            next unless tab
+
+            name = "port-#{port.id.gsub(/[^A-Za-z0-9_-]/, "_")}"
+            body.element("rect", id: @ids.part(node, name), x: fmt(tab.left), y: fmt(tab.top), width: fmt(tab.width), height: fmt(tab.height),
+                                 rx: 4, class: ["asd-port", stroke_class], "data-asd-port": port.id)
+            room = port.badge ? Layout::PortMetrics::BADGE_ROOM : 0.0
+            body.raw(@text_renderer.label_text(tab.x - (room / 2.0), tab.y, port.label, font_size: @port_metrics.font_size,
+                                                                                        attrs: { id: @ids.part(node, "#{name}-label"), "data-asd-owner": @ids.id(node), "data-asd-line": port.line },
+                                                                                        extra_class: "asd-port-text asd-run-code"))
+            badge_dot(body, tab.right - Layout::PortMetrics::PADDING_X - 1.0, tab.y, port.badge, id: @ids.part(node, "#{name}-badge")) if port.badge
+          end
+        end
+
+        def badge_dot(body, cx, cy, badge, id:)
+          definition = @graph&.badge_definition(badge)
+          tint = definition ? definition.tint : "gray"
+          body.element("circle", id: id, cx: fmt(cx), cy: fmt(cy), r: fmt(BADGE_RADIUS), class: "asd-badge-#{tint}") do
+            body.raw(Markup.tag("title", escape(definition.label))) if definition
+          end
         end
 
         # A `text` has no shape for the broken-link styling to dash, so its label is dimmed and dashed itself.

data/lib/archsight/diagram/renderer/path_renderer.rb

@@ -18,13 +18,13 @@ module Archsight
         # replaces the default `asd-stroke-thin` width when the caller
         # needs its own (only a dataflow's thicker, hover-animated line does).
         def draw_relation_path(body, points, relation, marker_end: false, marker_start: false, color: nil, curve: false,
-                               css_class: nil, id: nil)
+                               css_class: nil, id: nil, line_style: "solid")
           path_d = PathGeometry.path_d_string(points, curve: curve)
           marker_id = "url(##{MarkerDefs.marker_id(relation, color: color)})"
 
           body.element("path", id: id, d: path_d,
                                class: ["asd-line", "asd-relation-#{relation}", css_class || "asd-stroke-thin",
-                                       (MarkerDefs.color_class(color) if color)],
+                                       (MarkerDefs.color_class(color) if color), ("asd-line-#{line_style}" unless line_style == "solid")],
                                "marker-end": (marker_id if marker_end),
                                "marker-start": (marker_id if marker_start))
         end

data/lib/archsight/diagram/renderer/stylesheet.rb

@@ -55,7 +55,7 @@ module Archsight
         end
 
         def style_block
-          css = [text_css, line_css, relation_css, shape_css, tint_css, legend_css, line_color_css].join("\n")
+          css = [text_css, line_css, relation_css, shape_css, tint_css, port_css, legend_css, line_color_css].join("\n")
           wrap(css)
         end
 
@@ -233,6 +233,7 @@ module Archsight
             .asd-underline { text-decoration: underline; }
             .asd-run-bold { font-weight: bold; }
             .asd-run-italic { font-style: italic; }
+            .asd-run-code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, "DejaVu Sans Mono", monospace; }
             .asd-run-underline { text-decoration: underline; }
             .asd-broken-text { opacity: 0.6; text-decoration: underline dashed; }
             .asd-text-hit { fill: transparent; stroke: none; }
@@ -244,6 +245,8 @@ module Archsight
             .asd-line { fill: none; }
             .asd-stroke-thin { stroke-width: #{EDGE_STROKE_WIDTH}; }
             .asd-stroke-application { stroke-width: 2.5; }
+            .asd-line.asd-line-dashed { stroke-dasharray: 6 4; }
+            .asd-line.asd-line-dotted { stroke-dasharray: 1.5 3; stroke-linecap: round; }
             .asd-dataflow-line { stroke-width: #{DATAFLOW_STROKE_WIDTH}; transition: stroke-width 0.15s ease; }
             .asd-dataflow-halo { fill: none; stroke: #fff; stroke-width: #{DataflowRenderer::DATAFLOW_HALO_WIDTH}; stroke-linecap: round; }
           CSS
@@ -294,6 +297,12 @@ module Archsight
           end.join("\n")
         end
 
+        # Port tabs (see `NodeRenderer#render_ports`) and badge dots, one fill rule per tint.
+        def port_css
+          badges = Tints.names.map { |name| ".asd-badge-#{name} { fill: #{Tints.for(name).border(0)}; }" }
+          [".asd-port { fill: #fff; stroke-width: 1.1; }", *badges].join("\n")
+        end
+
         def legend_css
           <<~CSS.chomp
             .asd-legend-bg { fill: #fafbfc; stroke-width: 1; }

data/lib/archsight/diagram/renderer/text_renderer.rb

@@ -123,6 +123,7 @@ module Archsight
           classes << "asd-run-bold" if style[:bold]
           classes << "asd-run-italic" if style[:italic]
           classes << "asd-run-underline" if style[:underline] || style[:link]
+          classes << "asd-run-code" if style[:code]
 
           span = Markup.tag("tspan", escape(content), class: classes)
           return span if style[:link].nil? || suppress_inline_links

data/lib/archsight/diagram/renderer.rb

@@ -74,16 +74,20 @@ module Archsight
         # The legend's frame is as solid as a node box, as far as a label is
         # concerned.
         legend_boxes = @layout.legend ? @boxes.slice(@layout.legend.frame.id) : {}
-        @label_placer = LabelPlacer.new(@boxes.slice(*nodes.select(&:leaf?).map(&:id)).merge(legend_boxes),
+        ports = layout.ports || {}
+        port_boxes = ports.transform_keys { |ref| "port:#{ref}" }
+        @label_placer = LabelPlacer.new(@boxes.slice(*nodes.select(&:leaf?).map(&:id)).merge(legend_boxes, port_boxes, title_boxes(nodes, theme)),
                                         containers: @boxes.slice(*nodes.reject { |n| n.leaf? || n.anonymous? }.map(&:id)))
         @node_renderer = NodeRenderer.new(@boxes, @text_renderer, ids: @ids, theme: theme,
-                                                                  hover_sources: drawn_edges.to_set { |e| e.from.id })
+                                                                  hover_sources: drawn_edges.to_set { |e| e.from.id },
+                                                                  ports: ports, graph: @graph)
         @implements_tree_renderer = ImplementsTreeRenderer.new(@boxes, path_renderer: @path_renderer, text_renderer: @text_renderer,
                                                                        ids: @ids, theme: theme)
         # Both routing stages avoid the same boxes, so they share one map
         # (and, with the native kernels, one packed box table).
-        obstacle_map = ObstacleMap.new(@boxes, ignoring: nodes.select { |n| n.anonymous? && !n.leaf? }.map(&:id))
-        @edge_routing = EdgeRouting.new(@graph, @boxes, obstacle_map: obstacle_map)
+        # Port tabs are obstacles too, so other lines don't end on top of one.
+        obstacle_map = ObstacleMap.new(@boxes.merge(port_boxes), ignoring: nodes.select { |n| n.anonymous? && !n.leaf? }.map(&:id))
+        @edge_routing = EdgeRouting.new(@graph, @boxes, obstacle_map: obstacle_map, ports: ports)
         @edge_renderer = EdgeRenderer.new(path_renderer: @path_renderer, text_renderer: @text_renderer, label_placer: @label_placer,
                                           ids: @ids, theme: theme)
         @dataflow_routing = DataflowRouting.new(@graph, @boxes, obstacle_map: obstacle_map)
@@ -230,7 +234,7 @@ module Archsight
         # default `hash`/`==`.
         @implements_tree_groups ||=
           drawn_edges
-          .select { |e| e.relation_type.tree_grouped? && e.direction == :directed && !e.attrs.key?("style") && e.tint.nil? }
+          .select { |e| e.relation_type.tree_grouped? && e.direction == :directed && !e.attrs.key?("style") && e.tint.nil? && !e.attrs.key?("line") && !e.to_port && !e.from_port }
           .group_by { |e| e.to.id }
           .filter_map { |_id, edges| [edges.first.to, edges] if edges.length > 1 }
       end
@@ -246,6 +250,18 @@ module Archsight
         @tree_grouped_edges ||= implements_tree_groups.flat_map { |_target, edges| edges }
       end
 
+      # Where each named container's title is written (see `NodeRenderer#render_container`), so edge labels
+      # keep off it like off a node.
+      def title_boxes(nodes, theme)
+        nodes.select { |n| n.container? && !n.anonymous? && @boxes[n.id] }.to_h do |n|
+          box = @boxes[n.id]
+          size = n.boundary? ? theme.boundary_title_font_size : theme.group_title_font_size
+          width = TextMetrics.rendered_width(MarkdownText.new("**#{n.label}**"), font_size: size)
+          height = n.layout_title_height(theme)
+          ["title:#{n.id}", Layout::Box.new(box.left + theme.title_inset_x + (width / 2.0), box.top + (height / 2.0), width, height)]
+        end
+      end
+
       # --- edges -------------------------------------------------------------
 
       def individually_routed_edges

data/lib/archsight/diagram/routing/edge_routing.rb

@@ -76,11 +76,18 @@ module Archsight
       # instead (see `port_order`).
       PORT_ORDER_TOLERANCE = PORT_MIN_GAP / 2.0
 
+      # A port end is routed to its tab, a box of its own (always a rectangle).
+      PortEnd = Struct.new(:box) do
+        def shape = "rectangle"
+      end
+
       # `obstacle_map` can be shared with `DataflowRouting` over the same boxes.
-      def initialize(graph, boxes, obstacle_map: ObstacleMap.new(boxes))
+      # `ports` are the port tabs (`Layout::Result#ports`) an edge may attach to instead of its node.
+      def initialize(graph, boxes, obstacle_map: ObstacleMap.new(boxes), ports: {})
         @graph = graph
         @boxes = boxes
         @obstacle_map = obstacle_map
+        @ports = ports
       end
 
       # Every edge's route, computed up front (rather than immediately
@@ -89,11 +96,13 @@ module Archsight
       # split into multiple attachment points.
       def compute_paths(edges)
         edges.map do |edge|
-          from = positioned(edge.from)
-          to = positioned(edge.to)
+          from = positioned(edge.from, edge.from_port)
+          to = positioned(edge.to, edge.to_port)
           obstacles = @obstacle_map.excluding(edge.from, edge.to)
           candidates = EdgeRouter.candidate_paths(from.box, to.box, edge.attrs["style"],
                                                   from_shape: from.shape, to_shape: to.shape, obstacles: obstacles)
+          candidates = tab_free_lanes(edge, from, to) + candidates
+          candidates = through_ports(candidates, edge) if edge.from_port || edge.to_port
           scored = EdgeRouter.score_candidates(candidates, obstacles)
           points = EdgeRouter.select_best(scored, sibling_paths: [])
           RoutedEdge.new(edge: edge, points: points, from_box: from.box, to_box: to.box, obstacles: obstacles, scored: scored)
@@ -234,8 +243,100 @@ module Archsight
         points.map { |point| point.dup.tap { |p| p[index] += delta } }
       end
 
-      def positioned(node)
-        Layout::PositionedNode.new(node, @boxes[node.id])
+      def positioned(node, port = nil)
+        tab = port && @ports[port.ref]
+        tab ? PortEnd.new(tab) : Layout::PositionedNode.new(node, @boxes[node.id])
+      end
+
+      # Only lines that leave a tab on its outer side (away from its leaf) and never run through the leaf
+      # itself, which is not an obstacle to its own edges. If no candidate does, all of them are kept.
+      def through_ports(candidates, edge)
+        ends = [[edge.from_port, edge.from, :first], [edge.to_port, edge.to, :last]].select { |port, _, _| port && @ports[port.ref] }
+        kept = candidates.select do |points|
+          ends.all? do |port, node, at|
+            tab = @ports[port.ref]
+            outward?(tab, node, points.public_send(at)) && !EdgeRouter::PathMetrics.enters_interior?(points, @boxes[node.id])
+          end
+        end
+        kept.empty? ? candidates : kept
+      end
+
+      # A straight line between two boxes one above the other (or side by side) normally runs at one box's
+      # center, which may be where a port tab sits on a side it attaches to (a tab is an obstacle). This
+      # offers the same line in the middle of the widest stretch the two boxes share that no tab on the facing
+      # sides covers -- only when such a tab is in the way, so other diagrams route as before.
+      def tab_free_lanes(edge, from, to)
+        a = from.box
+        b = to.box
+        return [] if [from, to].any? { |e| Representers.for(e.shape).elliptical? }
+
+        vertical = !a.overlaps_y?(b) && a.overlaps_x?(b)
+        horizontal = !a.overlaps_x?(b) && a.overlaps_y?(b)
+        return [] unless vertical || horizontal
+
+        axis = vertical ? %i[left right x] : %i[top bottom y]
+        margin = EdgeRouter::StraightPath::ALIGNED_CORNER_MARGIN
+        lo = [a.public_send(axis[0]), b.public_send(axis[0])].max + margin
+        hi = [a.public_send(axis[1]), b.public_send(axis[1])].min - margin
+        blocked = facing_tabs(edge, a, b, vertical).map { |t| [t.public_send(axis[0]) - margin, t.public_send(axis[1]) + margin] }
+        return [] if blocked.none? { |l, h| h > lo && l < hi }
+
+        lane = widest_free(lo, hi, blocked)
+        return [] unless lane
+
+        [lane_line(a, b, (lane[0] + lane[1]) / 2.0, vertical)]
+      end
+
+      # The straight line at `c` between the facing sides of `a` and `b`.
+      def lane_line(a, b, c, vertical)
+        if vertical
+          down = a.y < b.y
+          [[c, down ? a.bottom : a.top], [c, down ? b.top : b.bottom]]
+        else
+          right = a.x < b.x
+          [[right ? a.right : a.left, c], [right ? b.left : b.right, c]]
+        end
+      end
+
+      # The tabs on the sides of the edge's two leaves that face each other (a port end itself is its own box).
+      def facing_tabs(edge, a, b, vertical)
+        [[edge.from, edge.from_port, a, b], [edge.to, edge.to_port, b, a]].flat_map do |node, port, own, other|
+          next [] if port
+
+          side = if vertical
+                   own.y < other.y ? :bottom : :top
+                 else
+                   own.x < other.x ? :right : :left
+                 end
+          node.ports.filter_map { |p| @ports[p.ref] }.select { |tab| tab_on_side?(tab, @boxes[node.id], side) }
+        end
+      end
+
+      def tab_on_side?(tab, box, side)
+        case side
+        when :top then EdgeRouter::PathMetrics.close?(tab.y, box.top)
+        when :bottom then EdgeRouter::PathMetrics.close?(tab.y, box.bottom)
+        when :left then EdgeRouter::PathMetrics.close?(tab.x, box.left)
+        else EdgeRouter::PathMetrics.close?(tab.x, box.right)
+        end
+      end
+
+      # The widest part of `lo..hi` outside every `blocked` interval, `nil` if none is left.
+      def widest_free(lo, hi, blocked)
+        cursor = lo
+        free = []
+        blocked.sort.each do |l, h|
+          free << [cursor, l] if l > cursor
+          cursor = [cursor, h].max
+        end
+        free << [cursor, hi] if hi > cursor
+        free.map { |l, h| [l, [h, hi].min] }.select { |l, h| h - l >= 1.0 }.max_by { |l, h| h - l }
+      end
+
+      # Whether `point` (an end of a line) is on the side of `tab` that faces away from its leaf.
+      def outward?(tab, node, point)
+        side = tab.side_of(point)
+        !side.nil? && tab_on_side?(tab, @boxes[node.id], side)
       end
 
       # Returns whether any edge's `points` actually changed this round.

data/lib/archsight/diagram/support/markdown_text.rb

@@ -10,8 +10,8 @@ module Archsight
     # plain run. Anything built from a label has to carry the flag along
     # (`like`), or its markers render as literal text.
     class MarkdownText < String
-      # Every marker (`**`, `__`, `*`, `[text](url)`) opens with one of these.
-      MARKER_START = /[*_\[]/
+      # Every marker (`**`, `__`, `*`, `` `code` ``, `[text](url)`) opens with one of these.
+      MARKER_START = /[*_`\[]/
 
       # `text` as a `MarkdownText` if a marker could start in it, else as is.
       def self.detect(text) = text.match?(MARKER_START) ? new(text) : text

data/lib/archsight/diagram/support/text_metrics.rb

@@ -56,6 +56,8 @@ module Archsight
         611, 611, 389, 556, 333, 611, 556, 778, 556, 556, 500, 389, 280, 389, 584
       ].freeze
       FALLBACK_WIDTH = 700
+      # Every char of a monospace (`` `code` ``) run: the advance of Menlo, Consolas, DejaVu Sans Mono...
+      MONO_WIDTH = 602
 
       # The rendered width, in px, of `text`'s widest line at `font_size`
       # -- markdown-lite markers don't take up room, and `**bold**` runs
@@ -68,6 +70,8 @@ module Archsight
 
       def line_units(line)
         markdown_runs(line).sum do |content, style|
+          next content.length * MONO_WIDTH if style[:code]
+
           table = style[:bold] ? HELVETICA_BOLD_WIDTHS : HELVETICA_WIDTHS
           content.each_char.sum do |char|
             index = char.ord - 32
@@ -79,7 +83,7 @@ module Archsight
       # A small, deliberately non-nested markdown-lite: `**bold**`,
       # `*italic*`, `__underline__` (a separate marker from bold's `**` so
       # the two never collide, since real Markdown has no underline
-      # syntax), and `[text](url)` for an inline link. Scans left to
+      # syntax), `` `code` `` (monospace) and `[text](url)` for an inline link. Scans left to
       # right, splitting `text` into `[content, style]` pairs -- `style`
       # is `{}` for a plain run. Only a `MarkdownText` is scanned (the lexer
       # flags every string literal a marker could start in); any other
@@ -109,7 +113,7 @@ module Archsight
       end
 
       # Checked in this order, so `**` wins over `*`.
-      PAIRED_MARKERS = { "**" => :bold, "__" => :underline, "*" => :italic }.freeze
+      PAIRED_MARKERS = { "`" => :code, "**" => :bold, "__" => :underline, "*" => :italic }.freeze
 
       # The formatted `[content, style]` run starting at `text[i]`, plus the
       # index just past it -- or nil when no (closed) marker starts there.
@@ -151,7 +155,7 @@ module Archsight
         lines.empty? ? [line] : lines.map { |l| runs_to_markdown(source, l) }
       end
 
-      MARKERS = { bold: "**", italic: "*", underline: "__" }.freeze
+      MARKERS = { bold: "**", italic: "*", underline: "__", code: "`" }.freeze
 
       def runs_to_markdown(source, chars)
         out = chars.chunk_while { |a, b| a[1] == b[1] }.map do |group|

data/lib/archsight/version.rb

@@ -4,5 +4,5 @@
 # Do not edit manually.
 
 module Archsight
-  VERSION = "0.5.4"
+  VERSION = "0.5.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: archsight
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors:
 - Vincent Landgraf
@@ -281,12 +281,15 @@ files:
 - lib/archsight/diagram/graph/edge.rb
 - lib/archsight/diagram/graph/gap_spec.rb
 - lib/archsight/diagram/graph/node.rb
+- lib/archsight/diagram/graph/port.rb
 - lib/archsight/diagram/includes.rb
 - lib/archsight/diagram/layout.rb
+- lib/archsight/diagram/layout/alignment.rb
 - lib/archsight/diagram/layout/expander.rb
 - lib/archsight/diagram/layout/force_simulation.rb
 - lib/archsight/diagram/layout/globalizer.rb
 - lib/archsight/diagram/layout/overlap_resolver.rb
+- lib/archsight/diagram/layout/ports.rb
 - lib/archsight/diagram/layout/rank_arranger.rb
 - lib/archsight/diagram/layout/rank_topology.rb
 - lib/archsight/diagram/layout/ranked_arranger.rb