sirena 0.1.0

data/lib/sirena/parser/transforms/timeline.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "../../diagram/timeline"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to Timeline diagram model.
+      #
+      # Converts the parse tree output from Grammars::Timeline into a
+      # fully-formed Diagram::Timeline object with sections and events.
+      class Timeline
+        # Transform parse tree into Timeline diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::Timeline] the timeline diagram model
+        def apply(tree)
+          diagram = Diagram::Timeline.new
+          @current_section = nil
+          @last_event = nil
+
+          # Tree structure: array with header and statements
+          if tree.is_a?(Array)
+            tree.each do |item|
+              next unless item.is_a?(Hash)
+
+              process_item(diagram, item)
+            end
+          elsif tree.is_a?(Hash)
+            process_item(diagram, tree)
+
+            if tree[:statements]
+              process_statements(diagram, tree[:statements])
+            end
+          end
+
+          diagram
+        end
+
+        private
+
+        def process_item(diagram, item)
+          return unless item.is_a?(Hash)
+
+          process_header(diagram, item) if item.key?(:header)
+          process_title(diagram, item) if item.key?(:title)
+          process_acc_title(diagram, item) if item.key?(:acc_title)
+          process_acc_descr(diagram, item) if item.key?(:acc_descr)
+          process_section(diagram, item) if item.key?(:section)
+          process_event(diagram, item) if item.key?(:event_entry)
+          process_continuation(diagram, item) if item.key?(:continuation_entry)
+          process_task(diagram, item) if item.key?(:task)
+        end
+
+        def process_statements(diagram, statements)
+          Array(statements).each do |stmt|
+            process_item(diagram, stmt) if stmt.is_a?(Hash)
+          end
+        end
+
+        def process_header(diagram, item)
+          # Header is just the 'timeline' keyword, nothing to extract
+        end
+
+        def process_title(diagram, item)
+          diagram.title = extract_text(item[:title])
+        end
+
+        def process_acc_title(diagram, item)
+          diagram.acc_title = extract_text(item[:acc_title])
+        end
+
+        def process_acc_descr(diagram, item)
+          diagram.acc_description = extract_text(item[:acc_descr])
+        end
+
+        def process_section(diagram, item)
+          section_name = extract_text(item[:section])
+          @current_section = Diagram::TimelineSection.new(section_name)
+          diagram.sections << @current_section
+          @last_event = nil
+        end
+
+        def process_event(diagram, item)
+          event_data = item[:event_entry]
+          return unless event_data
+
+          time = extract_text(event_data[:time])
+          descriptions = extract_descriptions(event_data[:descriptions])
+
+          event = Diagram::TimelineEvent.new.tap do |e|
+            e.time = time
+            e.descriptions.concat(descriptions)
+          end
+
+          # Store reference for continuation entries
+          @last_event = event
+
+          # Add to current section or diagram
+          if @current_section
+            @current_section.events << event
+          else
+            diagram.events << event
+          end
+        end
+
+        def process_continuation(diagram, item)
+          continuation_data = item[:continuation_entry]
+          return unless continuation_data
+
+          descriptions = extract_descriptions(continuation_data[:descriptions])
+
+          # Add descriptions to last event if it exists
+          if @last_event
+            @last_event.descriptions.concat(descriptions)
+          else
+            # If no last event, create a new event with empty time
+            # This handles edge case of continuation at start
+            event = Diagram::TimelineEvent.new.tap do |e|
+              e.time = ""
+              e.descriptions.concat(descriptions)
+            end
+
+            if @current_section
+              @current_section.events << event
+            else
+              diagram.events << event
+            end
+
+            @last_event = event
+          end
+        end
+
+        def process_task(diagram, item)
+          # Ensure we have a section for tasks
+          unless @current_section
+            @current_section = Diagram::TimelineSection.new("Default")
+            diagram.sections << @current_section
+          end
+
+          task_name = extract_text(item[:task])
+          @current_section.tasks << task_name unless task_name.empty?
+        end
+
+        def extract_descriptions(descriptions_data)
+          return [] unless descriptions_data
+
+          # descriptions_data is an array of {:desc => text} hashes
+          if descriptions_data.is_a?(Array)
+            descriptions_data.map do |item|
+              if item.is_a?(Hash) && item[:desc]
+                extract_text(item[:desc])
+              else
+                extract_text(item)
+              end
+            end.reject(&:empty?)
+          elsif descriptions_data.is_a?(Hash) && descriptions_data[:desc]
+            [extract_text(descriptions_data[:desc])].reject(&:empty?)
+          else
+            [extract_text(descriptions_data)].reject(&:empty?)
+          end
+        end
+
+        def extract_text(value)
+          case value
+          when Hash
+            value.values.first.to_s
+          when String
+            value
+          else
+            value.to_s
+          end.strip
+        end
+      end
+    end
+  end
+end

