railroad_diagrams 0.1.0

data/lib/railroad_diagrams/multiple_choice.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class MultipleChoice < DiagramMultiContainer
+    def initialize(default, type, *items)
+      super('g', items)
+      raise ArgumentError, "default must be between 0 and #{items.length - 1}" unless (0...items.length).cover?(default)
+      raise ArgumentError, "type must be 'any' or 'all'" unless %w[any all].include?(type)
+
+      @default = default
+      @type = type
+      @needs_space = true
+      @inner_width = @items.map(&:width).max
+      @width = 30 + AR + @inner_width + AR + 20
+      @up = @items[0].up
+      @down = @items[-1].down
+      @height = @items[default].height
+
+      @items.each_with_index do |item, i|
+        minimum =
+          if [default - 1, default + 1].include?(i)
+            10 + AR
+          else
+            AR
+          end
+
+        if i < default
+          @up += [minimum, item.height + item.down + VS + @items[i + 1].up].max
+        elsif i > default
+          @down += [minimum, item.up + VS + @items[i - 1].down + @items[i - 1].height].max
+        end
+      end
+
+      @down -= @items[default].height # already counted in @height
+    end
+
+    def to_s
+      items = @items.map(&:to_s).join(', ')
+      "MultipleChoice(#{@default}, #{@type}, #{items})"
+    end
+
+    def format(x, y, width)
+      left_gap, right_gap = determine_gaps(width, @width)
+
+      # Hook up the two sides if self is narrower than its stated 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
+
+      default = @items[@default]
+
+      # Do the elements that curve above
+      above = @items[0...@default].reverse
+      distance_from_y = 0
+      distance_from_y = [10 + AR, default.up + VS + above.first.down + above.first.height].max if above.any?
+
+      double_enumerate(above).each do |i, ni, item|
+        Path.new(x + 30, y).up(distance_from_y - AR).arc('wn').add(self)
+        item.format(x + 30 + AR, y - distance_from_y, @inner_width).add(self)
+        Path.new(x + 30 + AR + @inner_width, y - distance_from_y + item.height)
+            .arc('ne')
+            .down(distance_from_y - item.height + default.height - AR - 10)
+            .add(self)
+        distance_from_y += [AR, item.up + VS + above[i + 1].down + above[i + 1].height].max if ni < -1
+      end
+
+      # Do the straight-line path.
+      Path.new(x + 30, y).right(AR).add(self)
+      @items[@default].format(x + 30 + AR, y, @inner_width).add(self)
+      Path.new(x + 30 + AR + @inner_width, y + @height).right(AR).add(self)
+
+      # Do the elements that curve below
+      below = @items[(@default + 1)..] || []
+      distance_from_y = [10 + AR, default.height + default.down + VS + below.first.up].max if below.any?
+
+      below.each_with_index do |item, i|
+        Path.new(x + 30, y).down(distance_from_y - AR).arc('ws').add(self)
+        item.format(x + 30 + AR, y + distance_from_y, @inner_width).add(self)
+        Path.new(x + 30 + AR + @inner_width, y + distance_from_y + item.height)
+            .arc('se')
+            .up(distance_from_y - AR + item.height - default.height - 10)
+            .add(self)
+
+        distance_from_y += [AR, item.height + item.down + VS + (below[i + 1]&.up || 0)].max
+      end
+
+      text = DiagramItem.new('g', attrs: { 'class' => 'diagram-text' }).add(self)
+      DiagramItem.new(
+        'title',
+        text: @type == 'any' ? 'take one or more branches, once each, in any order' : 'take all branches, once each, in any order'
+      ).add(text)
+
+      DiagramItem.new(
+        'path',
+        attrs: {
+          'd' => "M #{x + 30} #{y - 10} h -26 a 4 4 0 0 0 -4 4 v 12 a 4 4 0 0 0 4 4 h 26 z",
+          'class' => 'diagram-text'
+        }
+      ).add(text)
+
+      DiagramItem.new(
+        'text',
+        text: @type == 'any' ? '1+' : 'all',
+        attrs: { 'x' => x + 15, 'y' => y + 4, 'class' => 'diagram-text' }
+      ).add(text)
+
+      DiagramItem.new(
+        'path',
+        attrs: {
+          'd' => "M #{x + @width - 20} #{y - 10} h 16 a 4 4 0 0 1 4 4 v 12 a 4 4 0 0 1 -4 4 h -16 z",
+          'class' => 'diagram-text'
+        }
+      ).add(text)
+
+      DiagramItem.new(
+        'text',
+        text: '↺',
+        attrs: { 'x' => x + @width - 10, 'y' => y + 4, 'class' => 'diagram-arrow' }
+      ).add(text)
+
+      self
+    end
+
+    def text_diagram
+      multi_repeat = TextDiagram.get_parts(['multi_repeat']).first
+      any_all = TextDiagram.rect(@type == 'any' ? '1+' : 'all')
+      diagram_td = Choice.text_diagram(self)
+      repeat_td = TextDiagram.rect(multi_repeat)
+      diagram_td = any_all.append_right(diagram_td, '')
+      diagram_td.append_right(repeat_td, '')
+    end
+
+    private
+
+    def double_enumerate(seq)
+      length = seq.length
+      seq.each_with_index.map { |item, i| [i, i - length, item] }
+    end
+  end
+end

