sirena 0.1.0

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

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require_relative "../../diagram/gantt"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to Gantt diagram model.
+      #
+      # Converts the parse tree output from Grammars::Gantt into a
+      # fully-formed Diagram::GanttChart object with sections and tasks.
+      class Gantt
+        # Transform parse tree into Gantt diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::GanttChart] the gantt chart diagram model
+        def apply(tree)
+          diagram = Diagram::GanttChart.new
+          @current_section = nil
+          @click_map = {}
+
+          # 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
+
+          # Apply click handlers to tasks
+          apply_click_handlers(diagram)
+
+          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_date_format(diagram, item) if item.key?(:date_format)
+          process_axis_format(diagram, item) if item.key?(:axis_format)
+          process_tick_interval(diagram, item) if item.key?(:tick_interval)
+          process_excludes(diagram, item) if item.key?(:excludes)
+          process_today_marker(diagram, item) if item.key?(:today_marker)
+          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_click(item) if item.key?(:click_id)
+          process_task(diagram, item) if item.key?(:task_entry)
+        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 'gantt' keyword, nothing to extract
+        end
+
+        def process_title(diagram, item)
+          diagram.title = extract_text(item[:title])
+        end
+
+        def process_date_format(diagram, item)
+          diagram.date_format = extract_text(item[:date_format])
+        end
+
+        def process_axis_format(diagram, item)
+          diagram.axis_format = extract_text(item[:axis_format])
+        end
+
+        def process_tick_interval(diagram, item)
+          diagram.tick_interval = extract_text(item[:tick_interval])
+        end
+
+        def process_excludes(diagram, item)
+          excludes_text = extract_text(item[:excludes])
+          diagram.excludes << excludes_text unless excludes_text.empty?
+        end
+
+        def process_today_marker(diagram, item)
+          diagram.today_marker = extract_text(item[:today_marker])
+        end
+
+        def process_acc_title(diagram, item)
+          # Store as metadata (not currently in model)
+        end
+
+        def process_acc_descr(diagram, item)
+          # Store as metadata (not currently in model)
+        end
+
+        def process_section(diagram, item)
+          section_name = extract_text(item[:section])
+          @current_section = Diagram::GanttSection.new(section_name)
+          diagram.sections << @current_section
+        end
+
+        def process_click(item)
+          click_id = extract_text(item[:click_id])
+          if item[:href]
+            @click_map[click_id] = { type: :href, value: extract_text(item[:href]) }
+          elsif item[:callback]
+            @click_map[click_id] = { type: :callback, value: extract_text(item[:callback]) }
+          end
+        end
+
+        def process_task(diagram, item)
+          # Ensure we have a section
+          unless @current_section
+            @current_section = Diagram::GanttSection.new("Default")
+            diagram.sections << @current_section
+          end
+
+          task_entry = item[:task_entry]
+          task = Diagram::GanttTask.new
+          task.description = extract_text(task_entry[:description])
+
+          # Process task details
+          if task_entry[:task_details]
+            process_task_details(task, task_entry[:task_details])
+          end
+
+          @current_section.tasks << task
+        end
+
+        def process_task_details(task, details)
+          return unless details.is_a?(Hash)
+
+          # Extract tags
+          if details[:tags]
+            extract_tags(task, details[:tags])
+          end
+
+          # Extract task ID
+          if details[:id]
+            task.id = extract_text(details[:id])
+          end
+
+          # Extract timing information
+          if details[:start_date]
+            task.start_date = extract_text(details[:start_date])
+          end
+
+          if details[:end_date]
+            task.end_date = extract_text(details[:end_date])
+          end
+
+          if details[:duration]
+            task.duration = extract_text(details[:duration])
+          end
+
+          if details[:after_task]
+            task.after_task = extract_text(details[:after_task])
+          end
+
+          if details[:until_task]
+            task.until_task = extract_text(details[:until_task])
+          end
+        end
+
+        def extract_tags(task, tags_data)
+          tags_array = if tags_data.is_a?(Array)
+                         tags_data
+                       else
+                         [tags_data]
+                       end
+
+          tags_array.each do |tag_item|
+            tag = extract_text(tag_item)
+            task.tags << tag unless tag.empty?
+          end
+        end
+
+        def apply_click_handlers(diagram)
+          diagram.sections.each do |section|
+            section.tasks.each do |task|
+              next unless task.id && @click_map[task.id]
+
+              click_info = @click_map[task.id]
+              if click_info[:type] == :href
+                task.click_href = click_info[:value]
+              elsif click_info[:type] == :callback
+                task.click_callback = click_info[:value]
+              end
+            end
+          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/git_graph.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for Git Graph diagrams
+      class GitGraph < Parslet::Transform
+        # Current state tracking
+        class State
+          attr_accessor :current_branch, :branches, :commits, :commit_counter
+
+          def initialize
+            @current_branch = "main"
+            @branches = { "main" => { order: 0, created_at: nil } }
+            @commits = []
+            @commit_counter = 0
+          end
+
+          def add_commit(options = {})
+            @commit_counter += 1
+            commit_id = options[:id] || "commit-#{@commit_counter}"
+
+            commit = {
+              id: commit_id,
+              type: options[:type] || "NORMAL",
+              tag: options[:tag],
+              branch_name: @current_branch,
+              parent_ids: find_parents,
+              is_merge: options[:is_merge] || false,
+              merge_branch: options[:merge_branch],
+              is_cherry_pick: options[:is_cherry_pick] || false,
+              cherry_pick_parent: options[:cherry_pick_parent]
+            }
+
+            @commits << commit
+            commit
+          end
+
+          def add_branch(name, order = nil)
+            return if @branches.key?(name)
+
+            @branches[name] = {
+              order: order,
+              parent_branch: @current_branch,
+              created_at: @commits.last&.fetch(:id)
+            }
+          end
+
+          def checkout_branch(name)
+            @current_branch = name
+          end
+
+          def merge_branch(branch_name, options = {})
+            add_commit(
+              options.merge(
+                is_merge: true,
+                merge_branch: branch_name
+              )
+            )
+          end
+
+          def cherry_pick(options = {})
+            add_commit(
+              options.merge(is_cherry_pick: true)
+            )
+          end
+
+          def extract_options(options)
+            return {} unless options
+
+            opts = {}
+            options_array = Array(options)
+
+            options_array.each do |opt|
+              next unless opt.is_a?(Hash)
+
+              opts[:id] = opt[:id].to_s if opt[:id]
+              opts[:type] = opt[:type].to_s if opt[:type]
+              opts[:tag] = opt[:tag].to_s if opt[:tag]
+              opts[:cherry_pick_parent] = opt[:parent].to_s if opt[:parent]
+            end
+
+            opts
+          end
+
+          private
+
+          def find_parents
+            # Find the last commit on the current branch
+            parent = @commits.reverse.find do |c|
+              c[:branch_name] == @current_branch
+            end
+
+            parent ? [parent[:id]] : []
+          end
+        end
+
+        # Statement handlers
+        rule(statements: subtree(:stmts)) do
+          state = State.new
+          stmts_array = Array(stmts)
+
+          stmts_array.each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            if stmt.key?(:commit)
+              # commit[:options] contains the parsed options if any
+              commit_data = stmt[:commit]
+              if commit_data.is_a?(Hash) && commit_data.key?(:options)
+                options = state.extract_options(commit_data[:options])
+              else
+                options = {}
+              end
+              state.add_commit(options)
+            elsif stmt.key?(:branch)
+              name = stmt[:branch][:name].to_s
+              options = stmt[:branch][:options]
+              order = nil
+
+              if options.is_a?(Array)
+                order_opt = options.find { |o| o.is_a?(Hash) && o.key?(:order) }
+                order = order_opt[:order].to_i if order_opt
+              elsif options.is_a?(Hash) && options.key?(:order)
+                order = options[:order].to_i
+              end
+
+              state.add_branch(name, order)
+            elsif stmt.key?(:checkout)
+              state.checkout_branch(stmt[:checkout][:branch].to_s)
+            elsif stmt.key?(:switch)
+              state.checkout_branch(stmt[:switch][:branch].to_s)
+            elsif stmt.key?(:merge)
+              branch = stmt[:merge][:branch].to_s
+              options = state.extract_options(stmt[:merge][:options])
+              state.merge_branch(branch, options)
+            elsif stmt.key?(:cherry_pick)
+              options = state.extract_options(stmt[:cherry_pick][:options])
+              state.cherry_pick(options)
+            end
+          end
+
+          # Convert state to diagram structure
+          {
+            commits: state.commits,
+            branches: state.branches.map do |name, info|
+              {
+                name: name,
+                order: info[:order],
+                parent_branch: info[:parent_branch],
+                created_at_commit: info[:created_at]
+              }
+            end
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../diagram/info'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to Info diagram model.
+      #
+      # Converts the parse tree output from Grammars::Info into a
+      # fully-formed Diagram::Info object.
+      class Info
+        # Transform parse tree into Info diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::Info] the info diagram model
+        def apply(tree)
+          diagram = Diagram::Info.new
+
+          # Process tree structure
+          if tree.is_a?(Array)
+            tree.each do |item|
+              next unless item.is_a?(Hash)
+
+              process_show_info_inline(diagram, item) if item.key?(:show_info_inline)
+              process_show_info_body(diagram, item) if item.key?(:show_info_body)
+            end
+          elsif tree.is_a?(Hash)
+            process_show_info_inline(diagram, tree) if tree.key?(:show_info_inline)
+            process_show_info_body(diagram, tree) if tree.key?(:show_info_body)
+          end
+
+          diagram
+        end
+
+        private
+
+        def process_show_info_inline(diagram, item)
+          show_info = item[:show_info_inline]
+          return unless show_info
+          return if show_info.to_s.strip.empty?
+
+          # showInfo flag is present inline
+          diagram.show_info = true
+        end
+
+        def process_show_info_body(diagram, item)
+          show_info = item[:show_info_body]
+          return unless show_info
+          return if show_info.to_s.strip.empty?
+
+          # showInfo flag is present in body
+          diagram.show_info = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for Kanban diagrams
+      class Kanban < Parslet::Transform
+        # Helper class to build kanban board from indented lines
+        class BoardBuilder
+          attr_reader :columns
+
+          def initialize
+            @columns = []
+            @current_column = nil
+            @min_indent = nil
+            @items = []
+          end
+
+          def add_line(line_data)
+            # Skip empty lines
+            return if line_data.nil?
+            return unless line_data[:id]
+
+            indent_size = get_indent_size(line_data[:indent])
+
+            # Track minimum indentation
+            @min_indent = indent_size if @min_indent.nil? || indent_size < @min_indent
+
+            item = {
+              id: line_data[:id].to_s,
+              text: line_data[:text].to_s,
+              indent: indent_size,
+              metadata: line_data[:metadata]
+            }
+
+            @items << item
+          end
+
+          def finalize
+            return if @items.empty?
+
+            # Determine column vs card by indentation
+            # Items at minimum indent are columns, items with more indent are cards
+            @items.each do |item|
+              if item[:indent] == @min_indent
+                # This is a column
+                add_column(item)
+              else
+                # This is a card, add to current column
+                add_card(item)
+              end
+            end
+          end
+
+          private
+
+          def add_column(item)
+            column = {
+              id: item[:id],
+              title: item[:text],
+              cards: []
+            }
+
+            @columns << column
+            @current_column = column
+          end
+
+          def add_card(item)
+            # Cards must belong to a column
+            return unless @current_column
+
+            card = {
+              id: item[:id],
+              text: item[:text]
+            }
+
+            # Extract metadata if present
+            if item[:metadata]
+              metadata = parse_metadata(item[:metadata])
+              card.merge!(metadata)
+            end
+
+            @current_column[:cards] << card
+          end
+
+          def parse_metadata(metadata_data)
+            return {} if metadata_data.nil?
+
+            result = {}
+
+            # metadata_data could be a single entry or an array
+            entries = if metadata_data.is_a?(Array)
+                       metadata_data
+                     else
+                       [metadata_data]
+                     end
+
+            entries.each do |entry|
+              next unless entry.is_a?(Hash)
+              next unless entry[:key] && entry[:value]
+
+              key = entry[:key].to_s
+              value = extract_value(entry[:value])
+
+              # Map to known metadata fields
+              case key
+              when "assigned"
+                result[:assigned] = value
+              when "ticket"
+                result[:ticket] = value
+              when "icon"
+                result[:icon] = value
+              when "label"
+                result[:label] = value
+              when "priority"
+                result[:priority] = value
+              else
+                # Store unknown keys as-is
+                result[key.to_sym] = value
+              end
+            end
+
+            result
+          end
+
+          def extract_value(value_data)
+            return "" if value_data.nil?
+
+            if value_data.is_a?(Hash) && value_data[:string]
+              # It's a string wrapped in :string key
+              value_data[:string].to_s
+            else
+              value_data.to_s
+            end
+          end
+
+          def get_indent_size(indent_data)
+            return 0 if indent_data.nil?
+            return 0 if indent_data.is_a?(Array) && indent_data.empty?
+
+            indent_str = if indent_data.is_a?(Array)
+                          indent_data.join('')
+                        else
+                          indent_data.to_s
+                        end
+
+            indent_str.length
+          end
+        end
+
+        # Transform the lines array into columns and cards
+        rule(lines: subtree(:lines)) do
+          builder = BoardBuilder.new
+          lines_array = Array(lines)
+
+          lines_array.each do |line_data|
+            next unless line_data.is_a?(Hash)
+
+            # Skip empty lines
+            next unless line_data[:id]
+
+            builder.add_line(line_data)
+          end
+
+          builder.finalize
+
+          {
+            columns: builder.columns
+          }
+        end
+      end
+    end
+  end
+end