railroad_diagrams 0.1.0

data/lib/railroad_diagrams/skip.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Skip < DiagramItem
+    def initialize
+      super('g')
+      @width = 0
+      @up = 0
+      @down = 0
+    end
+
+    def to_s
+      'Skip()'
+    end
+
+    def format(x, y, width)
+      Path.new(x, y).right(width).add(self)
+      self
+    end
+
+    def text_diagram
+      line, = TextDiagram.get_parts(['line'])
+      TextDiagram.new(0, 0, [line])
+    end
+  end
+end

data/lib/railroad_diagrams/stack.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Stack < DiagramMultiContainer
+    def initialize(*items)
+      super('g', items)
+      @need_space = false
+      @width = @items.map { |item| item.width + (item.needs_space ? 20 : 0) }.max
+
+      # pretty sure that space calc is totes wrong
+      @width += AR * 2 if @items.size > 1
+
+      @up = @items.first.up
+      @down = @items.last.down
+      @height = 0
+      last = @items.size - 1
+
+      @items.each_with_index do |item, i|
+        @height += item.height
+        @height += [AR * 2, item.up + VS].max if i.positive?
+        @height += [AR * 2, item.down + VS].max if i < last
+      end
+    end
+
+    def to_s
+      items = @items.map(&:to_s).join(', ')
+      "Stack(#{items})"
+    end
+
+    def format(x, y, width)
+      left_gap, right_gap = determine_gaps(width, @width)
+      Path.new(x, y).h(left_gap).add(self)
+      x += left_gap
+      x_initial = x
+      if @items.size > 1
+        Path.new(x, y).h(AR).add(self)
+        x += AR
+        inner_width = @width - (AR * 2)
+      else
+        inner_width = @width
+      end
+
+      @items.each_with_index do |item, i|
+        item.format(x, y, inner_width).add(self)
+        x += inner_width
+        y += item.height
+        next unless i != @items.size - 1
+
+        Path.new(x, y)
+            .arc('ne')
+            .down([0, item.down + VS - (AR * 2)].max)
+            .arc('es')
+            .left(inner_width)
+            .arc('nw')
+            .down([0, @items[i + 1].up + VS - (AR * 2)].max)
+            .arc('ws')
+            .add(self)
+        y += [item.down + VS, AR * 2].max + [@items[i + 1].up + VS, AR * 2].max
+        x = x_initial + AR
+      end
+      if @items.size > 1
+        Path.new(x, y).h(AR).add(self)
+        x += AR
+      end
+      Path.new(x, y).h(right_gap).add(self)
+      self
+    end
+
+    def text_diagram
+      corner_bot_left, corner_bot_right, corner_top_left, corner_top_right, line, line_vertical = TextDiagram.get_parts(
+        %w[corner_bot_left corner_bot_right corner_top_left corner_top_right line line_vertical]
+      )
+
+      # Format all the child items, so we can know the maximum width.
+      item_tds = @items.map(&:text_diagram)
+      max_width = item_tds.map(&:width).max
+      left_lines = []
+      right_lines = []
+      separator_td = TextDiagram.new(0, 0, [line * max_width])
+      diagram_td = nil # Top item will replace it.
+      item_tds.each_with_index do |item_td, item_num|
+        if item_num.zero?
+          # The top item enters directly from its left.
+          left_lines += [line * 2]
+          left_lines += [' ' * 2] * (item_td.height - item_td.entry - 1)
+        else
+          # All items below the top enter from a snake-line from the previous item's exit.
+          # Here, we resume that line, already having descended from above on the right.
+          diagram_td = diagram_td.append_below(separator_td, [])
+          left_lines += [corner_top_left + line]
+          left_lines += ["#{line_vertical} "] * item_td.entry
+          left_lines += [corner_bot_left + line]
+          left_lines += [' ' * 2] * (item_td.height - item_td.entry - 1)
+          right_lines += [' ' * 2] * item_td.exit
+        end
+        if item_num < item_tds.size - 1
+          # All items above the bottom exit via a snake-line to the next item's entry.
+          # Here, we start that line on the right.
+          right_lines += [line + corner_top_right]
+          right_lines += [" #{line_vertical}"] * (item_td.height - item_td.exit - 1)
+          right_lines += [line + corner_bot_right]
+        else
+          # The bottom item exits directly to its right.
+          right_lines += [line * 2]
+        end
+        left_pad, right_pad = TextDiagram._gaps(max_width, item_td.width)
+        item_td = item_td.expand(left_pad, right_pad, 0, 0)
+        diagram_td = if item_num.zero?
+                       item_td
+                     else
+                       diagram_td.append_below(item_td, [])
+                     end
+      end
+      left_td = TextDiagram.new(0, 0, left_lines)
+      diagram_td = left_td.append_right(diagram_td, '')
+      right_td = TextDiagram.new(0, right_lines.size - 1, right_lines)
+      diagram_td.append_right(right_td, '')
+    end
+  end
+end

