etassia 0.1.0

data/lib/etassia/parser/native/builders/block.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/block"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Block from the native parse tree of the +block+
+        # entry.
+        #
+        # The native tree has the shape Parslet's has -- a header node
+        # followed by the statement nodes, whose position in that list names
+        # anonymous blocks -- so the Parslet builder, which owns the model
+        # rules, reads it as is. One thing differs: the Parslet builder
+        # stringifies an arrow block's direction node, slice offset
+        # included, and a native slice counts bytes where Parslet counts
+        # characters.
+        class Block
+          # A direction that inspects as Parslet's slice does.
+          class CharacterSlice
+            def initialize(slice)
+              @text = slice.to_s
+              @offset = slice.input.byteslice(0, slice.bytepos).length
+            end
+
+            def inspect
+              "#{@text.inspect}@#{@offset}"
+            end
+          end
+          private_constant :CharacterSlice
+
+          # @param tree [Hash] native parse tree
+          # @return [Diagram::Block]
+          def apply(tree)
+            statements = Text.items(tree[:statements]).map { |s| fix(s) }
+            Parser::Builders::Block.new
+              .apply([{ header: tree[:header] }, *statements])
+          end
+
+          private
+
+          def fix(statement)
+            direction = statement[:arrow_direction]
+            nested = statement[:compound_statements]
+            return statement unless direction || nested
+
+            statement.merge(fixed_direction(direction), fixed_children(nested))
+          end
+
+          def fixed_direction(direction)
+            return {} unless direction
+
+            { arrow_direction: { direction:
+              CharacterSlice.new(direction[:direction]) } }
+          end
+
+          def fixed_children(nested)
+            return {} unless nested
+
+            { compound_statements: Text.items(nested).map { |s| fix(s) } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/c4.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../../builders/c4"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::C4 from the native parse tree of the +c4+ entry,
+        # which has the shape Parslet's tree has.
+        class C4 < Parser::Builders::C4
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/class_diagram.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/class_diagram"
+require_relative "../../class_notes"
+require_relative "../../class_namespaces"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::ClassDiagram from the native parse tree of the
+        # +class_diagram+ entry. The statement nodes have the shape
+        # Parslet's have, so the Parslet builder, which owns the model
+        # rules, reads them as is; only the list shapes are normalised.
+        class ClassDiagram
+          # The Parslet builder reads a member's source text back from its
+          # capture offsets; the native slices carry the same offsets.
+          class Reader < Parser::Builders::ClassDiagram
+            private
+
+            def collect_slices(node, slices)
+              case node
+              when Hash then node.each_value { |v| collect_slices(v, slices) }
+              else slices << node if node.respond_to?(:offset)
+              end
+            end
+          end
+          private_constant :Reader
+
+          # @param tree [Hash] native parse tree
+          # @param source [String] the text the tree was parsed from
+          # @return [Diagram::ClassDiagram]
+          def apply(tree, source)
+            items = statements(tree)
+            diagram = Reader.new.apply(items, source)
+            diagram.notes = ClassNotes.collect(items, diagram)
+            diagram.namespaces = ClassNamespaces.collect(items, diagram)
+            diagram
+          end
+
+          private
+
+          def statements(tree)
+            head = tree.except(:statements)
+            [head, *Text.items(tree[:statements])].map { |item| lists(item) }
+          end
+
+          # A single-element repeat is a Hash here, an Array in Parslet.
+          def lists(item)
+            item.to_h do |key, value|
+              [key, list_key?(key) ? Text.items(value) : value]
+            end
+          end
+
+          def list_key?(key)
+            %i[body namespace_body].include?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/er_diagram.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/er_diagram"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::ErDiagram from the native parse tree of the
+        # +er_diagram+ entry. The statement nodes have the shape Parslet's
+        # have, so the Parslet builder, which owns the model rules, reads
+        # them once an empty note (an Array in the native tree, a Slice in
+        # Parslet's) is spelled as the empty string.
+        class ErDiagram
+          # @param tree [Hash] native parse tree
+          # @return [Diagram::ErDiagram]
+          def apply(tree)
+            statements = Text.items(tree[:statements]).map do |statement|
+              normalize(statement)
+            end
+            Parser::Builders::ErDiagram.new.apply(statements)
+          end
+
+          private
+
+          def normalize(statement)
+            return statement unless statement.key?(:attributes)
+
+            statement.merge(
+              attributes: Text.items(statement[:attributes]).map do |attr|
+                normalize_attribute(attr)
+              end,
+            )
+          end
+
+          def normalize_attribute(attribute)
+            note = attribute[:note]
+            return attribute unless note.is_a?(Hash)
+
+            attribute.merge(note: { string: Text.of(note[:string]) })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/flowchart.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../declined"
+require_relative "../../builders/flowchart"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Flowchart from the native parse tree of the
+        # +flowchart+ entry. The native grammar captures under the names
+        # of the Parslet grammar, so the Parslet builder, which owns the
+        # model rules, reads the tree as is; only list shapes and the
+        # nesting depth are looked at first.
+        class Flowchart
+          # The Parslet grammar gives out under 190 nested boxes and
+          # reports a diagram that nests too deeply. A deeper tree is
+          # left to it so the answer stays that error.
+          MAX_NESTING = 64
+
+          # @param tree [Hash, Array] native parse tree
+          # @return [Diagram::Flowchart]
+          # @raise [Declined] for a tree nested deeper than MAX_NESTING
+          def apply(tree)
+            items = [tree].flatten(1)
+            raise Declined if too_deep?(items, 0)
+
+            Parser::Builders::Flowchart.new.apply(items.map { |i| lists(i) })
+          end
+
+          private
+
+          def too_deep?(statements, depth)
+            statements.any? do |stmt|
+              next false unless stmt.is_a?(Hash) && stmt[:subgraph_keyword]
+
+              inner = depth + 1
+              inner > MAX_NESTING ||
+                too_deep?([stmt[:subgraph_statements]].flatten(1), inner)
+            end
+          end
+
+          # A single-element repeat is a Hash here, an Array in Parslet.
+          def lists(item)
+            return item unless item.is_a?(Hash)
+
+            item = item.merge(group: [item[:group]].flatten(1)) if
+              item.key?(:group)
+            return item unless item[:subgraph_statements]
+
+            statements = [item[:subgraph_statements]].flatten(1)
+            item.merge(subgraph_statements: statements.map { |s| lists(s) })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/gantt.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/gantt"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Gantt from the native parse tree of the +gantt+
+        # entry. The statement semantics are the Parslet builder's own; only
+        # the tree shape differs: the native task details are the field
+        # list itself, without Parslet's +:parts+ wrapper.
+        class Gantt < Parser::Builders::Gantt
+          # @param tree [Hash, Array, Parsanol::Slice] native parse tree
+          # @return [Diagram::Gantt]
+          def apply(tree)
+            Diagram::Gantt.new.tap do |diagram|
+              @current_section = nil
+              @click_map = {}
+              Text.items(tree).each { |item| process_item(diagram, item) }
+              apply_click_handlers(diagram)
+            end
+          end
+
+          private
+
+          def process_task_details(task, details)
+            super(task, { parts: details })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/gitgraph.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/git_graph"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds the git graph model data from the native parse tree of
+        # the +gitgraph+ entry. The tree's statements have the shape the
+        # Parslet transform consumes, so the same replay State turns them
+        # into commits and branches, with the same errors.
+        class GitGraph
+          DEFAULT_ORIENTATION = "LR"
+          private_constant :DEFAULT_ORIENTATION
+
+          # @param tree [Hash, Parsanol::Slice] native parse tree
+          # @param main_branch_name [String] name of the first branch
+          # @return [Array(Hash, String)] the replayed graph data and the
+          #   orientation
+          # @raise [Parser::ParseError] for an unknown branch, a repeated
+          #   merge id and the other replay errors
+          def apply(tree, main_branch_name: "main")
+            hash = tree.is_a?(Hash) ? tree : {}
+            statements = Text.items(hash[:statements])
+            state = Parser::Builders::GitGraph::State.new(main_branch_name)
+            [state.process(statements).to_h,
+             hash.fetch(:direction, DEFAULT_ORIENTATION).to_s]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../diagram/info"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Info from the native parse tree of the +info+ entry.
+        class Info
+          # @param tree [Hash, Parsanol::Slice] native parse tree
+          # @return [Diagram::Info]
+          def apply(tree)
+            Diagram::Info.new.tap do |diagram|
+              diagram.show_info = true if show_info?(tree)
+            end
+          end
+
+          private
+
+          def show_info?(tree)
+            return false unless tree.is_a?(Hash)
+
+            tree.key?(:show_info) || tree.key?(:body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/kanban.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/kanban"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Kanban from the native parse tree of the +kanban+
+        # entry. The lines have the shape Parslet's have, so the Parslet
+        # builder, which owns the board rules, reads them as is. A capture
+        # that matched no characters is an Array in the native tree where
+        # Parslet holds an empty slice, so those are read as text first.
+        class Kanban
+          # @param tree [Hash, Parsanol::Slice] native parse tree
+          # @return [Diagram::Kanban]
+          def apply(tree)
+            lines = tree.is_a?(Hash) ? Text.items(tree[:lines]) : []
+            result = Parser::Builders::Kanban.new
+              .apply(lines: lines.map { |line| plain(line) })
+            Parser::Kanban.new.create_diagram(result)
+          end
+
+          private
+
+          def plain(line)
+            line = line.merge(indent: Text.of(line[:indent])) if line[:indent]
+            return line unless line[:metadata]
+
+            line.merge(metadata: { body: Text.of(line[:metadata][:body]) })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/mindmap.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/mindmap"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Mindmap from the native parse tree of the
+        # +mindmap+ entry. The node lines have the shape Parslet's have, so
+        # the Parslet builder, which owns the hierarchy rules, reads them as
+        # is.
+        class Mindmap
+          # @param tree [Hash, Parsanol::Slice] native parse tree
+          # @return [Diagram::Mindmap]
+          def apply(tree)
+            nodes = tree.is_a?(Hash) ? Text.items(tree[:nodes]) : []
+            result = Parser::Builders::Mindmap.new.apply(nodes: nodes)
+            Parser::Mindmap.new.create_diagram(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/packet.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../../error/parse_error"
+require_relative "../../../diagram/packet"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Packet from the native tree of the +packet+ entry.
+        class Packet
+          # @param tree [Hash, Parsanol::Slice] native parse tree
+          # @return [Diagram::Packet]
+          # @raise [Parser::ParseError] for a reversed or gapped bit range
+          def apply(tree)
+            diagram = Diagram::Packet.new
+            @next_bit = 0
+            statements(tree).each { |item| apply_item(diagram, item) }
+            diagram
+          end
+
+          private
+
+          def statements(tree)
+            return [] unless tree.is_a?(Hash)
+
+            Text.items(tree[:statements])
+          end
+
+          def apply_item(diagram, item)
+            return diagram.title = item[:title].to_s if item.key?(:title)
+
+            diagram.add_field(field(item))
+          end
+
+          def field(item)
+            first = item[:bit_start].to_s.to_i
+            last = item.key?(:bit_end) ? item[:bit_end].to_s.to_i : first
+            check_range(first, last)
+            @next_bit = last + 1
+            Diagram::PacketField.new(first, last, label(item[:label]))
+          end
+
+          def check_range(first, last)
+            if last < first
+              raise Parser::ParseError,
+                    "Packet field end must be greater than or equal to start."
+            end
+            return if first == @next_bit
+
+            raise Parser::ParseError,
+                  "Packet fields must start from #{@next_bit}."
+          end
+
+          def label(capture)
+            Text.of(capture).gsub(/\\(.)/m, '\\1')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/pie.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../declined"
+require_relative "../../../error/parse_error"
+require_relative "../../../diagram/pie"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Pie from the native parse tree of the +pie+ entry.
+        class Pie
+          # @param tree [Hash, Array, Parsanol::Slice] native parse tree
+          # @return [Diagram::Pie]
+          # @raise [Declined] for an empty title or accessibility text
+          # @raise [Parser::ParseError] for a negative slice value
+          def apply(tree)
+            Diagram::Pie.new.tap do |diagram|
+              Text.items(tree).each { |item| apply_item(diagram, item) }
+            end
+          end
+
+          private
+
+          def apply_item(diagram, item)
+            diagram.show_data = true if item.key?(:show_data)
+            diagram.title = title_text(item[:title]) if item.key?(:title)
+            apply_statement(diagram, item)
+          end
+
+          def apply_statement(diagram, item)
+            return add_slice(diagram, item[:entry]) if item.key?(:entry)
+
+            apply_text(diagram, item)
+          end
+
+          TEXT_ATTRIBUTES = {
+            acc_title: :acc_title=,
+            acc_descr: :acc_description=,
+            standalone_title: :title=,
+          }.freeze
+          private_constant :TEXT_ATTRIBUTES
+
+          def apply_text(diagram, item)
+            key = TEXT_ATTRIBUTES.keys.find { |name| item.key?(name) }
+            return unless key
+
+            diagram.public_send(TEXT_ATTRIBUTES[key],
+                                accessibility_text(item[key]))
+          end
+
+          def title_text(node)
+            accessibility_text(node)
+          end
+
+          # Parslet leaves "[]" for an empty text; the Ruby path owns that.
+          def accessibility_text(node)
+            raise Declined if Text.empty?(node[:text])
+
+            Text.of(node[:text]).strip
+          end
+
+          def add_slice(diagram, entry)
+            slice = Diagram::PieSlice.new
+            slice.label = Text.of(entry[:label][:string]).strip
+            slice.value = slice_value(entry[:value])
+            diagram.slices << slice
+          end
+
+          def slice_value(raw)
+            value = raw.to_s.to_f
+            return value unless value.negative?
+
+            raise Parser::ParseError,
+                  "Negative values are not allowed in pie charts."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/quadrant.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/quadrant"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Quadrant from the native tree of the +quadrant+
+        # entry. Its statements carry the keys the Ruby builder reads, so
+        # the two paths share that builder and the classDef check.
+        class Quadrant
+          # @param tree [Hash] native parse tree
+          # @return [Diagram::Quadrant]
+          # @raise [Parser::ParseError] for an unsupported classDef style
+          def apply(tree)
+            items = [tree.except(:statements)]
+            items.concat(Text.items(tree[:statements]))
+            Parser::Quadrant.new.validate_class_styles(items)
+            Parser::Builders::Quadrant.new.apply(items)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etassia/parser/native/builders/radar.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../text"
+require_relative "../../builders/radar"
+
+module Etassia
+  module Parser
+    module Native
+      module Builders
+        # Builds Diagram::Radar from the native tree of the +radar+ entry:
+        # native statements become the typed statements the Ruby builder
+        # folds, and the parser assembles the diagram from that.
+        class Radar
+          SCALARS = %i[title acc_title acc_descr].freeze
+          OPTIONS = {
+            ticks: :to_i.to_proc,
+            show_legend: ->(text) { text == "true" },
+            graticule: :to_s.to_proc,
+            min: :to_f.to_proc,
+            max: :to_f.to_proc,
+          }.freeze
+          private_constant :SCALARS, :OPTIONS
+
+          # @param tree [Hash] native parse tree
+          # @return [Diagram::Radar]
+          def apply(tree)
+            statements = Text.items(tree[:statements]).filter_map do |item|
+              statement(item)
+            end
+            result = Parser::Builders::Radar.build(statements)
+            Parser::Radar.new.create_diagram(result)
+          end
+
+          private
+
+          def statement(item)
+            scalar = SCALARS.find { |key| item.key?(key) }
+            return { type: scalar, scalar => item[scalar].to_s } if scalar
+            return axes(item) if item.key?(:axes)
+            return curve(item) if item.key?(:values)
+
+            option(item)
+          end
+
+          def axes(item)
+            list = Text.items(item[:axes]).map { |axis| axis_entry(axis) }
+            { type: :axes, axes: list }
+          end
+
+          def axis_entry(axis)
+            id = axis[:id].to_s
+            { id:, label: axis.key?(:label) ? axis[:label].to_s : id }
+          end
+
+          def curve(item)
+            id = item[:id].to_s
+            { type: :curve, id:,
+              label: item.key?(:label) ? item[:label].to_s : id,
+              values: values(item[:values]) }
+          end
+
+          # One value is a bare number or hash, several an Array, as the
+          # Ruby builder leaves them.
+          def values(node)
+            list = Text.items(node).map { |entry| value(entry) }
+            list.one? ? list.first : list
+          end
+
+          def value(entry)
+            number = entry[:value].to_s.to_f
+            return number unless entry.key?(:axis)
+
+            { axis: entry[:axis].to_s, value: number }
+          end
+
+          def option(item)
+            key = OPTIONS.keys.find { |name| item.key?(name) }
+            { type: :option, key:, value: OPTIONS[key].call(item[key].to_s) }
+          end
+        end
+      end
+    end
+  end
+end