merminal 0.1.0

data/lib/merminal/diagrams/base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Merminal
+  module Diagrams
+    Text = Merminal::Text
+    Scene = Merminal::Scene
+    Flowchart = Merminal::Flowchart
+
+    # Shared Scene assembly for diagram plugins.
+    class Builder
+      def initialize
+        @items = []
+        @width = 0
+        @height = 0
+      end
+
+      def text(x, y, string, role: :node_text)
+        string.to_s.split("\n", -1).each_with_index do |line, offset|
+          @items << Scene::Text.new(x: x, y: y + offset, string: line, role: role, layer: :label, emphasis: nil)
+          reach(x + Text.width(line), y + offset + 1)
+        end
+      end
+
+      def box(x, y, width, height, role: :node_border, rounded: false)
+        @items << Scene::Box.new(rect: Scene::Rect.new(x: x, y: y, width: width, height: height),
+                                 stroke: Scene::LIGHT, corners: rounded ? :rounded : :sharp, role: role,
+                                 layer: role == :container_border ? :container : :node)
+        reach(x + width, y + height)
+      end
+
+      def line(points, role: :edge, weight: :light, pattern: :solid)
+        @items << Scene::Polyline.new(points: points, stroke: Scene::Stroke.new(weight: weight, pattern: pattern),
+                                      role: role, layer: :edge)
+        points.each { |x, y| reach(x + 1, y + 1) }
+      end
+
+      def marker(x, y, kind: :arrow, direction: :e)
+        @items << Scene::Marker.new(x: x, y: y, kind: kind, direction: direction, role: :marker, layer: :marker)
+        reach(x + 1, y + 1)
+      end
+
+      def glyph(x, y, char, role: :series_1)
+        @items << Scene::Glyph.new(x: x, y: y, char: char, role: role, layer: :marker)
+        reach(x + 1, y + 1)
+      end
+
+      def scene
+        Scene.new(width: @width, height: @height, items: @items.freeze)
+      end
+
+      private
+
+      def reach(x, y)
+        @width = [@width, x].max
+        @height = [@height, y].max
+      end
+    end
+
+    module_function
+
+    def finding(message, source, index, severity: :error)
+      Diagnostic.new(severity: severity, message: message, line: source.line_map[index] || 1, column: 1, length: 1)
+    end
+  end
+end