data/lib/railroad_diagrams/non_terminal.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class NonTerminal < DiagramItem
+    def initialize(text, href = nil, title = nil, cls: '')
+      super('g', attrs: { 'class' => "non-terminal #{cls}" })
+      @text = text
+      @href = href
+      @title = title
+      @cls = cls
+      @width = (text.length * CHAR_WIDTH) + 20
+      @up = 11
+      @down = 11
+      @needs_space = true
+    end
+
+    def to_s
+      "NonTerminal(#{@text}, href=#{@href}, title=#{@title}, cls=#{@cls})"
+    end
+
+    def format(x, y, width)
+      left_gap, right_gap = determine_gaps(width, @width)
+
+      # Hook up the two sides if self is narrower than its stated width.
+      Path.new(x, y).h(left_gap).add(self)
+      Path.new(x + left_gap + @width, y).h(right_gap).add(self)
+
+      DiagramItem.new(
+        'rect',
+        attrs: {
+          'x' => x + left_gap,
+          'y' => y - 11,
+          'width' => @width,
+          'height' => @up + @down
+        }
+      ).add(self)
+
+      text = DiagramItem.new(
+        'text',
+        attrs: {
+          'x' => x + left_gap + (@width / 2),
+          'y' => y + 4
+        },
+        text: @text
+      )
+      if @href
+        a = DiagramItem.new(
+          'a',
+          attrs: {
+            'xlink:href' => @href
+          },
+          text:
+        ).add(self)
+        text.add(a)
+      else
+        text.add(self)
+      end
+      DiagramItem.new('title', attrs: {}, text: @title).add(self) if @title
+      self
+    end
+
+    def text_diagram
+      # NOTE: href, title, and cls are ignored for text diagrams.
+      TextDiagram.rect(@text)
+    end
+  end
+end

data/lib/railroad_diagrams/one_or_more.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class OneOrMore < DiagramItem
+    def initialize(item, repeat = nil)
+      super('g')
+      @item = wrap_string(item)
+      repeat ||= Skip.new
+      @rep = wrap_string(repeat)
+      @width = [@item.width, @rep.width].max + (AR * 2)
+      @height = @item.height
+      @up = @item.up
+      @down = [AR * 2, @item.down + VS + @rep.up + @rep.height + @rep.down].max
+      @needs_space = true
+    end
+
+    def to_s
+      "OneOrMore(#{@item}, repeat=#{@rep})"
+    end
+
+    def format(x, y, width)
+      left_gap, right_gap = determine_gaps(width, @width)
+
+      # Hook up the two sides if self is narrower than its stated 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
+
+      # Draw item
+      Path.new(x, y).right(AR).add(self)
+      @item.format(x + AR, y, @width - (AR * 2)).add(self)
+      Path.new(x + @width - AR, y + @height).right(AR).add(self)
+
+      # Draw repeat arc
+      distance_from_y = [AR * 2, @item.height + @item.down + VS + @rep.up].max
+      Path.new(x + AR, y).arc('nw').down(distance_from_y - (AR * 2)).arc('ws').add(self)
+      @rep.format(x + AR, y + distance_from_y, @width - (AR * 2)).add(self)
+      Path.new(x + @width - AR, y + distance_from_y + @rep.height)
+          .arc('se')
+          .up(distance_from_y - (AR * 2) + @rep.height - @item.height)
+          .arc('en')
+          .add(self)
+
+      self
+    end
+
+    def text_diagram
+      parts = TextDiagram.get_parts(
+        %w[
+          line repeat_top_left repeat_left repeat_bot_left repeat_top_right repeat_right repeat_bot_right
+        ]
+      )
+      line, repeat_top_left, repeat_left, repeat_bot_left, repeat_top_right, repeat_right, repeat_bot_right = parts
+
+      # Format the item and then format the repeat append it to the bottom, after a spacer.
+      item_td = @item.text_diagram
+      repeat_td = @rep.text_diagram
+      fir_width = TextDiagram._max_width(item_td, repeat_td)
+      repeat_td = repeat_td.expand(0, fir_width - repeat_td.width, 0, 0)
+      item_td = item_td.expand(0, fir_width - item_td.width, 0, 0)
+      item_and_repeat_td = item_td.append_below(repeat_td, [])
+
+      # Build the left side of the repeat line and append the combined item and repeat to its right.
+      left_lines = []
+      left_lines << (repeat_top_left + line)
+      left_lines += [repeat_left + ' '] * ((item_td.height - item_td.entry) + repeat_td.entry - 1)
+      left_lines << (repeat_bot_left + line)
+      left_td = TextDiagram.new(0, 0, left_lines)
+      left_td = left_td.append_right(item_and_repeat_td, '')
+
+      # Build the right side of the repeat line and append it to the combined left side, item, and repeat's right.
+      right_lines = []
+      right_lines << (line + repeat_top_right)
+      right_lines += [' ' + repeat_right] * ((item_td.height - item_td.exit) + repeat_td.exit - 1)
+      right_lines << (line + repeat_bot_right)
+      right_td = TextDiagram.new(0, 0, right_lines)
+      left_td.append_right(right_td, '')
+    end
+
+    def walk(callback)
+      callback.call(self)
+      @item.walk(callback)
+      @rep.walk(callback)
+    end
+  end
+end

