railroad_diagrams 0.1.0

data/lib/railroad_diagrams/diagram.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Diagram < DiagramMultiContainer
+    def initialize(*items, **kwargs)
+      super('svg', items.to_a, { 'class' => DIAGRAM_CLASS })
+      @type = kwargs.fetch(:type, 'simple')
+
+      if @items.any?
+        @items.unshift(Start.new(@type)) unless @items.first.is_a?(Start)
+        @items.push(End.new(@type)) unless @items.last.is_a?(End)
+      end
+
+      @up = 0
+      @down = 0
+      @height = 0
+      @width = 0
+
+      @items.each do |item|
+        next if item.is_a?(Style)
+
+        @width += item.width + (item.needs_space ? 20 : 0)
+        @up = [@up, item.up - @height].max
+        @height += item.height
+        @down = [@down - item.height, item.down].max
+      end
+
+      @width -= 10 if @items[0].needs_space
+      @width -= 10 if @items[-1].needs_space
+      @formatted = false
+    end
+
+    def to_s
+      items = items.map(&:to_s).join(', ')
+      pieces = items ? [items] : []
+      pieces.push("type=#{@type}") if @type != 'simple'
+      "Diagram(#{pieces.join(', ')})"
+    end
+
+    def format(padding_top = 20, padding_right = nil, padding_bottom = nil, padding_left = nil)
+      padding_right = padding_top if padding_right.nil?
+      padding_bottom = padding_top if padding_bottom.nil?
+      padding_left = padding_right if padding_left.nil?
+
+      x = padding_left
+      y = padding_top + @up
+      g = DiagramItem.new('g')
+      g.attrs['transform'] = 'translate(.5 .5)' if STROKE_ODD_PIXEL_LENGTH
+
+      @items.each do |item|
+        if item.needs_space
+          Path.new(x, y).h(10).add(g)
+          x += 10
+        end
+        item.format(x, y, item.width).add(g)
+        x += item.width
+        y += item.height
+        if item.needs_space
+          Path.new(x, y).h(10).add(g)
+          x += 10
+        end
+      end
+
+      @attrs['width'] = (@width + padding_left + padding_right).to_s
+      @attrs['height'] = (@up + @height + @down + padding_top + padding_bottom).to_s
+      @attrs['viewBox'] = "0 0 #{@attrs['width']} #{@attrs['height']}"
+      g.add(self)
+      @formatted = true
+      self
+    end
+
+    def text_diagram
+      separator, = TextDiagram.get_parts(['separator'])
+      diagram_td = items[0].text_diagram
+      items[1..].each do |item|
+        item_td = item.text_diagram
+        item_td.expand(1, 1, 0, 0) if item.needs_space
+        diagram_td = diagram_td.append_right(separator)
+      end
+    end
+
+    def write_svg(write)
+      format unless @formatted
+
+      super
+    end
+
+    def write_text(_write)
+      output = text_diagram
+      output = "#{output.lines.join("\n")}\n"
+      output = output.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;') if ESCAPE_HTML
+      write(output)
+    end
+
+    def write_standalone(write, css = nil)
+      format unless @formatted
+      css = Style.default_style if css
+      Style.new(css).add(self)
+      @attrs['xmlns'] = 'http://www.w3.org/2000/svg'
+      @attrs['xmlns:xlink'] = 'http://www.w3.org/1999/xlink'
+      DiagramItem.write_svg(write)
+      @children.pop
+      @attrs.delete('xmlns')
+      @attrs.delete('xmlns:xlink')
+    end
+  end
+end

data/lib/railroad_diagrams/diagram_item.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class DiagramItem
+    attr_reader :up, :down, :height, :width, :needs_space, :attrs, :children
+
+    def initialize(name, attrs: {}, text: nil)
+      @name = name
+      @up = 0
+      @height = 0
+      @down = 0
+      @width = 0
+      @needs_space = false
+      @attrs = attrs || {}
+      @children = text ? [text] : []
+    end
+
+    def format(x, y, width)
+      raise NotImplementedError
+    end
+
+    def text_diagram
+      raise NotImplementedError 'Virtual'
+    end
+
+    def add(parent)
+      parent.children.push self
+      self
+    end
+
+    def write_svg(write)
+      write.call("<#{@name}")
+      @attrs.sort.each do |name, value|
+        write.call(" #{name}=\"#{RailroadDiagrams.escape_attr(value)}\"")
+      end
+      write.call('>')
+      write.call("\n") if @name in %w[g svg]
+      @children.each do |child|
+        if child.is_a?(DiagramItem) || child.is_a?(Path) || child.is_a?(Style)
+          child.write_svg(write)
+        else
+          write.call(RailroadDiagrams.escape_html(child))
+        end
+      end
+      write.call("</#{@name}>")
+    end
+
+    def walk(_callback)
+      callback(self)
+    end
+
+    def to_str
+      "DiagramItem(#{@name}, #{@attrs}, #{@children})"
+    end
+
+    private
+
+    def wrap_string(value)
+      if value.class <= DiagramItem
+        value
+      else
+        Terminal.new(value)
+      end
+    end
+
+    def determine_gaps(outer, inner)
+      diff = outer - inner
+      if INTERNAL_ALIGNMENT == 'left'
+        [0, diff]
+      elsif INTERNAL_ALIGNMENT == 'right'
+        [diff, 0]
+      else
+        [diff / 2, diff / 2]
+      end
+    end
+  end
+end