data/lib/sirena/parser/transforms/treemap.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'parslet'
+require_relative '../../diagram/treemap'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting treemap parse tree to diagram model
+      class Treemap < Parslet::Transform
+        rule(number: simple(:x)) { x.to_f }
+        rule(string: simple(:x)) { x.to_s }
+        rule(string: sequence(:x)) { '' }  # Empty string
+        rule(identifier: simple(:x)) { x.to_s }
+
+        rule(keyword: simple(:_kw), statements: subtree(:stmts)) do
+          {
+            type: :treemap,
+            statements: Array(stmts).compact
+          }
+        end
+
+        # Title
+        rule(title: simple(:t)) do
+          { type: :title, value: t.to_s }
+        end
+
+        # Accessibility
+        rule(acc_title: simple(:t)) do
+          { type: :acc_title, value: t.to_s }
+        end
+
+        rule(acc_descr: simple(:d)) do
+          { type: :acc_descr, value: d.to_s }
+        end
+
+        # Class definition
+        rule(class_def: {
+          class_name: simple(:name),
+          class_styles: simple(:styles)
+        }) do
+          {
+            type: :class_def,
+            name: name.to_s,
+            styles: styles.to_s
+          }
+        end
+
+        # Transform happens bottom-up, so handle nested parts first
+        # Then handle the node structure
+
+        # Node with all fields
+        rule(node: subtree(:n)) do
+          indent_val = n[:indent]
+          # Handle indent - could be Array (empty), Parslet::Slice, or String
+          indent_len = if indent_val.is_a?(Array)
+                         indent_val.length  # Empty array = 0
+                       elsif indent_val.respond_to?(:to_s)
+                         indent_val.to_s.length  # String or Parslet::Slice
+                       else
+                         0
+                       end
+
+          label_val = n[:label]
+          label_str = label_val.is_a?(String) ? label_val : label_val.to_s
+
+          result = {
+            type: :node,
+            indent: indent_len,
+            label: label_str
+          }
+
+          result[:value] = n[:value] if n.key?(:value)
+          result[:css_class] = n[:css_class].to_s if n.key?(:css_class)
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/sirena/parser/transforms/xy_chart.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for XY Chart diagrams
+      class XYChart < Parslet::Transform
+        # Transform title (from grammar: {:title=>{:string=>"..."}} )
+        rule(title: { string: simple(:title) }) do
+          { type: :title, title: title.to_s }
+        end
+        
+        # Transform values - keep as-is for now, will determine numeric vs categorical later
+        rule(value: simple(:v)) do
+          # Try to convert to number if it looks numeric, otherwise keep as string
+          str = v.to_s
+          if str.match?(/^\d+(\.\d+)?$/)
+            str.to_f
+          else
+            str
+          end
+        end
+
+        # Transform X-axis with label
+        rule(x_label: { string: simple(:label) }, x_values: subtree(:values)) do
+          {
+            type: :x_axis,
+            label: label.to_s,
+            values: Array(values)
+          }
+        end
+
+        rule(x_values: subtree(:values)) do
+          {
+            type: :x_axis,
+            label: nil,
+            values: Array(values)
+          }
+        end
+
+        # Transform Y-axis with label
+        rule(y_label: { string: simple(:label) }, y_min: simple(:min), y_max: simple(:max)) do
+          {
+            type: :y_axis,
+            label: label.to_s,
+            min: min.to_s.to_f,
+            max: max.to_s.to_f
+          }
+        end
+
+        rule(y_min: simple(:min), y_max: simple(:max)) do
+          {
+            type: :y_axis,
+            label: nil,
+            min: min.to_s.to_f,
+            max: max.to_s.to_f
+          }
+        end
+
+        # Transform line dataset
+        rule(line_values: subtree(:values)) do
+          {
+            type: :dataset,
+            chart_type: :line,
+            label: "Line",
+            values: Array(values)
+          }
+        end
+
+        # Transform bar dataset
+        rule(bar_values: subtree(:values)) do
+          {
+            type: :dataset,
+            chart_type: :bar,
+            label: "Bar",
+            values: Array(values)
+          }
+        end
+
+        # Transform named dataset
+        rule(dataset_label: { string: simple(:label) }, dataset_values: subtree(:values)) do
+          {
+            type: :dataset,
+            chart_type: :line,
+            label: label.to_s,
+            values: Array(values)
+          }
+        end
+
+        # Transform the entire diagram
+        rule(statements: subtree(:statements)) do
+          result = {
+            title: nil,
+            x_axis: nil,
+            y_axis: nil,
+            datasets: []
+          }
+
+          Array(statements).each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            case stmt[:type]
+            when :title
+              result[:title] = stmt[:title]
+            when :x_axis
+              result[:x_axis] = {
+                label: stmt[:label],
+                values: stmt[:values]
+              }
+            when :y_axis
+              result[:y_axis] = {
+                label: stmt[:label],
+                min: stmt[:min],
+                max: stmt[:max]
+              }
+            when :dataset
+              result[:datasets] << {
+                chart_type: stmt[:chart_type],
+                label: stmt[:label],
+                values: stmt[:values]
+              }
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/sirena/parser/treemap.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'grammars/treemap'
+require_relative 'transforms/treemap'
+require_relative '../diagram/treemap'
+
+module Sirena
+  module Parser
+    # Parser for treemap diagrams using Parslet
+    class TreemapParser
+      def initialize
+        @grammar = Grammars::Treemap.new
+        @transform = Transforms::Treemap.new
+      end
+
+      # Parse treemap source into a TreemapDiagram
+      #
+      # @param source [String] The treemap diagram source
+      # @return [Diagram::TreemapDiagram] The parsed diagram
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def parse(source)
+        tree = @grammar.parse(source)
+        intermediate = @transform.apply(tree)
+        build_diagram(intermediate)
+      rescue Parslet::ParseFailed => e
+        raise ParseError, "Treemap parse error: #{e.message}"
+      end
+
+      private
+
+      # Build TreemapDiagram from intermediate representation
+      def build_diagram(data)
+        diagram = Diagram::TreemapDiagram.new
+
+        statements = data[:statements] || []
+        nodes = []
+
+        statements.each do |stmt|
+          case stmt[:type]
+          when :title
+            diagram.title = stmt[:value]
+          when :acc_title
+            # Store accessibility title (could be added to base)
+          when :acc_descr
+            # Store accessibility description
+          when :class_def
+            diagram.add_class_def(stmt[:name], stmt[:styles])
+          when :node
+            nodes << stmt
+          end
+        end
+
+        # Build hierarchical structure from flat node list
+        build_hierarchy(diagram, nodes)
+
+        diagram
+      end
+
+      # Build hierarchical tree from flat list of nodes with indentation
+      def build_hierarchy(diagram, nodes)
+        return if nodes.empty?
+
+        # Stack to track the current parent at each indentation level
+        # Format: [[indent_level, node], ...]
+        stack = []
+
+        nodes.each do |node_data|
+          indent = node_data[:indent] || 0
+          label = node_data[:label]
+          value = node_data[:value]
+          css_class = node_data[:css_class]
+
+          # Create the node
+          node = Diagram::TreemapNode.new(label, value)
+          node.css_class = css_class if css_class
+
+          # Pop stack until we find the parent
+          stack.pop while stack.any? && stack.last[0] >= indent
+
+          if stack.empty?
+            # This is a root node
+            diagram.add_root_node(node)
+          else
+            # This is a child of the last node in stack
+            parent = stack.last[1]
+            parent.add_child(node)
+          end
+
+          # Add current node to stack (it could be a parent for future nodes)
+          stack.push([indent, node])
+        end
+      end
+    end
+
+    # Alias for backward compatibility
+    Treemap = TreemapParser
+  end
+end

