kumi 0.0.7 → 0.0.9

data/lib/kumi/support/s_expression_printer.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Support
+    class SExpressionPrinter
+      def initialize(indent: 0)
+        @indent = indent
+      end
+
+      def visit(node)
+        return node.inspect unless node.respond_to?(:class)
+        
+        case node
+        when nil then "nil"
+        when Array then visit_array(node)
+        when Kumi::Syntax::Root then visit_root(node)
+        when Kumi::Syntax::ValueDeclaration then visit_value_declaration(node)
+        when Kumi::Syntax::TraitDeclaration then visit_trait_declaration(node)
+        when Kumi::Syntax::InputDeclaration then visit_input_declaration(node)
+        when Kumi::Syntax::CallExpression then visit_call_expression(node)
+        when Kumi::Syntax::ArrayExpression then visit_array_expression(node)
+        when Kumi::Syntax::CascadeExpression then visit_cascade_expression(node)
+        when Kumi::Syntax::CaseExpression then visit_case_expression(node)
+        when Kumi::Syntax::InputReference then visit_input_reference(node)
+        when Kumi::Syntax::InputElementReference then visit_input_element_reference(node)
+        when Kumi::Syntax::DeclarationReference then visit_declaration_reference(node)
+        when Kumi::Syntax::Literal then visit_literal(node)
+        when Kumi::Syntax::HashExpression then visit_hash_expression(node)
+        else visit_generic(node)
+        end
+      end
+
+      def self.print(node, indent: 0)
+        new(indent: indent).visit(node)
+      end
+
+      private
+
+      def visit_array(node)
+        return "[]" if node.empty?
+        
+        elements = node.map { |child| child_printer.visit(child) }
+        "[\n#{indent_str(2)}#{elements.join("\n#{indent_str(2)}")}\n#{indent_str}]"
+      end
+
+      def visit_root(node)
+        fields = %i[inputs attributes traits].map do |field|
+          value = node.public_send(field)
+          "#{field}: #{child_printer.visit(value)}"
+        end.join("\n#{indent_str(2)}")
+        
+        "(Root\n#{indent_str(2)}#{fields}\n#{indent_str})"
+      end
+
+      def visit_value_declaration(node)
+        "(ValueDeclaration :#{node.name}\n#{child_indent}#{child_printer.visit(node.expression)}\n#{indent_str})"
+      end
+
+      def visit_trait_declaration(node)
+        "(TraitDeclaration :#{node.name}\n#{child_indent}#{child_printer.visit(node.expression)}\n#{indent_str})"
+      end
+
+      def visit_input_declaration(node)
+        fields = [":#{node.name}"]
+        fields << ":#{node.type}" if node.respond_to?(:type) && node.type
+        fields << "domain: #{node.domain.inspect}" if node.respond_to?(:domain) && node.domain
+        
+        if node.respond_to?(:children) && !node.children.empty?
+          children_str = child_printer.visit(node.children)
+          "(InputDeclaration #{fields.join(' ')}\n#{child_indent}#{children_str}\n#{indent_str})"
+        else
+          "(InputDeclaration #{fields.join(' ')})"
+        end
+      end
+
+      def visit_call_expression(node)
+        return "(CallExpression :#{node.fn_name})" if node.args.empty?
+        
+        args = node.args.map { |arg| child_printer.visit(arg) }
+        "(CallExpression :#{node.fn_name}\n#{indent_str(2)}#{args.join("\n#{indent_str(2)}")}\n#{indent_str})"
+      end
+
+      def visit_array_expression(node)
+        return "(ArrayExpression)" if node.elements.empty?
+        
+        elements = node.elements.map { |elem| child_printer.visit(elem) }
+        "(ArrayExpression\n#{indent_str(2)}#{elements.join("\n#{indent_str(2)}")}\n#{indent_str})"
+      end
+
+      def visit_cascade_expression(node)
+        cases = node.cases.map do |case_expr|
+          "(#{visit(case_expr.condition)} #{visit(case_expr.result)})"
+        end.join("\n#{indent_str(2)}")
+        
+        "(CascadeExpression\n#{indent_str(2)}#{cases}\n#{indent_str})"
+      end
+
+      def visit_case_expression(node)
+        "(CaseExpression #{visit(node.condition)} #{visit(node.result)})"
+      end
+
+      def visit_input_reference(node)
+        "(InputReference :#{node.name})"
+      end
+
+      def visit_input_element_reference(node)
+        "(InputElementReference #{node.path.map(&:to_s).join('.')})"
+      end
+
+      def visit_declaration_reference(node)
+        "(DeclarationReference :#{node.name})"
+      end
+
+      def visit_literal(node)
+        "(Literal #{node.value.inspect})"
+      end
+
+      def visit_hash_expression(node)
+        return "(HashExpression)" if node.pairs.empty?
+        
+        pairs = node.pairs.map do |pair|
+          "(#{visit(pair.key)} #{visit(pair.value)})"
+        end.join("\n#{indent_str(2)}")
+        
+        "(HashExpression\n#{indent_str(2)}#{pairs}\n#{indent_str})"
+      end
+
+      def visit_generic(node)
+        class_name = node.class.name&.split('::')&.last || node.class.to_s
+        
+        if node.respond_to?(:children) && !node.children.empty?
+          children = node.children.map { |child| child_printer.visit(child) }
+          "(#{class_name}\n#{indent_str(2)}#{children.join("\n#{indent_str(2)}")}\n#{indent_str})"
+        elsif node.respond_to?(:members)
+          fields = node.members.reject { |m| m == :loc }.map do |member|
+            value = node[member]
+            "#{member}: #{child_printer.visit(value)}"
+          end
+          
+          return "(#{class_name})" if fields.empty?
+          
+          "(#{class_name}\n#{indent_str(2)}#{fields.join("\n#{indent_str(2)}")}\n#{indent_str})"
+        else
+          "(#{class_name} #{node.inspect})"
+        end
+      end
+
+      def child_printer
+        @child_printer ||= self.class.new(indent: @indent + 2)
+      end
+
+      def indent_str(extra = 0)
+        ' ' * (@indent + extra)
+      end
+
+      def child_indent
+        indent_str(2)
+      end
+    end
+  end
+end