data/lib/railroad_diagrams/start.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Start < DiagramItem
+    def initialize(type = 'simple', label: nil)
+      super('g')
+      @width =
+        if label
+          [20, (label.length * CHAR_WIDTH) + 10].max
+        else
+          20
+        end
+      @up = 10
+      @down = 10
+      @type = type
+      @label = label
+    end
+
+    def to_s
+      "Start(#{@type}, label=#{@label})"
+    end
+
+    def format(x, y, _width)
+      path = Path.new(x, y - 10)
+      if @type == 'complex'
+        path.down(20).m(0, -10).right(@width).add(self)
+      else
+        path.down(20).m(10, -20).down(20).m(-10, -10).right(@width).add(self)
+      end
+      if @label
+        DiagramItem.new(
+          'text',
+          attrs: {
+            'x' => x,
+            'y' => y - 15,
+            'style' => 'text-anchor:start'
+          },
+          text: @label
+        ).add(self)
+      end
+      self
+    end
+
+    def text_diagram
+      cross, line, tee_right = TextDiagram.get_parts(%w[cross line tee_right])
+      start =
+        if @type == 'simple'
+          tee_right + cross + line
+        else
+          tee_right + line
+        end
+
+      label_td = TextDiagram.new(0, 0, [])
+      if @label
+        label_td = TextDiagram.new(0, 0, [@label])
+        start = TextDiagram.pad_r(start, label_td.width, line)
+      end
+      start_td = TextDiagram.new(0, 0, [start])
+      label_td.append_below(start_td, [], move_entry: true, move_exit: true)
+    end
+  end
+end

data/lib/railroad_diagrams/style.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Style
+    def initialize(css)
+      @css = css
+    end
+
+    class << self
+      def default_style
+        <<~CSS
+          svg.railroad-diagram {
+            background-color:hsl(30,20%,95%);
+          }
+          svg.railroad-diagram path {
+            stroke-width:3;
+            stroke:black;
+            fill:rgba(0,0,0,0);
+          }
+          svg.railroad-diagram text {
+            font:bold 14px monospace;
+            text-anchor:middle;
+          }
+          svg.railroad-diagram text.label{
+            text-anchor:start;
+          }
+          svg.railroad-diagram text.comment{
+            font:italic 12px monospace;
+          }
+          svg.railroad-diagram rect{
+            stroke-width:3;
+            stroke:black;
+            fill:hsl(120,100%,90%);
+          }
+          svg.railroad-diagram rect.group-box {
+            stroke: gray;
+            stroke-dasharray: 10 5;
+            fill: none;
+          }
+        CSS
+      end
+    end
+
+    def to_s
+      "Style(#{@css})"
+    end
+
+    def add(parent)
+      parent.children.push(self)
+      self
+    end
+
+    def format
+      self
+    end
+
+    def text_diagram
+      TextDiagram.new
+    end
+
+    def write_svg(write)
+      # Write included stylesheet as CDATA. See https://developer.mozilla.org/en-US/docs/Web/SVG/Element/style
+      cdata = "/* <![CDATA[ */\n#{@css}\n/* ]]> */\n"
+      write.call("<style>#{cdata}</style>")
+    end
+  end
+end

data/lib/railroad_diagrams/terminal.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class Terminal < DiagramItem
+    def initialize(text, href = nil, title = nil, cls: '')
+      super('g', attrs: { 'class' => "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
+      "Terminal(#{@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,
+          'rx' => 10,
+          'ry' => 10
+        }
+      ).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.round_rect(@text)
+    end
+  end
+end