data/lib/railroad_diagrams/diagram_multi_container.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class DiagramMultiContainer < DiagramItem
+    def initialize(name, items, attrs = nil, text = nil)
+      super(name, attrs:, text:)
+      @items = items.map { |item| wrap_string(item) }
+    end
+
+    def format(x, y, width)
+      raise NotImplementedError
+    end
+
+    def walk(callback)
+      callback(self)
+      @items.each { |item| item.walk(callback) }
+    end
+
+    def to_str
+      "DiagramMultiContainer(#{@name}, #{@items}, #{@attrs}, #{@children})"
+    end
+  end
+end

data/lib/railroad_diagrams/end.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class End < DiagramItem
+    def initialize(type = 'simple')
+      super('path')
+      @width = 20
+      @up = 10
+      @down = 10
+      @type = type
+    end
+
+    def to_s
+      "End(type=#{@type})"
+    end
+
+    def format(x, y, _width)
+      @attrs['d'] =
+        if @type == 'simple'
+          "M #{x} #{y} h 20 m -10 -10 v 20 m 10 -20 v 20"
+        else
+          "M #{x} #{y} h 20 m 0 -10 v 20"
+        end
+      self
+    end
+
+    def text_diagram
+      cross, line, tee_left = TextDiagram.get_parts(%w[cross line tee_left])
+      end_node =
+        if @type == 'simple'
+          line + cross + tee_left
+        else
+          line + tee_left
+        end
+
+      TextDiagram.new(0, 0, [end_node])
+    end
+  end
+end

data/lib/railroad_diagrams/group.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Group < DiagramItem
+    def initialize(item, label = nil)
+      super('g')
+      @item = wrap_string(item)
+
+      @label =
+        if label.is_a?(DiagramItem)
+          label
+        elsif label
+          Comment.new(label)
+        end
+
+      item_width = @item.width + (@item.needs_space ? 20 : 0)
+      label_width = @label ? @label.width : 0
+      @width = [item_width, label_width, AR * 2].max
+
+      @height = @item.height
+
+      @box_up = [@item.up + VS, AR].max
+      @up = @box_up
+      @up += @label.up + @label.height + @label.down if @label
+
+      @down = [@item.down + VS, AR].max
+
+      @needs_space = true
+    end
+
+    def to_s
+      "Group(#{@item}, label=#{@label})"
+    end
+
+    def format(x, y, width)
+      left_gap, right_gap = determine_gaps(width, @width)
+      Path.new(x, y).h(left_gap).add(self)
+      Path.new(x + left_gap + @width, y + @height).h(right_gap).add(self)
+      x += left_gap
+
+      DiagramItem.new(
+        'rect',
+        attrs: {
+          'x' => x,
+          'y' => y - @box_up,
+          'width' => @width,
+          'height' => @height + @box_up + @down,
+          'rx' => AR,
+          'ry' => AR,
+          'class' => 'group-box'
+        }
+      ).add(self)
+
+      @item.format(x, y, @width).add(self)
+      @label.format(x, y - (@box_up + @label.down + @label.height), @width).add(self) if @label
+
+      self
+    end
+
+    def walk(callback)
+      callback.call(self)
+      item.walk(callback)
+      label&.walk(callback)
+    end
+
+    def text_diagram
+      diagram_td = TextDiagram.round_rect(@item.text_diagram, dashed: true)
+      if @label
+        label_td = @label.text_diagram
+        diagram_td = label_td.append_below(diagram_td, [], move_entry: true, move_exit: true).expand(0, 0, 1, 0)
+      end
+      diagram_td
+    end
+  end
+end