data/lib/kumi/syntax/array_expression.rb

@@ -2,14 +2,14 @@
 
 module Kumi
   module Syntax
-    ArrayExpression = Struct.new(:elements) do
-      include Node
+      ArrayExpression = Struct.new(:elements) do
+        include Node
 
-      def children = elements
+        def children = elements
 
-      def size
-        elements.size
+        def size
+          elements.size
+        end
       end
-    end
   end
 end

data/lib/kumi/syntax/call_expression.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    CallExpression = Struct.new(:fn_name, :args) do
-      include Node
+      CallExpression = Struct.new(:fn_name, :args) do
+        include Node
 
-      def children = args
-    end
+        def children = args
+      end
   end
 end

data/lib/kumi/syntax/cascade_expression.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    CascadeExpression = Struct.new(:cases) do
-      include Node
+      CascadeExpression = Struct.new(:cases) do
+        include Node
 
-      def children = cases
-    end
+        def children = cases
+      end
   end
 end

data/lib/kumi/syntax/case_expression.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    CaseExpression = Struct.new(:condition, :result) do
-      include Node
+      CaseExpression = Struct.new(:condition, :result) do
+        include Node
 
-      def children = [condition, result]
-    end
+        def children = [condition, result]
+      end
   end
 end

data/lib/kumi/syntax/declaration_reference.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    DeclarationReference = Struct.new(:name) do
-      include Node
+      DeclarationReference = Struct.new(:name) do
+        include Node
 
-      def children = []
-    end
+        def children = []
+      end
   end
 end

data/lib/kumi/syntax/hash_expression.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    HashExpression = Struct.new(:pairs) do
-      include Node
+      HashExpression = Struct.new(:pairs) do
+        include Node
 
-      def children = pairs.flatten
-    end
+        def children = pairs.flatten
+      end
   end
 end

data/lib/kumi/syntax/input_declaration.rb

@@ -2,11 +2,11 @@
 
 module Kumi
   module Syntax
-    # For field metadata declarations inside input blocks
-    InputDeclaration = Struct.new(:name, :domain, :type, :children) do
-      include Node
+      # For field metadata declarations inside input blocks
+      InputDeclaration = Struct.new(:name, :domain, :type, :children) do
+        include Node
 
-      def children = self[:children] || []
-    end
+        def children = self[:children] || []
+      end
   end
 end

data/lib/kumi/syntax/input_element_reference.rb

@@ -2,11 +2,11 @@
 
 module Kumi
   module Syntax
-    # For field usage/reference in expressions (input.field_name)
-    InputElementReference = Struct.new(:path) do
-      include Node
+      # For field usage/reference in expressions (input.field_name)
+      InputElementReference = Struct.new(:path) do
+        include Node
 