data/lib/railroad_diagrams/optional.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Optional < DiagramMultiContainer
+    def self.new(item, skip = false)
+      Choice.new(skip ? 0 : 1, Skip.new, item)
+    end
+  end
+end

data/lib/railroad_diagrams/optional_sequence.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class OptionalSequence < DiagramMultiContainer
+    def self.new(*items)
+      return Sequence.new(*items) if items.size <= 1
+
+      super
+    end
+
+    def initialize(*items)
+      super('g', items)
+      @needs_space = false
+      @width = 0
+      @up = 0
+      @height = @items.sum(&:height)
+      @down = @items.first.down
+
+      height_so_far = 0.0
+
+      @items.each_with_index do |item, i|
+        @up = [@up, [AR * 2, item.up + VS].max - height_so_far].max
+        height_so_far += item.height
+
+        if i.positive?
+          @down = [
+            @height + @down,
+            height_so_far + [AR * 2, item.down + VS].max
+          ].max - @height
+        end
+
+        item_width = item.width + (item.needs_space ? 10 : 0)
+        @width += if i.zero?
+                    AR + [item_width, AR].max
+                  else
+                    (AR * 2) + [item_width, AR].max + AR
+                  end
+      end
+    end
+
+    def to_s
+      items = @items.map(&:to_s).join(', ')
+      "OptionalSequence(#{items})"
+    end
+
+    def format(x, y, width)
+      left_gap, right_gap = determine_gaps(width, @width)
+      Path.new(x, y).right(left_gap).add(self)
+      Path.new(x + left_gap + @width, y + @height).right(right_gap).add(self)
+      x += left_gap
+      upper_line_y = y - @up
+      last = @items.size - 1
+
+      @items.each_with_index do |item, i|
+        item_space = item.needs_space ? 10 : 0
+        item_width = item.width + item_space
+
+        if i.zero?
+          # Upper skip
+          Path.new(x, y)
+              .arc('se')
+              .up(y - upper_line_y - (AR * 2))
+              .arc('wn')
+              .right(item_width - AR)
+              .arc('ne')
+              .down(y + item.height - upper_line_y - (AR * 2))
+              .arc('ws')
+              .add(self)
+
+          # Straight line
+          Path.new(x, y).right(item_space + AR).add(self)
+          item.format(x + item_space + AR, y, item.width).add(self)
+          x += item_width + AR
+          y += item.height
+        elsif i < last
+          # Upper skip
+          Path.new(x, upper_line_y)
+              .right((AR * 2) + [item_width, AR].max + AR)
+              .arc('ne')
+              .down(y - upper_line_y + item.height - (AR * 2))
+              .arc('ws')
+              .add(self)
+
+          # Straight line
+          Path.new(x, y).right(AR * 2).add(self)
+          item.format(x + (AR * 2), y, item.width).add(self)
+          Path.new(x + item.width + (AR * 2), y + item.height)
+              .right(item_space + AR)
+              .add(self)
+
+          # Lower skip
+          Path.new(x, y)
+              .arc('ne')
+              .down(item.height + [item.down + VS, AR * 2].max - (AR * 2))
+              .arc('ws')
+              .right(item_width - AR)
+              .arc('se')
+              .up(item.down + VS - (AR * 2))
+              .arc('wn')
+              .add(self)
+
+          x += (AR * 2) + [item_width, AR].max + AR
+          y += item.height
+        else
+          # Straight line
+          Path.new(x, y).right(AR * 2).add(self)
+          item.format(x + (AR * 2), y, item.width).add(self)
+          Path.new(x + (AR * 2) + item.width, y + item.height)
+              .right(item_space + AR)
+              .add(self)
+
+          # Lower skip
+          Path.new(x, y)
+              .arc('ne')
+              .down(item.height + [item.down + VS, AR * 2].max - (AR * 2))
+              .arc('ws')
+              .right(item_width - AR)
+              .arc('se')
+              .up(item.down + VS - (AR * 2))
+              .arc('wn')
+              .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.
+      item_tds = @items.map(&:text_diagram)
+
+      # diagramEntry: 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
+      # SOILHeight: distance from top to lowest entry before rightmost item, aka distance from skip-over-items line to rightmost entry, aka SOIL height.
+      soil_height = item_tds[0...-1].map(&:entry).max
+      # topToSOIL: distance from top to skip-over-items line.
+      top_to_soil = diagram_entry - soil_height
+
+      # The diagram starts with a line from its entry up to the skip-over-items line:
+      lines = ['  '] * top_to_soil
+      lines += [roundcorner_top_left + line]
+      lines += ["#{line_vertical} "] * soil_height
+      lines += [roundcorner_bot_right + line]
+      diagram_td = TextDiagram.new(lines.size - 1, lines.size - 1, lines)
+
+      @items.each_with_index do |item_td, i|
+        if i.positive?
+          # All items except the leftmost start with a line from their entry down to their skip-under-item line,
+          # with a joining-line across at the skip-over-items line:
+          lines = (['  '] * top_to_soil) + [line * 2] +
+                  (['  '] * (diagram_td.exit - top_to_soil - 1)) +
+                  [line + roundcorner_top_right] +
+                  ([" #{line_vertical}"] * (item_td.height - item_td.entry - 1)) +
+                  [" #{roundcorner_bot_left}"]
+
+          skip_down_td = TextDiagram.new(diagram_td.exit, diagram_td.exit, lines)
+          diagram_td = diagram_td.append_right(skip_down_td, '')
+
+          # All items except the leftmost next have a line from skip-over-items line down to their entry,
+          # with joining-lines at their entry and at their skip-under-item line:
+          lines = (['  '] * top_to_soil) + [line + roundcorner_top_right +
+                                            # All such items except the rightmost also have a continuation of the skip-over-items line:
+                                            (i < item_tds.size - 1 ? line : ' ')] +
+                  ([" #{line_vertical} "] * (diagram_td.exit - top_to_soil - 1)) +
+                  [line + roundcorner_bot_left + line] +
+                  ([' ' * 3] * (item_td.height - item_td.entry - 1)) +
+                  [line * 3]
+
+          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 i < item_tds.size - 1
+          # All items except the rightmost have 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 = [line * item_td.width] + ([' ' * item_td.width] * (soil_height - item_td.entry))
+          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 i.positive?
+          # All items except the leftmost have their skip-under-item line at the bottom.
+          soil_segment = TextDiagram.new(0, 0, [line * item_td.width])
+          part_td = part_td.append_below(soil_segment, [])
+        end
+
+        diagram_td = diagram_td.append_right(part_td, '')
+
+        next unless i.positive?
+
+        # All items except the leftmost have a line from their skip-under-item line to their exit:
+        lines = (['  '] * top_to_soil) +
+                # All such items except the rightmost also have a joining-line across at the skip-over-items line:
+                [(i < item_tds.size - 1 ? line * 2 : '  ')] +
+                (['  '] * (diagram_td.exit - top_to_soil - 1)) +
+                [line + roundcorner_top_left] +
+                ([" #{line_vertical}"] * (part_td.height - part_td.exit - 2)) +
+                [line + roundcorner_bot_right]
+
+        skip_up_td = TextDiagram.new(diagram_td.exit, diagram_td.exit, lines)
+        diagram_td = diagram_td.append_right(skip_up_td, '')
+      end
+
+      diagram_td
+    end
+  end
+end