data/lib/sirena/parser/user_journey.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'parslet'
+require_relative 'base'
+require_relative '../diagram/user_journey'
+
+module Sirena
+  module Parser
+    # Parslet grammar for User Journey diagrams
+    class UserJourneyGrammar < Parslet::Parser
+      rule(:sp) { match('[ \t]').repeat(1) }
+      rule(:sp?) { sp.maybe }
+      rule(:nl) { str("\n") }
+
+      rule(:journey) { str('journey') >> sp? >> (nl | any.absent?) }
+      rule(:title_decl) { sp? >> str('title') >> sp >> text_line.as(:title) >> (nl | any.absent?) }
+      rule(:section_decl) do
+        sp? >> str('section') >> sp >> text_line.as(:section) >> (nl | any.absent?)
+      end
+
+      rule(:text_line) { (nl.absent? >> str(':').absent? >> any).repeat(1) }
+      rule(:task_text) { (str(':').absent? >> nl.absent? >> any).repeat(1) }
+      rule(:actor_text) { (match('[,\n]').absent? >> any).repeat(1) }
+
+      rule(:task_line) do
+        sp? >>
+          task_text.as(:task) >> str(':') >> sp? >>
+          match('[0-9]').repeat(1).as(:score) >> str(':') >> sp? >>
+          actor_list.as(:actors) >> sp? >> (nl | any.absent?)
+      end
+
+      rule(:actor_list) do
+        actor_text.as(:actor) >>
+          (sp? >> str(',') >> sp? >> actor_text.as(:actor)).repeat
+      end
+
+      rule(:line) { title_decl | section_decl | task_line | comment_line | blank_line }
+      rule(:comment_line) { sp? >> str('%%') >> (nl.absent? >> any).repeat >> nl }
+      rule(:blank_line) { sp? >> nl }
+
+      rule(:journey_doc) do
+        journey >>
+          line.repeat.as(:lines)
+      end
+
+      root(:journey_doc)
+    end
+
+    # User Journey diagram parser using Parslet
+    class UserJourneyParser < Base
+      def parse(source)
+        grammar = UserJourneyGrammar.new
+
+        begin
+          tree = grammar.parse(source)
+        rescue Parslet::ParseFailed => e
+          raise ParseError, "Parse error: #{e.parse_failure_cause.ascii_tree}"
+        end
+
+        build_diagram_from_tree(tree)
+      end
+
+      private
+
+      def build_diagram_from_tree(tree)
+        diagram = Diagram::UserJourney.new
+        current_section = nil
+
+        lines = Array(tree[:lines])
+
+        lines.each do |line|
+          next unless line.is_a?(Hash)
+
+          if line[:title]
+            diagram.title = line[:title].to_s.strip
+          elsif line[:section]
+            # Save previous section
+            diagram.sections << current_section if current_section
+
+            # Create new section
+            current_section = Diagram::JourneySection.new
+            current_section.name = line[:section].to_s.strip
+          elsif line[:task] && current_section
+            # Parse task
+            task = Diagram::JourneyTask.new
+            task.name = line[:task].to_s.strip
+            task.score = line[:score].to_s.to_i
+
+            validate_score!(task.score)
+
+            # Extract actors
+            actors_data = line[:actors]
+            task.actors = if actors_data.is_a?(Array)
+                            actors_data.map do |a|
+                              a[:actor].to_s.strip
+                            end.reject(&:empty?)
+                          elsif actors_data.is_a?(Hash) && actors_data[:actor]
+                            [actors_data[:actor].to_s.strip]
+                          else
+                            []
+                          end
+
+            current_section.tasks << task
+          end
+        end
+
+        # Add final section
+        diagram.sections << current_section if current_section
+
+        diagram
+      end
+
+      def validate_score!(score)
+        return if score >= 1 && score <= 5
+
+        raise ParseError, "Score must be between 1 and 5, got #{score}"
+      end
+    end
+  end
+end