data/lib/merminal/diagrams/gantt.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Merminal::Diagrams
+  # Date based Mermaid Gantt chart.
+  module Gantt
+    Task = Data.define(:name, :state, :start_date, :end_date, :section)
+    Diagram = Data.define(:title, :tasks)
+    def self.diagram_type = :gantt
+    def self.keywords = %w[gantt]
+
+    def self.parse(source)
+      title = source.title
+      format = "%Y-%m-%d"
+      section = nil
+      weekends = false
+      tasks = []
+      by_id = {}
+      findings = []
+      source.lines.drop(1).each_with_index do |line, index|
+        statement = line.strip
+        case statement
+        when /\Atitle\s+(.+)\z/
+          title = Regexp.last_match(1)
+        when /\AdateFormat\s+(.+)\z/
+          format = Regexp.last_match(1).gsub("YYYY", "%Y").gsub("MM", "%m").gsub("DD", "%d")
+        when /\Asection\s+(.+)\z/
+          section = Regexp.last_match(1)
+        when /\Aexcludes\s+weekends\z/
+          weekends = true
+        when /\A([^:]+)\s*:\s*(.+)\z/
+          name = Regexp.last_match(1).strip
+          pieces = Regexp.last_match(2).split(",").map(&:strip)
+          state = pieces.grep(/\A(?:done|active|crit|milestone)\z/).first&.to_sym
+          pieces.delete(state.to_s) if state
+          id = pieces.length > 2 ? pieces.shift : nil
+          start_token = pieces.shift
+          duration_token = pieces.shift
+          start_date = if start_token&.start_with?("after ")
+                         by_id[start_token.delete_prefix("after ")]&.end_date
+                       else
+                         Date.strptime(start_token.to_s, format)
+                       end
+          raise ArgumentError, "unknown start date" unless start_date
+
+          end_date = if duration_token =~ /\A(\d+)([dw])\z/
+                       days = Regexp.last_match(1).to_i * (Regexp.last_match(2) == "w" ? 7 : 1)
+                       advance(start_date, days, weekends)
+                     else
+                       Date.strptime(duration_token.to_s, format)
+                     end
+          task = Task.new(name: name, state: state, start_date: start_date, end_date: end_date, section: section)
+          tasks << task
+          by_id[id] = task if id
+        when "", /\A(?:axisFormat|todayMarker|tickInterval)\b/
+          next
+        else
+          findings << Merminal::Diagrams.finding("unrecognized gantt statement", source, index + 1)
+        end
+      rescue ArgumentError
+        findings << Merminal::Diagrams.finding("invalid gantt task", source, index + 1)
+      end
+      [Diagram.new(title: title, tasks: tasks.freeze), findings]
+    end
+
+    def self.advance(start_date, days, weekends)
+      date = start_date
+      days.times do
+        date += 1
+        date += 1 while weekends && [0, 6].include?(date.wday)
+      end
+      date
+    end
+
+    def self.layout(ast, charset: :unicode, **)
+      builder = Builder.new
+      return builder.scene if ast.tasks.empty?
+
+      y = 0
+      if ast.title
+        builder.text(0, y, ast.title, role: :emphasis)
+        y += 2
+      end
+      first = ast.tasks.map(&:start_date).min
+      last = ast.tasks.map(&:end_date).max
+      span = [(last - first).to_i, 1].max
+      label_width = ast.tasks.map { |task| Text.width(task.name) }.max
+      bar_left = label_width + 3
+      builder.text(bar_left, y, "#{first} — #{last}", role: :axis_label)
+      y += 1
+      section = nil
+      ast.tasks.each do |task|
+        if task.section && task.section != section
+          section = task.section
+          builder.text(0, y, section, role: :container_title)
+          y += 1
+        end
+        builder.text(0, y, Text.pad(task.name, label_width))
+        offset = ((task.start_date - first).to_f / span * 40).round
+        size = [((task.end_date - task.start_date).to_f / span * 40).round, 1].max
+        char = task.state == :milestone ? (charset == :ascii ? "*" : "◆") : (charset == :ascii ? "#" : "█")
+        builder.text(bar_left + offset, y, char * (task.state == :milestone ? 1 : size), role: task.state == :done ? :muted : :series_1)
+        y += 1
+      end
+      builder.scene
+    end
+  end
+end

