sirena 0.1.0

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative '../../diagram/er_diagram'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to ER diagram model.
+      #
+      # Converts the parse tree output from Grammars::ErDiagram into a
+      # fully-formed Diagram::ErDiagram object with entities, attributes,
+      # and relationships.
+      class ErDiagram
+        # Cardinality symbol mappings
+        CARDINALITY_SYMBOLS = {
+          '||' => 'one',
+          'o{' => 'zero_or_more',
+          '|{' => 'one_or_more',
+          '}o' => 'zero_or_one',
+          '{o' => 'zero_or_more',
+          '{|' => 'one_or_more',
+          '}{' => 'one_or_more',
+          '{}' => 'one_or_more'
+        }.freeze
+
+        # Transform parse tree into ER diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::ErDiagram] the ER diagram model
+        def apply(tree)
+          diagram = Diagram::ErDiagram.new
+
+          # Tree is an array: [header, ...statements]
+          if tree.is_a?(Array)
+            tree.each do |item|
+              next if item.is_a?(Hash) && item[:header] # Skip header
+              process_statement(diagram, item) if item.is_a?(Hash)
+            end
+          elsif tree.is_a?(Hash) && tree[:statements]
+            process_statements(diagram, tree[:statements])
+          end
+
+          diagram
+        end
+
+        private
+
+        def process_statements(diagram, statements)
+          Array(statements).each do |stmt|
+            process_statement(diagram, stmt) if stmt.is_a?(Hash)
+          end
+        end
+
+        def process_statement(diagram, stmt)
+          return unless stmt.is_a?(Hash)
+
+          if stmt[:entity_id] && stmt[:attributes]
+            # Entity definition with attributes
+            process_entity_definition(diagram, stmt)
+          elsif stmt[:from_id] && stmt[:to_id] && stmt[:pattern]
+            # Relationship
+            process_relationship(diagram, stmt)
+          elsif stmt[:entity_id]
+            # Stand-alone entity declaration
+            ensure_entity(diagram, stmt[:entity_id].to_s)
+          end
+        end
+
+        def process_entity_definition(diagram, stmt)
+          entity_id = stmt[:entity_id].to_s
+          entity = find_or_create_entity(diagram, entity_id)
+
+          # Process attributes
+          if stmt[:attributes]
+            attributes = Array(stmt[:attributes])
+            attributes.each do |attr_data|
+              next unless attr_data.is_a?(Hash)
+
+              attribute = Diagram::ErAttribute.new.tap do |attr|
+                attr.name = attr_data[:name].to_s
+                attr.attribute_type = extract_text(attr_data[:type]) if attr_data[:type]
+                attr.key_type = extract_key_type(attr_data[:key]) if attr_data[:key]
+              end
+
+              entity.attributes << attribute
+            end
+          end
+        end
+
+        def process_relationship(diagram, stmt)
+          from_id = stmt[:from_id].to_s
+          to_id = stmt[:to_id].to_s
+          pattern = stmt[:pattern]
+
+          # Ensure entities exist
+          ensure_entity(diagram, from_id)
+          ensure_entity(diagram, to_id)
+
+          # Parse relationship pattern
+          card_from = extract_text(pattern[:card_from])
+          card_to = extract_text(pattern[:card_to])
+          operator = extract_text(pattern[:operator])
+
+          # Map cardinalities
+          card_from_val = CARDINALITY_SYMBOLS[card_from]
+          card_to_val = CARDINALITY_SYMBOLS[card_to]
+
+          # Determine relationship type from operator
+          rel_type = operator == '==' ? 'identifying' : 'non-identifying'
+
+          # Extract label if present
+          label = nil
+          if stmt[:label] && stmt[:label][:label_text]
+            label = extract_text(stmt[:label][:label_text]).strip
+          end
+
+          relationship = Diagram::ErRelationship.new.tap do |rel|
+            rel.from_id = from_id
+            rel.to_id = to_id
+            rel.relationship_type = rel_type
+            rel.cardinality_from = card_from_val
+            rel.cardinality_to = card_to_val
+            rel.label = label unless label.nil? || label.empty?
+          end
+
+          diagram.relationships << relationship
+        end
+
+        def find_or_create_entity(diagram, entity_id)
+          existing = diagram.find_entity(entity_id)
+          return existing if existing
+
+          entity = Diagram::ErEntity.new.tap do |e|
+            e.id = entity_id
+            e.name = entity_id
+          end
+          diagram.entities << entity
+          entity
+        end
+
+        def ensure_entity(diagram, entity_id)
+          find_or_create_entity(diagram, entity_id)
+        end
+
+        def extract_text(value)
+          case value
+          when Hash
+            if value[:string]
+              value[:string].to_s
+            elsif value[:key_type]
+              value[:key_type].to_s
+            else
+              value.values.first.to_s
+            end
+          when String
+            value
+          else
+            value.to_s
+          end
+        end
+
+        def extract_key_type(value)
+          text = extract_text(value)
+          text if %w[PK FK UK].include?(text)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../diagram/error'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting Parslet parse tree to Error diagram model.
+      #
+      # Converts the parse tree output from Grammars::Error into a
+      # fully-formed Diagram::Error object.
+      class Error
+        # Transform parse tree into Error diagram.
+        #
+        # @param tree [Array, Hash] Parslet parse tree
+        # @return [Diagram::Error] the error diagram model
+        def apply(tree)
+          diagram = Diagram::Error.new
+
+          # Process tree structure
+          if tree.is_a?(Array)
+            tree.each do |item|
+              next unless item.is_a?(Hash)
+
+              process_message(diagram, item) if item.key?(:message)
+            end
+          elsif tree.is_a?(Hash)
+            process_message(diagram, tree) if tree.key?(:message)
+          end
+
+          diagram
+        end
+
+        private
+
+        def process_message(diagram, item)
+          message = item[:message]
+          return unless message
+
+          # Extract message text
+          message_text = extract_text(message)
+          diagram.message = message_text unless message_text.empty?
+        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/flowchart.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'parslet'
+require_relative '../../diagram/flowchart'
+
+module Sirena
+  module Parser
+    module Transforms
+      # Transform for converting flowchart parse trees to diagram models.
+      #
+      # Handles transformation of nodes, edges, subgraphs, and styling
+      # directives from Parslet parse trees into Flowchart diagram objects.
+      class Flowchart < Parslet::Transform
+        # Shape delimiter to type mapping
+        SHAPE_MAP = {
+          '[]' => 'rect',
+          '()' => 'rounded',
+          '([])' => 'stadium',
+          '[[]]' => 'subroutine',
+          '[()]' => 'cylindrical',
+          '(())' => 'circle',
+          '((()))' => 'double_circle',
+          '>]' => 'asymmetric',
+          '{}' => 'rhombus',
+          '{{}}' => 'hexagon',
+          '[//]' => 'parallelogram',
+          '[\\\\]' => 'parallelogram_alt',
+          '[/\\]' => 'trapezoid',
+          '[\\/]' => 'trapezoid_alt'
+        }.freeze
+
+        # Arrow type mapping
+        ARROW_MAP = {
+          '-->' => 'arrow',
+          '->' => 'arrow',
+          '---' => 'line',
+          '-.>' => 'dotted_arrow',
+          '-.-' => 'dotted_arrow',
+          '==>' => 'thick_arrow',
+          '==' => 'thick_arrow'
+        }.freeze
+
+        # Direction value
+        rule(dir_value: simple(:v)) { v.to_s }
+
+        # Node ID
+        rule(node_id: simple(:id)) { id.to_s }
+        rule(node_id: { string: simple(:s) }) { s.to_s }
+
+        # Shape with label
+        rule(
+          shape: {
+            open: simple(:o),
+            label: simple(:l),
+            close: simple(:c)
+          }
+        ) do
+          delims = "#{o}#{c}"
+          {
+            shape_type: SHAPE_MAP[delims] || 'rect',
+            label: l.to_s.strip
+          }
+        end
+
+        # Handle empty labels
+        rule(
+          shape: {
+            open: simple(:o),
+            label: sequence(:_),
+            close: simple(:c)
+          }
+        ) do
+          delims = "#{o}#{c}"
+          {
+            shape_type: SHAPE_MAP[delims] || 'rect',
+            label: ''
+          }
+        end
+
+        # Node with shape
+        rule(
+          node: {
+            node_id: simple(:id),
+            shape: subtree(:s)
+          }
+        ) do
+          {
+            node_id: id.to_s,
+            shape_type: s[:shape_type] || 'rect',
+            label: s[:label] || id.to_s
+          }
+        end
+
+        # Node with shape and inline class
+        rule(
+          node: {
+            node_id: simple(:id),
+            inline_class: simple(:cls),
+            shape: subtree(:s)
+          }
+        ) do
+          {
+            node_id: id.to_s,
+            shape_type: s[:shape_type] || 'rect',
+            label: s[:label] || id.to_s,
+            classes: cls.to_s
+          }
+        end
+
+        # Node without shape
+        rule(node: { node_id: simple(:id) }) do
+          {
+            node_id: id.to_s,
+            shape_type: 'rect',
+            label: id.to_s
+          }
+        end
+
+        # Node with inline class but no shape
+        rule(
+          node: {
+            node_id: simple(:id),
+            inline_class: simple(:cls)
+          }
+        ) do
+          {
+            node_id: id.to_s,
+            shape_type: 'rect',
+            label: id.to_s,
+            classes: cls.to_s
+          }
+        end
+
+        # Arrow types
+        rule(arrow: { plain: simple(:a) }) { a.to_s }
+        rule(arrow: { dotted: simple(:a) }) { a.to_s }
+        rule(arrow: { thick: simple(:a) }) { a.to_s }
+
+        # Edge label
+        rule(label: simple(:l)) { l.to_s.strip }
+        rule(label: sequence(:l)) { l.join.strip }
+
+        # Helper method to create nodes
+        def self.create_node(node_data)
+          Diagram::FlowchartNode.new.tap do |n|
+            n.id = node_data[:node_id]
+            n.label = node_data[:label] || node_data[:node_id]
+            n.shape = node_data[:shape_type] || 'rect'
+            n.classes = node_data[:classes] if node_data[:classes]
+          end
+        end
+
+        # Helper method to create edges
+        def self.create_edge(source_id, target_data, arrow_type, label = nil)
+          Diagram::FlowchartEdge.new.tap do |e|
+            e.source_id = source_id
+            e.target_id = target_data[:node_id]
+            e.arrow_type = ARROW_MAP[arrow_type] || 'arrow'
+            # Convert Parslet::Slice to string before checking empty
+            label_str = label.to_s if label
+            e.label = label_str if label_str && !label_str.empty?
+          end
+        end
+
+        # Process parsed diagram
+        def self.apply(tree, diagram = nil)
+          diagram ||= Diagram::Flowchart.new
+
+          # Parse tree is an array: [header_element, *statement_elements]
+          tree = [tree] unless tree.is_a?(Array)
+
+          # Extract header (first element)
+          header = tree.first
+          if header && header.is_a?(Hash) && header[:direction]
+            dir_value = header[:direction][:dir_value] || header[:direction]
+            diagram.direction = dir_value.to_s if dir_value
+          end
+
+          # Process statements (remaining elements)
+          statements = tree[1..-1] || []
+
+          process_statements(diagram, statements)
+
+          diagram
+        end
+
+        def self.process_statements(diagram, statements)
+          statements.each do |stmt|
+            next unless stmt.is_a?(Hash)
+
+            if stmt[:node]
+              # Node with edges
+              process_node_edge_statement(diagram, stmt)
+            elsif stmt[:node_id]
+              # Standalone node
+              node_data = { node_id: stmt[:node_id], shape_type: 'rect', label: stmt[:node_id] }
+              add_or_update_node(diagram, node_data)
+            elsif stmt[:subgraph_keyword]
+              # Subgraph (acknowledge but don't fully implement for now)
+              # Process subgraph statements recursively
+              if stmt[:subgraph_statements]
+                sub_stmts = stmt[:subgraph_statements]
+                sub_stmts = [sub_stmts] unless sub_stmts.is_a?(Array)
+                process_statements(diagram, sub_stmts)
+              end
+            elsif stmt[:style_keyword] || stmt[:classdef_keyword] ||
+                  stmt[:class_keyword] || stmt[:click_keyword]
+              # Styling directives (acknowledge but don't fully implement)
+              # These are parsed but not processed into the model
+            end
+          end
+        end
+
+        def self.process_node_edge_statement(diagram, stmt)
+          node_data = extract_node_data(stmt[:node])
+          add_or_update_node(diagram, node_data)
+
+          # Process edges if present
+          edges = stmt[:edges]
+          return unless edges
+
+          edges = [edges] unless edges.is_a?(Array)
+          source_id = node_data[:node_id]
+
+          edges.each do |edge_data|
+            next unless edge_data.is_a?(Hash)
+
+            arrow_type = edge_data[:arrow].to_s
+            label = edge_data[:label]
+            target_data = edge_data[:target]
+
+            next unless target_data
+
+            # Extract and add target node
+            target_node_data = extract_node_data(target_data)
+            add_or_update_node(diagram, target_node_data)
+
+            # Create edge
+            edge = create_edge(source_id, target_node_data, arrow_type, label)
+            diagram.edges << edge
+
+            # For chaining, next edge source is current target
+            source_id = target_node_data[:node_id]
+          end
+        end
+
+        def self.add_or_update_node(diagram, node_data)
+          return unless node_data
+
+          existing = diagram.find_node(node_data[:node_id])
+          if existing
+            # Update existing node - only update if we have non-default values
+            existing.label = node_data[:label] if node_data[:label] && !node_data[:label].empty?
+            # Only update shape if the new shape is not the default 'rect' or if existing is 'rect'
+            if node_data[:shape_type] && node_data[:shape_type] != 'rect'
+              existing.shape = node_data[:shape_type]
+            end
+            existing.classes = node_data[:classes] if node_data[:classes]
+          else
+            # Add new node
+            node = create_node(node_data)
+            diagram.nodes << node
+          end
+        end
+
+        # Extract node data from parse tree
+        def self.extract_node_data(node_hash)
+          return nil unless node_hash
+
+          node_id = node_hash[:node_id].to_s
+
+          # Extract shape info if present
+          if node_hash[:shape]
+            shape_data = node_hash[:shape]
+            delims = "#{shape_data[:open]}#{shape_data[:close]}"
+            shape_type = SHAPE_MAP[delims] || 'rect'
+            label = shape_data[:label]&.to_s&.strip || node_id
+          else
+            shape_type = 'rect'
+            label = node_id
+          end
+
+          {
+            node_id: node_id,
+            shape_type: shape_type,
+            label: label,
+            classes: node_hash[:inline_class]&.to_s
+          }
+        end
+      end
+    end
+  end
+end