data/lib/railroad_diagrams/text_diagram.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class TextDiagram
+    PARTS_UNICODE = {
+      'cross_diag' => '╳',
+      'corner_bot_left' => '└',
+      'corner_bot_right' => '┘',
+      'corner_top_left' => '┌',
+      'corner_top_right' => '┐',
+      'cross' => '┼',
+      'left' => '│',
+      'line' => '─',
+      'line_vertical' => '│',
+      'multi_repeat' => '↺',
+      'rect_bot' => '─',
+      'rect_bot_dashed' => '┄',
+      'rect_bot_left' => '└',
+      'rect_bot_right' => '┘',
+      'rect_left' => '│',
+      'rect_left_dashed' => '┆',
+      'rect_right' => '│',
+      'rect_right_dashed' => '┆',
+      'rect_top' => '─',
+      'rect_top_dashed' => '┄',
+      'rect_top_left' => '┌',
+      'rect_top_right' => '┐',
+      'repeat_bot_left' => '╰',
+      'repeat_bot_right' => '╯',
+      'repeat_left' => '│',
+      'repeat_right' => '│',
+      'repeat_top_left' => '╭',
+      'repeat_top_right' => '╮',
+      'right' => '│',
+      'roundcorner_bot_left' => '╰',
+      'roundcorner_bot_right' => '╯',
+      'roundcorner_top_left' => '╭',
+      'roundcorner_top_right' => '╮',
+      'roundrect_bot' => '─',
+      'roundrect_bot_dashed' => '┄',
+      'roundrect_bot_left' => '╰',
+      'roundrect_bot_right' => '╯',
+      'roundrect_left' => '│',
+      'roundrect_left_dashed' => '┆',
+      'roundrect_right' => '│',
+      'roundrect_right_dashed' => '┆',
+      'roundrect_top' => '─',
+      'roundrect_top_dashed' => '┄',
+      'roundrect_top_left' => '╭',
+      'roundrect_top_right' => '╮',
+      'separator' => '─',
+      'tee_left' => '┤',
+      'tee_right' => '├'
+    }.freeze
+
+    PARTS_ASCII = {
+      'cross_diag' => 'X',
+      'corner_bot_left' => '\\',
+      'corner_bot_right' => '/',
+      'corner_top_left' => '/',
+      'corner_top_right' => '\\',
+      'cross' => '+',
+      'left' => '|',
+      'line' => '-',
+      'line_vertical' => '|',
+      'multi_repeat' => '&',
+      'rect_bot' => '-',
+      'rect_bot_dashed' => '-',
+      'rect_bot_left' => '+',
+      'rect_bot_right' => '+',
+      'rect_left' => '|',
+      'rect_left_dashed' => '|',
+      'rect_right' => '|',
+      'rect_right_dashed' => '|',
+      'rect_top' => '-',
+      'rect_top_dashed' => '-',
+      'rect_top_left' => '+',
+      'rect_top_right' => '+',
+      'repeat_bot_left' => '\\',
+      'repeat_bot_right' => '/',
+      'repeat_left' => '|',
+      'repeat_right' => '|',
+      'repeat_top_left' => '/',
+      'repeat_top_right' => '\\',
+      'right' => '|',
+      'roundcorner_bot_left' => '\\',
+      'roundcorner_bot_right' => '/',
+      'roundcorner_top_left' => '/',
+      'roundcorner_top_right' => '\\',
+      'roundrect_bot' => '-',
+      'roundrect_bot_dashed' => '-',
+      'roundrect_bot_left' => '\\',
+      'roundrect_bot_right' => '/',
+      'roundrect_left' => '|',
+      'roundrect_left_dashed' => '|',
+      'roundrect_right' => '|',
+      'roundrect_right_dashed' => '|',
+      'roundrect_top' => '-',
+      'roundrect_top_dashed' => '-',
+      'roundrect_top_left' => '/',
+      'roundrect_top_right' => '\\',
+      'separator' => '-',
+      'tee_left' => '|',
+      'tee_right' => '|'
+    }.freeze
+
+    class << self
+      attr_accessor :parts
+
+      def set_formatting(characters = nil, defaults = nil)
+        return unless characters
+
+        @parts = defaults ? defaults.dup : {}
+        @parts.merge!(characters)
+        @parts.each do |name, value|
+          raise ArgumentError, "Text part #{name} is more than 1 character: #{value}" if value.size != 1
+        end
+      end
+
+      def rect(item, dashed = false)
+        rectish('rect', item, dashed)
+      end
+
+      def round_rect(item, dashed = false)
+        rectish('roundrect', item, dashed)
+      end
+
+      def pad_l(string, width, pad)
+        gap = width - string.length
+        raise "Gap #{gap} must be a multiple of pad string '#{pad}'" unless gap % pad.length == 0
+
+        (pad * (gap / pad.length)) + string
+      end
+
+      def pad_r(string, width, pad)
+        gap = width - string.length
+        raise "Gap #{gap} must be a multiple of pad string '#{pad}'" unless gap % pad.length == 0
+
+        string + (pad * (gap / pad.length))
+      end
+
+      private
+
+      def rectish(rect_type, data, dashed)
+        line_type = dashed ? '_dashed' : ''
+        parts = get_parts([
+                            "#{rect_type}_top_left",
+                            "#{rect_type}_left#{line_type}",
+                            "#{rect_type}_bot_left",
+                            "#{rect_type}_top_right",
+                            "#{rect_type}_right#{line_type}",
+                            "#{rect_type}_bot_right",
+                            "#{rect_type}_top#{line_type}",
+                            "#{rect_type}_bot#{line_type}",
+                            'line',
+                            'cross'
+                          ])
+
+        item_td = data.is_a?(TextDiagram) ? data : new(0, 0, [data.to_s])
+
+        lines = [parts[6] * (item_td.width + 2)]
+        lines += item_td.expand(1, 1, 0, 0).lines.map { |line| " #{line} " }
+        lines << (parts[7] * (item_td.width + 2))
+
+        entry = item_td.entry + 1
+        exit = item_td.exit + 1
+
+        left_max = [parts[0], parts[1], parts[2]].map(&:size).max
+        lefts = Array.new(lines.size, parts[1].ljust(left_max))
+        lefts[0] = parts[0].ljust(left_max, parts[6])
+        lefts[-1] = parts[2].ljust(left_max, parts[7])
+        lefts[entry] = parts[9].ljust(left_max) if data.is_a?(TextDiagram)
+
+        right_max = [parts[3], parts[4], parts[5]].map(&:size).max
+        rights = Array.new(lines.size, parts[4].rjust(right_max))
+        rights[0] = parts[3].rjust(right_max, parts[6])
+        rights[-1] = parts[5].rjust(right_max, parts[7])
+        rights[exit] = parts[9].rjust(right_max) if data.is_a?(TextDiagram)
+
+        new_lines = lines.each_with_index.map do |line, i|
+          lefts[i] + line + rights[i]
+        end
+
+        lefts = Array.new(lines.size, ' ')
+        lefts[entry] = parts[8]
+        rights = Array.new(lines.size, ' ')
+        rights[exit] = parts[8]
+
+        new_lines = new_lines.each_with_index.map do |line, i|
+          lefts[i] + line + rights[i]
+        end
+
+        new(entry, exit, new_lines)
+      end
+
+      def enclose_lines(lines, lefts, rights)
+        unless lines.length == lefts.length && lines.length == rights.length
+          raise 'All arguments must be the same length'
+        end
+
+        lines.each_with_index.map { |line, i| lefts[i] + line + rights[i] }
+      end
+
+      def gaps(outer_width, inner_width)
+        diff = outer_width - inner_width
+        case INTERNAL_ALIGNMENT
+        when 'left'
+          [0, diff]
+        when 'right'
+          [diff, 0]
+        else
+          left = diff / 2
+          right = diff - left
+          [left, right]
+        end
+      end
+
+      def get_parts(part_names)
+        part_names.map { |name| @parts[name] }
+      end
+    end
+
+    attr_reader :entry, :exit, :height, :lines, :width
+
+    def initialize(entry, exit, lines)
+      @entry = entry
+      @exit = exit
+      @lines = lines.dup
+      @height = lines.size
+      @width = lines.empty? ? 0 : lines.first.size
+
+      validate
+    end
+
+    def alter(new_entry = nil, new_exit = nil, new_lines = nil)
+      self.class.new(
+        new_entry || @entry,
+        new_exit || @exit,
+        new_lines || @lines.dup
+      )
+    end
+
+    def append_below(item, lines_between, move_entry: false, move_exit: false)
+      new_width = [@width, item.width].max
+      new_lines = center(new_width).lines
+      lines_between.each { |line| new_lines << TextDiagram.pad_r(line, new_width, ' ') }
+      new_lines += item.center(new_width).lines
+
+      new_entry = move_entry ? @height + lines_between.size + item.entry : @entry
+      new_exit = move_exit ? @height + lines_between.size + item.exit : @exit
+
+      self.class.new(new_entry, new_exit, new_lines)
+    end
+
+    def append_right(item, chars_between)
+      join_line = [@exit, item.entry].max
+      new_height = [@height - @exit, item.height - item.entry].max + join_line
+
+      left = expand(0, 0, join_line - @exit, new_height - @height - (join_line - @exit))
+      right = item.expand(0, 0, join_line - item.entry, new_height - item.height - (join_line - item.entry))
+
+      new_lines = (0...new_height).map do |i|
+        sep = i == join_line ? chars_between : ' ' * chars_between.size
+        left_line = i < left.lines.size ? left.lines[i] : ' ' * left.width
+        right_line = i < right.lines.size ? right.lines[i] : ' ' * right.width
+        "#{left_line}#{sep}#{right_line}"
+      end
+
+      self.class.new(
+        @entry + (join_line - @exit),
+        item.exit + (join_line - item.entry),
+        new_lines
+      )
+    end
+
+    def center(new_width, pad = ' ')
+      raise 'Cannot center into smaller width' if width < @width
+      return copy if new_width == @width
+
+      total_padding = new_width - @width
+      left_width = total_padding / 2
+      left = [pad * left_width] * @height
+      right = [pad * (total_padding - left_width)] * @height
+
+      self.class.new(@entry, @exit, enclose_lines(@lines, left, right))
+    end
+
+    def copy
+      self.class.new(@entry, @exit, @lines.dup)
+    end
+
+    def expand(left, right, top, bottom)
+      return copy if [left, right, top, bottom].all?(&:zero?)
+
+      new_lines = []
+      top.times { new_lines << (' ' * (@width + left + right)) }
+
+      @lines.each do |line|
+        left_part = (line == @lines[@entry] ? self.class.parts['line'] : ' ') * left
+        right_part = (line == @lines[@exit] ? self.class.parts['line'] : ' ') * right
+        new_lines << "#{left_part}#{line}#{right_part}"
+      end
+
+      bottom.times { new_lines << (' ' * (@width + left + right)) }
+
+      self.class.new(
+        @entry + top,
+        @exit + top,
+        new_lines
+      )
+    end
+
+    private
+
+    def validate
+      return if @lines.empty?
+
+      line_length = @lines.first.size
+      @lines.each do |line|
+        raise ArgumentError, "Diagram is not rectangular:\n#{inspect}" unless line.size == line_length
+      end
+
+      raise ArgumentError, "Entry point out of bounds:\n#{inspect}" if @entry >= @height
+
+      return unless @exit >= @height
+
+      raise ArgumentError, "Exit point out of bounds:\n#{inspect}"
+    end
+
+    def inspect
+      output = ["TextDiagram(entry=#{@entry}, exit=#{@exit}, height=#{@height})"]
+      @lines.each_with_index do |line, i|
+        marker = []
+        marker << 'entry' if i == @entry
+        marker << 'exit' if i == @exit
+        output << (format('%3d: %-20s %s', i, line.inspect, marker.join(', ')))
+      end
+      output.join("\n")
+    end
+  end
+end

data/lib/railroad_diagrams/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  VERSION = '0.1.0'
+end

data/lib/railroad_diagrams/zero_or_more.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RailroadDiagrams
+  class ZeroOrMore
+    def self.new(item, repeat = nil, skip = false)
+      Optional.new(OneOrMore.new(item, repeat), skip)
+    end
+  end
+end