data/lib/merminal/diagrams/mindmap.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Merminal::Diagrams
+  # Indented Mermaid mindmap rendered as a tidy tree.
+  module Mindmap
+    Node = Data.define(:id, :label, :parent, :depth, :shape)
+    Diagram = Data.define(:nodes)
+    def self.diagram_type = :mindmap
+    def self.keywords = %w[mindmap]
+
+    def self.parse(source)
+      nodes = []
+      stack = []
+      findings = []
+      source.lines.drop(1).each_with_index do |line, index|
+        next if line.strip.empty?
+
+        indent = line[/\A\s*/].length
+        while stack.any? && stack.last[0] >= indent
+          stack.pop
+        end
+        if nodes.any? && stack.empty?
+          findings << Merminal::Diagrams.finding("mindmap node has no parent", source, index + 1)
+          next
+        end
+        raw = line.strip
+        shape, label = if raw =~ /\A(.+?)\)\)(.+)\(\(\z/
+                         [:cloud, Regexp.last_match(2)]
+                       elsif raw =~ /\A(.+?)\(\((.+)\)\)\z/
+                         [:circle, Regexp.last_match(2)]
+                       elsif raw =~ /\A(.+?)\[(.+)\]\z/
+                         [:rectangle, Regexp.last_match(2)]
+                       elsif raw =~ /\A(.+?)\((.+)\)\z/
+                         [:rounded, Regexp.last_match(2)]
+                       else
+                         [:rectangle, raw]
+                       end
+        id = nodes.length
+        nodes << Node.new(id: id, label: label, parent: stack.last&.last, depth: stack.length, shape: shape)
+        stack << [indent, id]
+      end
+      [Diagram.new(nodes: nodes.freeze), findings]
+    end
+
+    def self.layout(ast, **)
+      builder = Builder.new
+      return builder.scene if ast.nodes.empty?
+
+      children = ast.nodes.to_h { |node| [node.id, []] }
+      ast.nodes.each { |node| children[node.parent] << node.id if node.parent }
+      depth_widths = ast.nodes.group_by(&:depth).transform_values do |nodes|
+        nodes.map { |node| node_width(node) }.max
+      end
+      x_positions = {}
+      depth_widths.keys.sort.each { |depth| x_positions[depth] = depth.zero? ? 0 : x_positions[depth - 1] + depth_widths[depth - 1] + 5 }
+      y_positions = {}
+      next_leaf = 0
+      place = lambda do |id|
+        if children[id].empty?
+          y_positions[id] = next_leaf * 4
+          next_leaf += 1
+        else
+          children[id].each { |child| place.call(child) }
+          y_positions[id] = (y_positions[children[id].first] + y_positions[children[id].last]) / 2
+        end
+      end
+      place.call(ast.nodes.first.id)
+      ast.nodes.each do |node|
+        x, y = x_positions[node.depth], y_positions[node.id]
+        width = node_width(node)
+        builder.box(x, y, width, 3, rounded: node.shape != :rectangle)
+        builder.text(x + (width - Text.width(node.label)) / 2, y + 1, node.label)
+        if %i[circle cloud].include?(node.shape)
+          left, right = node.shape == :circle ? %w[( )] : %w[~ ~]
+          builder.glyph(x, y + 1, left, role: :node_border)
+          builder.glyph(x + width - 1, y + 1, right, role: :node_border)
+        end
+        next unless node.parent
+
+        parent = ast.nodes[node.parent]
+        px = x_positions[parent.depth] + node_width(parent) - 1
+        py = y_positions[parent.id] + 1
+        cy = y + 1
+        middle = (px + x) / 2
+        builder.line([[px, py], [middle, py], [middle, cy], [x, cy]])
+      end
+      builder.scene
+    end
+
+    def self.node_width(node)
+      Text.width(node.label) + (%i[circle cloud].include?(node.shape) ? 6 : 4)
+    end
+  end
+end

data/lib/merminal/diagrams/pie.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Merminal::Diagrams
+  # Mermaid pie data as proportional horizontal bars.
+  module Pie
+    Diagram = Data.define(:title, :show_data, :entries)
+    def self.diagram_type = :pie
+    def self.keywords = %w[pie]
+
+    def self.parse(source)
+      title = source.title
+      show_data = source.lines.first.to_s.include?("showData")
+      entries = []
+      findings = []
+      source.lines.drop(1).each_with_index do |line, index|
+        case line.strip
+        when /\Atitle\s+(.+)\z/i
+          title = Regexp.last_match(1)
+        when /\AshowData\z/i
+          show_data = true
+        when /\A["'](.+?)["']\s*:\s*(-?\d+(?:\.\d+)?)\z/
+          value = Regexp.last_match(2).to_f
+          if value.negative?
+            findings << Merminal::Diagrams.finding("pie values must be nonnegative", source, index + 1)
+          else
+            entries << [Regexp.last_match(1), value]
+          end
+        when ""
+          next
+        else
+          findings << Merminal::Diagrams.finding("unrecognized pie statement", source, index + 1)
+        end
+      end
+      [Diagram.new(title: title, show_data: show_data, entries: entries.freeze), findings]
+    end
+
+    def self.layout(ast, charset: :unicode, **)
+      builder = Builder.new
+      y = 0
+      if ast.title
+        builder.text(0, y, ast.title, role: :emphasis)
+        y += 2
+      end
+      total = ast.entries.sum(&:last)
+      label_width = ast.entries.map { |label, _| Text.width(label) }.max.to_i
+      ast.entries.each do |label, value|
+        fraction = total.zero? ? 0 : value / total
+        eighths = (fraction * 30 * 8).round
+        bar = if charset == :ascii
+                "#" * (eighths / 8) + (eighths % 8 > 0 ? "+" : "")
+              else
+                "█" * (eighths / 8) + (eighths % 8 > 0 ? %w[▏ ▎ ▍ ▌ ▋ ▊ ▉][eighths % 8 - 1] : "")
+              end
+        builder.text(0, y, Text.pad(label, label_width))
+        builder.text(label_width + 2, y, bar, role: :series_1)
+        suffix = format("%5.1f%%", fraction * 100)
+        suffix += " (#{format('%g', value)})" if ast.show_data
+        builder.text(label_width + 34, y, suffix, role: :axis_label)
+        y += 1
+      end
+      builder.scene
+    end
+  end
+end

data/lib/merminal/diagrams/sequence.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Merminal::Diagrams
+  # Participants and chronological events of a Mermaid sequence diagram.
+  module Sequence
+    Participant = Data.define(:id, :label, :actor)
+    Event = Data.define(:kind, :from, :to, :text, :extra)
+    Diagram = Data.define(:participants, :events)
+    MESSAGE = /\A([\w.]+(?:-(?![-=>x])[\w.]+)*)\s*(-->>|->>|-->|->|--x|-x|--\)|-\))\s*([+-]?)([\w.-]+)\s*:\s*(.*)\z/
+    def self.diagram_type = :sequence
+    def self.keywords = %w[sequenceDiagram]
+
+    def self.parse(source)
+      participants = {}
+      events = []
+      findings = []
+      blocks = []
+      source.lines.drop(1).each_with_index do |line, index|
+        statement = line.strip
+        case statement
+        when /\A(participant|actor)\s+(\S+)(?:\s+as\s+(.+))?\z/
+          participants[Regexp.last_match(2)] = Participant.new(id: Regexp.last_match(2),
+                                                                 label: Regexp.last_match(3) || Regexp.last_match(2),
+                                                                 actor: Regexp.last_match(1) == "actor")
+        when MESSAGE
+          from, operator, activation, to, text = Regexp.last_match.captures
+          [from, to].each { |id| participants[id] ||= Participant.new(id: id, label: id, actor: false) }
+          events << Event.new(kind: :message, from: from, to: to, text: text, extra: operator)
+          events << Event.new(kind: activation == "+" ? :activate : :deactivate,
+                              from: activation == "+" ? to : from, to: nil, text: nil, extra: nil) unless activation.empty?
+        when /\ANote\s+(left of|right of|over)\s+([^:]+):\s*(.*)\z/i
+          side, ids, text = Regexp.last_match.captures
+          ids.split(",").each { |id| participants[id.strip] ||= Participant.new(id: id.strip, label: id.strip, actor: false) }
+          events << Event.new(kind: :note, from: ids.split(",").first.strip, to: ids.split(",").last.strip,
+                              text: text.gsub(/<br\s*\/?\s*>/i, "\n"), extra: side.downcase)
+        when /\A(loop|alt|opt|par|critical|break|rect)\b\s*(.*)\z/i
+          blocks << Regexp.last_match(1)
+          events << Event.new(kind: :block_start, from: nil, to: nil, text: Regexp.last_match(2), extra: Regexp.last_match(1))
+        when /\A(else|and)\b\s*(.*)\z/i
+          if blocks.empty?
+            findings << Merminal::Diagrams.finding("unexpected sequence branch", source, index + 1)
+          else
+            events << Event.new(kind: :block_else, from: nil, to: nil, text: Regexp.last_match(2), extra: Regexp.last_match(1))
+          end
+        when "end"
+          if blocks.empty?
+            findings << Merminal::Diagrams.finding("unexpected end", source, index + 1)
+          else
+            blocks.pop
+            events << Event.new(kind: :block_end, from: nil, to: nil, text: nil, extra: nil)
+          end
+        when /\A(activate|deactivate)\s+(\S+)\z/i
+          id = Regexp.last_match(2)
+          participants[id] ||= Participant.new(id: id, label: id, actor: false)
+          events << Event.new(kind: Regexp.last_match(1).downcase.to_sym, from: id, to: nil, text: nil, extra: nil)
+        when /\Aautonumber\b/
+          events << Event.new(kind: :autonumber, from: nil, to: nil, text: nil, extra: nil)
+        when ""
+          next
+        else
+          findings << Merminal::Diagrams.finding("unrecognized sequence statement", source, index + 1)
+        end
+      end
+      findings << Merminal::Diagrams.finding("unclosed sequence block", source, source.lines.length - 1) unless blocks.empty?
+      [Diagram.new(participants: participants.values.freeze, events: events.freeze), findings]
+    end
+
+    def self.layout(ast, repeat_participants: false, **)
+      builder = Builder.new
+      return builder.scene if ast.participants.empty?
+
+      ids = ast.participants.map(&:id)
+      gaps = ast.participants.each_cons(2).map do |left, right|
+        [14, (Text.width(left.label) + 5) / 2 + (Text.width(right.label) + 5) / 2 + 4].max
+      end
+      numbered = false
+      ast.events.each do |event|
+        numbered = true if event.kind == :autonumber
+        next unless event.kind == :message && event.from != event.to
+
+        a, b = [ids.index(event.from), ids.index(event.to)].sort
+        needed = Text.width(event.text) + 4 + (numbered ? 6 : 0)
+        current = gaps[a...b].sum
+        gaps[b - 1] += needed - current if current < needed
+      end
+      left_note = ast.events.select { |event| event.kind == :note && event.extra == "left of" && event.from == ids.first }
+      left_margin = left_note.map { |event| Text.width(event.text) + 4 }.max.to_i
+      first_width = Text.width(ast.participants.first.label) + 4
+      centers = [[5 + left_margin, first_width / 2 + 1].max]
+      gaps.each { |gap| centers << centers[-1] + gap }
+      columns = ids.zip(centers).to_h
+      rows = []
+      y = 4
+      autonumber = false
+      number = 0
+      ast.events.each do |event|
+        next autonumber = true if event.kind == :autonumber
+
+        label = event.text
+        if event.kind == :message && autonumber
+          number += 1
+          label = "#{number}. #{label}"
+        end
+        rows << [event, y, label]
+        y += case event.kind
+             when :message then event.from == event.to ? 4 : 3
+             when :note then label.count("\n") + 4
+             when :block_start, :block_else then 2
+             else 1
+             end
+      end
+      bottom = y + 2
+      ast.participants.each do |participant|
+        center = columns.fetch(participant.id)
+        width = Text.width(participant.label) + 4
+        x = center - width / 2
+        builder.box(x, 0, width, 3, rounded: participant.actor)
+        builder.text(x + 2, 1, participant.label)
+        builder.line([[center, 3], [center, bottom]], role: :muted, pattern: :dotted)
+      end
+      active = Hash.new { |hash, key| hash[key] = [] }
+      blocks = []
+      rows.each do |event, row, label|
+        case event.kind
+        when :message
+          from = columns.fetch(event.from)
+          to = columns.fetch(event.to)
+          if from == to
+            builder.text(from + 2, row, label, role: :edge_label)
+            builder.line([[from, row + 1], [from + 5, row + 1], [from + 5, row + 3], [from, row + 3]],
+                         pattern: event.extra.start_with?("--") ? :dotted : :solid)
+            builder.marker(from + 1, row + 3, direction: :w, kind: marker_kind(event.extra))
+          else
+            left = [from, to].min
+            builder.text(left + 1, row, label, role: :edge_label)
+            builder.line([[from, row + 1], [to, row + 1]], pattern: event.extra.start_with?("--") ? :dotted : :solid)
+            builder.marker(to + (to > from ? -1 : 1), row + 1, direction: to > from ? :e : :w,
+                           kind: marker_kind(event.extra))
+          end
+        when :note
+          from = columns.fetch(event.from)
+          to = columns.fetch(event.to)
+          width = [label.split("\n").map { |part| Text.width(part) }.max.to_i + 4,
+                   event.extra == "over" ? (to - from).abs + 5 : 0].max
+          x = event.extra == "left of" ? from - width - 2 : event.extra == "right of" ? to + 2 : (from + to - width) / 2
+          x = [x, 0].max
+          builder.box(x, row, width, label.count("\n") + 3, role: :container_border)
+          builder.text(x + 2, row + 1, label)
+        when :block_start
+          blocks << [row, event.extra, label, blocks.length]
+        when :block_else
+          inset = blocks.length - 1
+          builder.line([[inset, row], [centers.last + 6 - inset, row]], role: :container_border, pattern: :dotted)
+          builder.text(inset + 2, row + 1, "#{event.extra} #{label}", role: :container_title)
+        when :block_end
+          start, kind, title, inset = blocks.pop
+          next unless start
+
+          builder.box(inset, start, centers.last + 7 - inset * 2, row - start + 1, role: :container_border)
+          builder.text(inset + 2, start, "#{kind} #{title}", role: :container_title)
+        when :activate
+          active[event.from] << [row, active[event.from].length]
+        when :deactivate
+          start, depth = active[event.from].pop
+          builder.box(columns.fetch(event.from) - 1 + depth * 2, start, 3, row - start + 1) if start
+        end
+      end
+      active.each do |id, starts|
+        starts.each { |start, depth| builder.box(columns.fetch(id) - 1 + depth * 2, start, 3, bottom - start + 1) }
+      end
+      if repeat_participants
+        ast.participants.each do |participant|
+          center = columns.fetch(participant.id)
+          width = Text.width(participant.label) + 4
+          builder.box(center - width / 2, bottom + 1, width, 3, rounded: participant.actor)
+          builder.text(center - width / 2 + 2, bottom + 2, participant.label)
+        end
+      end
+      builder.scene
+    end
+
+    def self.marker_kind(operator)
+      operator.end_with?("x") ? :cross : operator.end_with?(")") ? :circle : :arrow
+    end
+  end
+end