etassia 0.1.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Etassia
+  module Parser
+    module Builders
+      # Transform for Packet diagrams
+      class Packet < Parslet::Transform
+        LABEL_TEXT = lambda do |captured|
+          captured.is_a?(Array) ? "" : captured.to_s.gsub(/\\(.)/m, '\\1')
+        end
+        private_constant :LABEL_TEXT
+
+        # Transform field definition. label is `subtree`, not `simple`,
+        # because an empty quoted label ("") captures zero characters --
+        # Parslet's `.repeat(0).as(:label)` has no bytes to build a Slice
+        # from on a zero-length match, so it yields `[]` instead of an
+        # empty Slice. `simple(:label)` refuses to bind an Array, which
+        # silently dropped the whole field (no :type key survived, so the
+        # diagram-level rule below skipped it without error).
+        rule(
+          bit_start: simple(:bit_start),
+          bit_end: simple(:bit_end),
+          label: subtree(:label),
+        ) do
+          {
+            type: :field,
+            bit_start: bit_start.to_s.to_i,
+            bit_end: bit_end.to_s.to_i,
+            label: LABEL_TEXT.call(label),
+          }
+        end
+
+        rule(
+          bit_start: simple(:bit_start),
+          label: subtree(:label),
+        ) do
+          bit = bit_start.to_s.to_i
+          {
+            type: :field,
+            bit_start: bit,
+            bit_end: bit,
+            label: LABEL_TEXT.call(label),
+          }
+        end
+
+        # Transform title
+        rule(title: simple(:title)) do
+          { type: :title, title: title.to_s }
+        end
+
+        # Transform the entire diagram
+        rule(statements: subtree(:statements)) do
+          result = { title: nil, fields: [] }
+
+          # A body of only comments and blank lines parses to one string,
+          # not an Array of statements.
+          expected_start = 0
+          Array(statements).each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            case stmt[:type]
+            when :title
+              result[:title] = stmt[:title]
+            else
+              if stmt[:bit_end] < stmt[:bit_start]
+                raise Parser::ParseError,
+                      "Packet field end must be greater than or equal to start."
+              end
+              unless stmt[:bit_start] == expected_start
+                raise Parser::ParseError,
+                      "Packet fields must start from #{expected_start}."
+              end
+              result[:fields] << stmt
+              expected_start = stmt[:bit_end] + 1
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "capture_string"
+require_relative "../../diagram/pie"
+
+module Etassia
+  module Parser
+    module Builders
+      # Transform for converting Parslet parse tree to Pie diagram model.
+      #
+      # Converts the parse tree output from Grammars::Pie into a
+      # fully-formed Diagram::Pie object with slices and metadata.
+      class Pie
+        include CaptureString
+
+        # Transform parse tree into Pie diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::Pie] the pie chart diagram model
+        def apply(tree)
+          diagram = Diagram::Pie.new
+
+          # A bare header parses to one Hash; header plus statements
+          # to an Array.
+          [tree].flatten(1).each do |item|
+            process_title(diagram, item) if item.key?(:title)
+            process_show_data(diagram, item) if item.key?(:show_data)
+            process_statement(diagram, item)
+          end
+
+          diagram
+        end
+
+        private
+
+        def process_title(diagram, item)
+          title_data = item[:title]
+          return unless title_data
+
+          # Extract title text
+          title_text = if title_data.is_a?(Hash)
+                         extract_text(title_data[:title])
+                       else
+                         extract_text(title_data)
+                       end
+
+          diagram.title = title_text unless title_text.empty?
+        end
+
+        def process_show_data(diagram, item)
+          show_data = item[:show_data]
+          return unless show_data
+
+          # showData flag is present if this key exists
+          diagram.show_data = true
+        end
+
+        def process_statement(diagram, stmt)
+          if stmt[:data_entry]
+            add_data_entry(diagram, stmt)
+          elsif stmt[:acc_title]
+            diagram.acc_title = extract_text(stmt[:acc_title])
+          elsif stmt[:acc_descr]
+            diagram.acc_description = extract_text(stmt[:acc_descr])
+          elsif stmt[:standalone_title]
+            diagram.title = extract_text(stmt[:standalone_title])
+          end
+        end
+
+        def add_data_entry(diagram, stmt)
+          label = extract_text(stmt[:label])
+          value = slice_value(stmt[:value])
+
+          slice = Diagram::PieSlice.new.tap do |s|
+            s.label = label
+            s.value = value
+          end
+
+          diagram.slices << slice
+        end
+
+        def extract_text(value)
+          case value
+          when Hash then capture_string(value[:string])
+          when String then value
+          else value.to_s
+          end.strip
+        end
+
+        def extract_numeric_value(value)
+          value.to_s.to_f
+        end
+
+        # Mermaid's pie db refuses a negative slice value.
+        def slice_value(raw)
+          value = extract_numeric_value(raw)
+          return value unless value.negative?
+
+          raise Parser::ParseError,
+                "Negative values are not allowed in pie charts."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "capture_string"
+require_relative "../../diagram/quadrant"
+
+module Etassia
+  module Parser
+    module Builders
+      # Transform for converting Parslet parse tree to Quadrant model.
+      #
+      # Converts the parse tree output from Grammars::Quadrant into a
+      # fully-formed Diagram::Quadrant object with points and labels.
+      class Quadrant
+        include CaptureString
+
+        STATEMENT_HANDLERS = {
+          header: :process_header,
+          title: :process_title,
+          x_axis_left: :process_x_axis,
+          y_axis_bottom: :process_y_axis,
+          quadrant_label: :process_quadrant_label,
+          data_point: :process_data_point,
+        }.freeze
+
+        HASH_STATEMENTS = %i[header title x_axis_left y_axis_bottom].freeze
+
+        STYLE_EXTRACTORS = {
+          radius: :extract_float,
+          color: :extract_text,
+          stroke_color: :extract_text,
+          stroke_width: :extract_float,
+        }.freeze
+
+        QUADRANT_LABELS = {
+          "1" => :quadrant_1_label,
+          "2" => :quadrant_2_label,
+          "3" => :quadrant_3_label,
+          "4" => :quadrant_4_label,
+        }.freeze
+
+        # Transform parse tree into Quadrant diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::Quadrant] the quadrant chart diagram model
+        def apply(tree)
+          diagram = Diagram::Quadrant.new
+          process_tree(diagram, tree)
+          diagram
+        end
+
+        private
+
+        def process_tree(diagram, tree)
+          if tree.is_a?(Array)
+            tree.each { |item| process_item(diagram, item, STATEMENT_HANDLERS) }
+          elsif tree.is_a?(Hash)
+            handlers = STATEMENT_HANDLERS.slice(*HASH_STATEMENTS)
+            process_item(diagram, tree, handlers)
+          end
+        end
+
+        def process_item(diagram, item, handlers)
+          return unless item.is_a?(Hash)
+
+          handlers.each do |key, handler|
+            send(handler, diagram, item) if item.key?(key)
+          end
+        end
+
+        def process_header(_diagram, _item)
+          # Header is just the 'quadrantChart' keyword
+        end
+
+        def process_title(diagram, item)
+          title_data = item[:title]
+          return unless title_data
+
+          title_text = extract_text(title_data)
+          diagram.title = title_text unless title_text.empty?
+        end
+
+        def process_x_axis(diagram, item)
+          diagram.x_axis_left = extract_text(item[:x_axis_left])
+          diagram.x_axis_right = extract_text(item[:x_axis_right])
+        end
+
+        def process_y_axis(diagram, item)
+          diagram.y_axis_bottom = extract_text(item[:y_axis_bottom])
+          diagram.y_axis_top = extract_text(item[:y_axis_top])
+        end
+
+        def process_quadrant_label(diagram, item)
+          attribute = QUADRANT_LABELS[item[:quadrant_number].to_s]
+          return unless attribute
+
+          label_text = extract_text(item[:quadrant_label])
+          diagram.public_send("#{attribute}=", label_text)
+        end
+
+        def process_data_point(diagram, item)
+          label = extract_text(item[:label])
+          coords = item[:coordinates]
+          return if label.empty? || coords.nil?
+
+          point = build_point(label, coords, item[:styling])
+          diagram.points << point
+        end
+
+        def build_point(label, coords, styling)
+          Diagram::QuadrantPoint.new.tap do |point|
+            point.label = label
+            point.x = extract_float(coords[:x])
+            point.y = extract_float(coords[:y])
+            assign_point_style(point, extract_styling(styling))
+          end
+        end
+
+        def assign_point_style(point, styling)
+          styling.each do |attribute, value|
+            point.public_send("#{attribute}=", value) if value
+          end
+        end
+
+        def extract_styling(styling)
+          styling_items(styling).each_with_object({}) do |item, result|
+            next unless item.is_a?(Hash)
+
+            STYLE_EXTRACTORS.each do |attribute, extractor|
+              value = item[attribute]
+              result[attribute] = send(extractor, value) if value
+            end
+          end
+        end
+
+        def styling_items(styling)
+          return styling if styling.is_a?(Array)
+          return [styling] if styling.is_a?(Hash)
+
+          []
+        end
+
+        def extract_text(value)
+          text = value.is_a?(Hash) ? extract_hash_text(value) : value.to_s
+          text.strip
+        end
+
+        def extract_hash_text(value)
+          return capture_string(value[:string]) if value[:string]
+
+          value.values.first.to_s
+        end
+
+        def extract_float(value)
+          value_str = if value.is_a?(Hash)
+                        value.values.first.to_s
+                      else
+                        value.to_s
+                      end
+
+          value_str.to_f
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Etassia
+  module Parser
+    module Builders
+      # Transform for Radar diagrams
+      class Radar < Parslet::Transform
+        RESULT_HANDLERS = {
+          title: :apply_scalar,
+          acc_title: :apply_scalar,
+          acc_descr: :apply_scalar,
+          axes: :apply_axes,
+          curve: :apply_curve,
+          option: :apply_option,
+        }.freeze
+        private_constant :RESULT_HANDLERS
+
+        # Transform axis definition
+        rule(id: simple(:id), label: simple(:label)) do
+          { id: id.to_s, label: label.to_s }
+        end
+
+        rule(id: simple(:id)) do
+          { id: id.to_s, label: id.to_s }
+        end
+
+        # Transform positional values (simple list)
+        rule(value: simple(:v)) do
+          v.to_s.to_f
+        end
+
+        # Transform named values (axis: value pairs)
+        rule(axis: simple(:axis), value: simple(:v)) do
+          { axis: axis.to_s, value: v.to_s.to_f }
+        end
+
+        # Transform curve definition
+        rule(id: simple(:id), label: simple(:label), values: subtree(:vals)) do
+          {
+            type: :curve,
+            id: id.to_s,
+            label: label.to_s,
+            values: vals,
+          }
+        end
+
+        rule(id: simple(:id), values: subtree(:vals)) do
+          {
+            type: :curve,
+            id: id.to_s,
+            label: id.to_s,
+            values: vals,
+          }
+        end
+
+        # Transform title
+        rule(title: simple(:title)) do
+          { type: :title, title: title.to_s }
+        end
+
+        # Transform accessibility
+        rule(acc_title: simple(:acc_title)) do
+          { type: :acc_title, acc_title: acc_title.to_s }
+        end
+
+        rule(acc_descr: simple(:acc_descr)) do
+          { type: :acc_descr, acc_descr: acc_descr.to_s }
+        end
+
+        # Transform axes definition
+        rule(axes: subtree(:axes)) do
+          # A single-axis statement yields a Hash, and Kernel#Array turns a
+          # Hash into its key/value pairs — so `axis A` became
+          # [[:id, "A"], [:label, "A"]]. Assignment used to hide that,
+          # because a later statement overwrote it; accumulating keeps it and
+          # the renderer then fails on a Symbol index.
+          {
+            type: :axes,
+            axes: axes.is_a?(Array) ? axes : [axes],
+          }
+        end
+
+        # Transform options
+        rule(ticks: simple(:ticks)) do
+          { type: :option, key: :ticks, value: ticks.to_s.to_i }
+        end
+
+        rule(show_legend: simple(:show_legend)) do
+          {
+            type: :option,
+            key: :show_legend,
+            value: show_legend.to_s == "true",
+          }
+        end
+
+        rule(graticule: simple(:graticule)) do
+          { type: :option, key: :graticule, value: graticule.to_s }
+        end
+
+        rule(min: simple(:min)) do
+          { type: :option, key: :min, value: min.to_s.to_f }
+        end
+
+        rule(max: simple(:max)) do
+          { type: :option, key: :max, value: max.to_s.to_f }
+        end
+
+        # Transform the entire diagram
+        rule(statements: subtree(:statements)) do
+          Radar.build(statements)
+        end
+
+        def self.build(statements)
+          result = empty_result
+          Array(statements).grep(Hash).each do |statement|
+            apply_statement(result, statement)
+          end
+          result
+        end
+
+        def self.empty_result
+          {
+            title: nil,
+            acc_title: nil,
+            acc_descr: nil,
+            axes: [],
+            curves: [],
+            options: {},
+          }
+        end
+
+        def self.apply_statement(result, statement)
+          handler = RESULT_HANDLERS[statement[:type]]
+          send(handler, result, statement) if handler
+        end
+
+        def self.apply_scalar(result, statement)
+          result[statement[:type]] = statement[statement[:type]]
+        end
+
+        def self.apply_axes(result, statement)
+          result[:axes].concat(statement[:axes])
+        end
+
+        def self.apply_curve(result, statement)
+          result[:curves] << statement
+        end
+
+        def self.apply_option(result, statement)
+          result[:options][statement[:key]] = statement[:value]
+        end
+      end
+    end
+  end
+end