data/lib/railroad_diagrams/horizontal_choice.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class HorizontalChoice < DiagramMultiContainer
+    def self.new(*items)
+      return Sequence.new(*items) if items.size <= 1
+
+      super
+    end
+
+    def initialize(*items)
+      super('g', items)
+      all_but_last = @items[0...-1]
+      middles = @items[1...-1]
+      first = @items.first
+      last = @items.last
+      @needs_space = false
+
+      @width =
+        AR + # starting track
+        (AR * 2 * (@items.size - 1)) + # inbetween tracks
+        @items.sum { |x| x.width + (x.needs_space ? 20 : 0) } + # items
+        (last.height > 0 ? AR : 0) + # needs space to curve up
+        AR # ending track
+
+      # Always exits at entrance height
+      @height = 0
+
+      # All but the last have a track running above them
+      @upper_track = [AR * 2, VS, all_but_last.map(&:up).max + VS].max
+      @up = [@upper_track, last.up].max
+
+      # All but the first have a track running below them
+      # Last either straight-lines or curves up, so has different calculation
+      @lower_track = [
+        VS,
+        middles.any? ? middles.map { |x| x.height + [x.down + VS, AR * 2].max }.max : 0,
+        last.height + last.down + VS
+      ].max
+      if first.height < @lower_track
+        # Make sure there's at least 2*AR room between first exit and lower track
+        @lower_track = [@lower_track, first.height + (AR * 2)].max
+      end
+      @down = [@lower_track, first.height + first.down].max
+    end
+
+    def to_s
+      items = @items.map(&:to_s).join(', ')
+      "HorizontalChoice(#{items})"
+    end
+
+    def format(x, y, width)
+      # Hook up the two sides if self is narrower than its stated width.
+      left_gap, right_gap = determine_gaps(width, @width)
+      Path.new(x, y).h(left_gap).add(self)
+      Path.new(x + left_gap + @width, y + @height).h(right_gap).add(self)
+      x += left_gap
+
+      first = @items.first
+      last = @items.last
+
+      # upper track
+      upper_span =
+        @items[0...-1].sum { |item| item.width + (item.needs_space ? 20 : 0) } +
+        ((@items.size - 2) * AR * 2) -
+        AR
+
+      Path.new(x, y)
+          .arc('se')
+          .up(@upper_track - (AR * 2))
+          .arc('wn')
+          .h(upper_span)
+          .add(self)
+
+      # lower track
+      lower_span =
+        @items[1..].sum { |item| item.width + (item.needs_space ? 20 : 0) } +
+        ((@items.size - 2) * AR * 2) +
+        (last.height.positive? ? AR : 0) -
+        AR
+
+      lower_start = x + AR + first.width + (first.needs_space ? 20 : 0) + (AR * 2)
+
+      Path.new(lower_start, y + @lower_track)
+          .h(lower_span)
+          .arc('se')
+          .up(@lower_track - (AR * 2))
+          .arc('wn')
+          .add(self)
+
+      # Items
+      @items.each_with_index do |item, i|
+        # input track
+        if i.zero?
+          Path.new(x, y)
+              .h(AR)
+              .add(self)
+          x += AR
+        else
+          Path.new(x, y - @upper_track)
+              .arc('ne')
+              .v(@upper_track - (AR * 2))
+              .arc('ws')
+              .add(self)
+          x += AR * 2
+        end
+
+        # item
+        item_width = item.width + (item.needs_space ? 20 : 0)
+        item.format(x, y, item_width).add(self)
+        x += item_width
+
+        # output track
+        if i == @items.size - 1
+          if item.height.zero?
+            Path.new(x, y).h(AR).add(self)
+          else
+            Path.new(x, y + item.height).arc('se').add(self)
+          end
+        elsif i.zero? && item.height > @lower_track
+          # Needs to arc up to meet the lower track, not down.
+          if item.height - @lower_track >= AR * 2
+            Path.new(x, y + item.height)
+                .arc('se')
+                .v(@lower_track - item.height + (AR * 2))
+                .arc('wn')
+                .add(self)
+          else
+            # Not enough space to fit two arcs
+            # so just bail and draw a straight line for now.
+            Path.new(x, y + item.height)
+                .l(AR * 2, @lower_track - item.height)
+                .add(self)
+          end
+        else
+          Path.new(x, y + item.height)
+              .arc('ne')
+              .v(@lower_track - item.height - (AR * 2))
+              .arc('ws')
+              .add(self)
+        end
+      end
+      self
+    end
+
+    def text_diagram
+      line, line_vertical, roundcorner_bot_left, roundcorner_bot_right,
+      roundcorner_top_left, roundcorner_top_right = TextDiagram.get_parts(
+        %w[line line_vertical roundcorner_bot_left roundcorner_bot_right roundcorner_top_left
+           roundcorner_top_right]
+      )
+
+      # Format all the child items, so we can know the maximum entry, exit, and height.
+      item_tds = @items.map(&:text_diagram)
+
+      # diagram_entry: distance from top to lowest entry, aka distance from top to diagram entry, aka final diagram entry and exit.
+      diagram_entry = item_tds.map(&:entry).max
+      # soil_to_baseline: distance from top to lowest entry before rightmost item, aka distance from skip-over-items line to rightmost entry, aka SOIL height.
+      soil_to_baseline = item_tds[0..-2].map(&:entry).max || 0
+      # top_to_soil: distance from top to skip-over-items line.
+      top_to_soil = diagram_entry - soil_to_baseline
+      # baseline_to_suil: distance from lowest entry or exit after leftmost item to bottom, aka distance from entry to skip-under-items line, aka SUIL height.
+      baseline_to_suil = item_tds[1..-1].map { |td| td.height - [td.entry, td.exit].min }.max.to_i - 1
+
+      # The diagram starts with a line from its entry up to skip-over-items line:
+      lines = Array.new(top_to_soil, '  ')
+      lines << (roundcorner_top_left + line)
+      lines += Array.new(soil_to_baseline, line_vertical + ' ')
+      lines << (roundcorner_bot_right + line)
+
+      diagram_td = TextDiagram.new(lines.size - 1, lines.size - 1, lines)
+
+      item_tds.each_with_index do |item_td, item_num|
+        if item_num > 0
+          # All items except the leftmost start with a line from the skip-over-items line down to their entry,
+          # with a joining-line across at the skip-under-items line:
+          lines = Array.new(top_to_soil, '  ')
+          # All such items except the rightmost also have a continuation of the skip-over-items line:
+          line_to_next_item = item_num == item_tds.size - 1 ? ' ' : line
+          lines << (roundcorner_top_right + line_to_next_item)
+          lines += Array.new(soil_to_baseline, line_vertical + ' ')
+          lines << (roundcorner_bot_left + line)
+          lines += Array.new(baseline_to_suil, '  ')
+          lines << (line * 2)
+
+          entry_td = TextDiagram.new(diagram_td.exit, diagram_td.exit, lines)
+          diagram_td = diagram_td.append_right(entry_td, '')
+        end
+
+        part_td = TextDiagram.new(0, 0, [])
+
+        if item_num < item_tds.size - 1
+          # All items except the rightmost start with a segment of the skip-over-items line at the top.
+          # followed by enough blank lines to push their entry down to the previous item's exit:
+          lines = []
+          lines << (line * item_td.width)
+          lines += Array.new(soil_to_baseline - item_td.entry, ' ' * item_td.width)
+          soil_segment = TextDiagram.new(0, 0, lines)
+          part_td = part_td.append_below(soil_segment, [])
+        end
+
+        part_td = part_td.append_below(item_td, [], move_entry: true, move_exit: true)
+
+        if item_num > 0
+          # All items except the leftmost end with enough blank lines to pad down to the skip-under-items
+          # line, followed by a segment of the skip-under-items line:
+          lines = Array.new(baseline_to_suil - (item_td.height - item_td.entry) + 1, ' ' * item_td.width)
+          lines << (line * item_td.width)
+          suil_segment = TextDiagram.new(0, 0, lines)
+          part_td = part_td.append_below(suil_segment, [])
+        end
+
+        diagram_td = diagram_td.append_right(part_td, '')
+
+        if item_num < item_tds.size - 1
+          # All items except the rightmost have a line from their exit down to the skip-under-items line,
+          # with a joining-line across at the skip-over-items line:
+          lines = Array.new(top_to_soil, '  ')
+          lines << (line * 2)
+          lines += Array.new(diagram_td.exit - top_to_soil - 1, '  ')
+          lines << (line + roundcorner_top_right)
+          lines += Array.new(baseline_to_suil - (diagram_td.exit - diagram_td.entry), ' ' + line_vertical)
+          line_from_prev_item = item_num > 0 ? line : ' '
+          lines << (line_from_prev_item + roundcorner_bot_left)
+
+          entry = diagram_entry + 1 + (diagram_td.exit - diagram_td.entry)
+          exit_td = TextDiagram.new(entry, diagram_entry + 1, lines)
+          diagram_td = diagram_td.append_right(exit_td, '')
+        else
+          # The rightmost item has a line from the skip-under-items line and from its exit up to the diagram exit:
+          lines = []
+          line_from_exit = diagram_td.exit == diagram_td.entry ? line : ' '
+          lines << (line_from_exit + roundcorner_top_left)
+          lines += Array.new(diagram_td.exit - diagram_td.entry - 1, ' ' + line_vertical)
+          lines << (line + roundcorner_bot_right) if diagram_td.exit != diagram_td.entry
+          lines += Array.new(baseline_to_suil - (diagram_td.exit - diagram_td.entry), ' ' + line_vertical)
+          lines << (line + roundcorner_bot_right)
+
+          exit_td = TextDiagram.new(diagram_td.exit - diagram_td.entry, 0, lines)
+          diagram_td = diagram_td.append_right(exit_td, '')
+        end
+      end
+
+      diagram_td
+    end
+  end
+end