-      def children = []
-    end
+        def children = []
+      end
   end
 end

data/lib/kumi/syntax/input_reference.rb

@@ -2,11 +2,11 @@
 
 module Kumi
   module Syntax
-    # For field usage/reference in expressions (input.field_name)
-    InputReference = Struct.new(:name) do
-      include Node
+      # For field usage/reference in expressions (input.field_name)
+      InputReference = Struct.new(:name) do
+        include Node
 
-      def children = []
-    end
+        def children = []
+      end
   end
 end

data/lib/kumi/syntax/literal.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    Literal = Struct.new(:value) do
-      include Node
+      Literal = Struct.new(:value) do
+        include Node
 
-      def children = []
-    end
+        def children = []
+      end
   end
 end

data/lib/kumi/syntax/node.rb

@@ -2,45 +2,45 @@
 
 module Kumi
   module Syntax
-    # A struct to hold standardized source location information.
-    Location = Struct.new(:file, :line, :column, keyword_init: true)
+      # A struct to hold standardized source location information.
+      Location = Struct.new(:file, :line, :column, keyword_init: true)
 
-    # Base module included by all AST nodes to provide a standard
-    # interface for accessing source location information..
-    module Node
-      attr_accessor :loc
+      # Base module included by all AST nodes to provide a standard
+      # interface for accessing source location information..
+      module Node
+        attr_accessor :loc
 
-      def initialize(*args, loc: nil, **kwargs)
-        @loc = loc
-        super(*args, **kwargs)
-        freeze
-      end
+        def initialize(*args, loc: nil, **kwargs)
+          @loc = loc
+          super(*args, **kwargs)
+          freeze
+        end
 
-      def ==(other)
-        other.is_a?(self.class) &&
-          # for Struct-based nodes
-          (if respond_to?(:members)
-             members.all? { |m| self[m] == other[m] }
-           else
-             instance_variables.reject { |iv| iv == :@loc }
-                                        .all? do |iv|
-               instance_variable_get(iv) ==
-                                            other.instance_variable_get(iv)
+        def ==(other)
+          other.is_a?(self.class) &&
+            # for Struct-based nodes
+            (if respond_to?(:members)
+               members.all? { |m| self[m] == other[m] }
+             else
+               instance_variables.reject { |iv| iv == :@loc }
+                                          .all? do |iv|
+                 instance_variable_get(iv) ==
+                                              other.instance_variable_get(iv)
+               end
              end
-           end
-          )
-      end
-      alias eql? ==
+            )
+        end
+        alias eql? ==
 
-      def hash
-        values = if respond_to?(:members)
-                   members.map { |m| self[m] }
-                 else
-                   instance_variables.reject { |iv| iv == :@loc }
-                                     .map { |iv| instance_variable_get(iv) }
-                 end
-        [self.class, *values].hash
+        def hash
+          values = if respond_to?(:members)
+                     members.map { |m| self[m] }
+                   else
+                     instance_variables.reject { |iv| iv == :@loc }
+                                       .map { |iv| instance_variable_get(iv) }
+                   end
+          [self.class, *values].hash
+        end
       end
-    end
   end
 end

data/lib/kumi/syntax/root.rb

@@ -2,12 +2,12 @@
 
 module Kumi
   module Syntax
-    # Represents the root of the Abstract Syntax Tree.
-    # It holds all the top-level declarations parsed from the source.
-    Root = Struct.new(:inputs, :attributes, :traits) do
-      include Node
+      # Represents the root of the Abstract Syntax Tree.
+      # It holds all the top-level declarations parsed from the source.
+      Root = Struct.new(:inputs, :attributes, :traits) do
+        include Node
 
-      def children = [inputs, attributes, traits]
-    end
+        def children = [inputs, attributes, traits]
+      end
   end
 end

data/lib/kumi/syntax/trait_declaration.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    TraitDeclaration = Struct.new(:name, :expression) do
-      include Node
+      TraitDeclaration = Struct.new(:name, :expression) do
+        include Node
 
-      def children = [expression]
-    end
+        def children = [expression]
+      end
   end
 end

data/lib/kumi/syntax/value_declaration.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-    ValueDeclaration = Struct.new(:name, :expression) do
-      include Node
+      ValueDeclaration = Struct.new(:name, :expression) do
+        include Node
 
-      def children = [expression]
-    end
+        def children = [expression]
+      end
   end
 end

data/lib/kumi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kumi
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 end