data/lib/railroad_diagrams/path.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Path
+    attr_reader :x, :y, :attrs
+
+    def initialize(x, y)
+      @x = x
+      @y = y
+      @attrs = { 'd' => "M#{x} #{y}" }
+    end
+
+    def m(x, y)
+      @attrs['d'] += "m#{x} #{y}"
+      self
+    end
+
+    def l(x, y)
+      @attrs['d'] += "l#{x} #{y}"
+      self
+    end
+
+    def h(val)
+      @attrs['d'] += "h#{val}"
+      self
+    end
+
+    def right(val)
+      h([0, val].max)
+    end
+
+    def left(val)
+      h(-[0, val].max)
+    end
+
+    def v(val)
+      @attrs['d'] += "v#{val}"
+      self
+    end
+
+    def down(val)
+      v([0, val].max)
+    end
+
+    def up(val)
+      v(-[0, val].max)
+    end
+
+    def arc_8(start, dir)
+      arc = AR
+      s2 = 1 / Math.sqrt(2) * arc
+      s2inv = arc - s2
+      sweep = dir == 'cw' ? '1' : '0'
+      path = "a #{arc} #{arc} 0 0 #{sweep} "
+
+      sd = start + dir
+      offset = case sd
+               when 'ncw' then [s2, s2inv]
+               when 'necw' then [s2inv, s2]
+               when 'ecw' then [-s2inv, s2]
+               when 'secw' then [-s2, s2inv]
+               when 'scw' then [-s2, -s2inv]
+               when 'swcw' then [-s2inv, -s2]
+               when 'wcw' then [s2inv, -s2]
+               when 'nwcw' then [s2, -s2inv]
+               when 'nccw' then [-s2, s2inv]
+               when 'nwccw' then [-s2inv, s2]
+               when 'wccw' then [s2inv, s2]
+               when 'swccw' then [s2, s2inv]
+               when 'sccw' then [s2, -s2inv]
+               when 'seccw' then [s2inv, -s2]
+               when 'eccw' then [-s2inv, -s2]
+               when 'neccw' then [-s2, -s2inv]
+               end
+
+      path += offset.map(&:to_s).join(' ')
+      @attrs['d'] += path
+      self
+    end
+
+    def arc(sweep)
+      x = AR
+      y = AR
+      x *= -1 if sweep[0] == 'e' || sweep[1] == 'w'
+      y *= -1 if sweep[0] == 's' || sweep[1] == 'n'
+      cw = %w[ne es sw wn].include?(sweep) ? 1 : 0
+      @attrs['d'] += "a#{AR} #{AR} 0 0 #{cw} #{x} #{y}"
+      self
+    end
+
+    def add(parent)
+      parent.children << self
+      self
+    end
+
+    def write_svg(write)
+      write.call('<path')
+      @attrs.sort.each do |name, value|
+        write.call(" #{name}=\"#{RailroadDiagrams.escape_attr(value)}\"")
+      end
+      write.call(' />')
+    end
+
+    def format
+      @attrs['d'] += 'h.5'
+      self
+    end
+
+    def text_diagram
+      TextDiagram.new(0, 0, [])
+    end
+
+    def to_s
+      "Path(#{@x.inspect}, #{@y.inspect})"
+    end
+  end
+end

data/lib/railroad_diagrams/sequence.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Sequence < DiagramMultiContainer
+    def initialize(*items)
+      super('g', items)
+      @needs_space = false
+      @up = 0
+      @down = 0
+      @height = 0
+      @width = 0
+      @items.each do |item|
+        @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
+    end
+
+    def to_s
+      items = @items.map(&:to_s).join(', ')
+      "Sequence(#{items})"
+    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
+      @items.each_with_index do |item, i|
+        if item.needs_space && i.positive?
+          Path.new(x, y).h(10).add(self)
+          x += 10
+        end
+        item.format(x, y, item.width).add(self)
+        x += item.width
+        y += item.height
+        if item.needs_space && i < @items.length - 1
+          Path.new(x, y).h(10).add(self)
+          x += 10
+        end
+      end
+      self
+    end
+
+    def text_diagram
+      separator, = TextDiagram.get_parts(['separator'])
+      diagram_td = TextDiagram.new(0, 0, [''])
+      @items.each do |item|
+        item_td = item.text_diagram
+        item_td = item_td.expand(1, 1, 0, 0) if item.needs_space
+        diagram_td = diagram_td.append_right(item_td, separator)
+      end
+      diagram_td
+    end
+  end
+end