kumi 0.0.8 → 0.0.10

data/lib/kumi/js/function_registry.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Js
+    # Maps Ruby function registry to JavaScript implementations
+    # Each function maintains the same signature and behavior as the Ruby version
+    module FunctionRegistry
+      # Generate complete JavaScript function registry
+      def self.generate_js_registry
+        {
+          # Mathematical functions
+          **math_functions,
+
+          # Comparison functions
+          **comparison_functions,
+
+          # Logical functions
+          **logical_functions,
+
+          # String functions
+          **string_functions,
+
+          # Collection functions
+          **collection_functions,
+
+          # Conditional functions
+          **conditional_functions,
+
+          # Type functions
+          **type_functions,
+
+          # Statistical functions
+          **stat_functions
+        }
+      end
+
+      # Generate JavaScript code for the function registry
+      def self.generate_js_code(functions_required: nil)
+        registry = generate_js_registry
+
+        # Filter registry to only include required functions if specified
+        registry = registry.slice(*functions_required) if functions_required && !functions_required.empty?
+
+        functions_js = registry.map do |name, js_code|
+          # Handle symbol names that need quoting in JS
+          js_name = name.to_s.match?(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/) ? name : "\"#{name}\""
+          "  #{js_name}: #{js_code}"
+        end.join(",\n")
+
+        <<~JAVASCRIPT
+          const kumiRegistry = {
+          #{functions_js}
+          };
+        JAVASCRIPT
+      end
+
+      def self.math_functions
+        {
+          # Basic arithmetic
+          add: "(a, b) => a + b",
+          subtract: "(a, b) => a - b",
+          multiply: "(a, b) => a * b",
+          divide: "(a, b) => a / b",
+          modulo: "(a, b) => a % b",
+          power: "(a, b) => Math.pow(a, b)",
+
+          # Unary operations
+          abs: "(a) => Math.abs(a)",
+          floor: "(a) => Math.floor(a)",
+          ceil: "(a) => Math.ceil(a)",
+
+          # Special operations
+          round: "(a, precision = 0) => Number(a.toFixed(precision))",
+          clamp: "(value, min, max) => Math.min(max, Math.max(min, value))",
+
+          # Complex mathematical operations
+          piecewise_sum: <<~JS.strip
+            (value, breaks, rates) => {
+              if (breaks.length !== rates.length) {
+                throw new Error('breaks & rates size mismatch');
+              }
+            #{'  '}
+              let acc = 0.0;
+              let previous = 0.0;
+              let marginal = rates[rates.length - 1];
+            #{'  '}
+              for (let i = 0; i < breaks.length; i++) {
+                const upper = breaks[i];
+                const rate = rates[i];
+            #{'    '}
+                if (value <= upper) {
+                  marginal = rate;
+                  acc += (value - previous) * rate;
+                  break;
+                } else {
+                  acc += (upper - previous) * rate;
+                  previous = upper;
+                }
+              }
+            #{'  '}
+              return [acc, marginal];
+            }
+          JS
+        }
+      end
+
+      def self.comparison_functions
+        {
+          # Equality operators (using strict equality)
+          "==": "(a, b) => a === b",
+          "!=": "(a, b) => a !== b",
+
+          # Comparison operators
+          ">": "(a, b) => a > b",
+          "<": "(a, b) => a < b",
+          ">=": "(a, b) => a >= b",
+          "<=": "(a, b) => a <= b",
+
+          # Range comparison
+          between?: "(value, min, max) => value >= min && value <= max"
+        }
+      end
+
+      def self.logical_functions
+        {
+          # Basic logical operations
+          and: "(...conditions) => conditions.every(x => x)",
+          or: "(...conditions) => conditions.some(x => x)",
+          not: "(a) => !a",
+
+          # Collection logical operations
+          all?: "(collection) => collection.every(x => x)",
+          any?: "(collection) => collection.some(x => x)",
+          none?: "(collection) => !collection.some(x => x)",
+
+          # Element-wise AND for cascades - works on arrays with hierarchical broadcasting
+          cascade_and: <<~JS.strip
+            (...conditions) => {
+              if (conditions.length === 0) return false;
+              if (conditions.length === 1) return conditions[0];
+            #{'  '}
+              // Start with first condition
+              let result = conditions[0];
+            #{'  '}
+              // Apply element-wise AND with remaining conditions using hierarchical broadcasting
+              for (let i = 1; i < conditions.length; i++) {
+                result = kumiRuntime.elementWiseAnd(result, conditions[i]);
+              }
+            #{'  '}
+              return result;
+            }
+          JS
+        }
+      end
+
+      def self.string_functions
+        {
+          # String transformations
+          upcase: "(str) => str.toString().toUpperCase()",
+          downcase: "(str) => str.toString().toLowerCase()",
+          capitalize: "(str) => { const s = str.toString(); return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase(); }",
+          strip: "(str) => str.toString().trim()",
+
+          # String queries
+          string_length: "(str) => str.toString().length",
+          length: "(str) => str.toString().length",
+
+          # String inclusion checks
+          string_include?: "(str, substr) => str.toString().includes(substr.toString())",
+          includes?: "(str, substr) => str.toString().includes(substr.toString())",
+          contains?: "(str, substr) => str.toString().includes(substr.toString())",
+          start_with?: "(str, prefix) => str.toString().startsWith(prefix.toString())",
+          end_with?: "(str, suffix) => str.toString().endsWith(suffix.toString())",
+
+          # String building
+          concat: "(...strings) => strings.map(s => s.toString()).join('')"
+        }
+      end
+
+      def self.collection_functions
+        {
+          # Collection queries (reducers)
+          empty?: "(collection) => collection.length === 0",
+          size: "(collection) => collection.length",
+
+          # Element access
+          first: "(collection) => collection[0]",
+          last: "(collection) => collection[collection.length - 1]",
+
+          # Mathematical operations on collections
+          sum: "(collection) => collection.reduce((a, b) => a + b, 0)",
+          min: "(collection) => Math.min(...collection)",
+          max: "(collection) => Math.max(...collection)",
+
+          # Collection operations
+          include?: "(collection, element) => collection.includes(element)",
+          reverse: "(collection) => [...collection].reverse()",
+          sort: "(collection) => [...collection].sort()",
+          unique: "(collection) => [...new Set(collection)]",
+          flatten: "(collection) => collection.flat(Infinity)",
+          flatten_one: "(collection) => collection.flat(1)",
+          flatten_deep: "(collection) => collection.flat(Infinity)",
+
+          # Array transformation functions
+          map_multiply: "(collection, factor) => collection.map(x => x * factor)",
+          map_add: "(collection, value) => collection.map(x => x + value)",
+          map_conditional: "(collection, condition_value, true_value, false_value) => collection.map(x => x === condition_value ? true_value : false_value)",
+
+          # Range/index functions
+          build_array: "(size) => Array.from({length: size}, (_, i) => i)",
+          range: "(start, finish) => Array.from({length: finish - start}, (_, i) => start + i)",
+
+          # Array slicing and grouping
+          each_slice: <<~JS.strip,
+            (array, size) => {
+              const result = [];
+              for (let i = 0; i < array.length; i += size) {
+                result.push(array.slice(i, i + size));
+              }
+              return result;
+            }
+          JS
+
+          join: "(array, separator = '') => array.map(x => x.toString()).join(separator.toString())",
+
+          map_join_rows: "(array_of_arrays, row_separator = '', column_separator = '\\n') => array_of_arrays.map(row => row.join(row_separator.toString())).join(column_separator.toString())",
+
+          # Higher-order collection functions
+          map_with_index: "(collection) => collection.map((item, index) => [item, index])",
+          indices: "(collection) => Array.from({length: collection.length}, (_, i) => i)",
+
+          # Conditional aggregation functions
+          count_if: "(condition_array) => condition_array.filter(x => x === true).length",
+          sum_if: "(value_array, condition_array) => value_array.reduce((sum, value, i) => sum + (condition_array[i] ? value : 0), 0)",
+          avg_if: <<~JS.strip,
+            (value_array, condition_array) => {
+              const pairs = value_array.map((value, i) => [value, condition_array[i]]);
+              const true_values = pairs.filter(([_, condition]) => condition).map(([value, _]) => value);
+              return true_values.length === 0 ? 0.0 : true_values.reduce((a, b) => a + b, 0) / true_values.length;
+            }
+          JS
+
+          # Flattening utilities for hierarchical data
+          any_across: "(nested_array) => nested_array.flat(Infinity).some(x => x)",
+          all_across: "(nested_array) => nested_array.flat(Infinity).every(x => x)",
+          count_across: "(nested_array) => nested_array.flat(Infinity).length"
+        }
+      end
+
+      def self.conditional_functions
+        {
+          conditional: "(condition, true_value, false_value) => condition ? true_value : false_value",
+          if: "(condition, true_value, false_value = null) => condition ? true_value : false_value",
+          coalesce: "(...values) => values.find(v => v != null)"
+        }
+      end
+
+      def self.type_functions
+        {
+          # Hash/object operations - assuming TypeFunctions exists
+          fetch: "(hash, key, default_value = null) => hash.hasOwnProperty(key) ? hash[key] : default_value",
+          has_key?: "(hash, key) => hash.hasOwnProperty(key)",
+          keys: "(hash) => Object.keys(hash)",
+          values: "(hash) => Object.values(hash)",
+          at: "(collection, index) => collection[index]"
+        }
+      end
+
+      def self.stat_functions
+        {
+          # Statistical functions - mirror Ruby StatFunctions behavior
+          avg: "(array) => array.length === 0 ? 0 : array.reduce((sum, val) => sum + val, 0) / array.length",
+          mean: "(array) => array.length === 0 ? 0 : array.reduce((sum, val) => sum + val, 0) / array.length",
+          median: <<~JS.strip,
+            (array) => {
+              if (array.length === 0) return 0;
+              const sorted = [...array].sort((a, b) => a - b);
+              const mid = Math.floor(sorted.length / 2);
+              return sorted.length % 2 === 0#{' '}
+                ? (sorted[mid - 1] + sorted[mid]) / 2
+                : sorted[mid];
+            }
+          JS
+          variance: <<~JS.strip,
+            (array) => {
+              if (array.length === 0) return 0;
+              const mean = array.reduce((sum, val) => sum + val, 0) / array.length;
+              const squaredDiffs = array.map(val => Math.pow(val - mean, 2));
+              return squaredDiffs.reduce((sum, val) => sum + val, 0) / array.length;
+            }
+          JS
+          stdev: <<~JS.strip,
+            (array) => {
+              if (array.length === 0) return 0;
+              const mean = array.reduce((sum, val) => sum + val, 0) / array.length;
+              const squaredDiffs = array.map(val => Math.pow(val - mean, 2));
+              const variance = squaredDiffs.reduce((sum, val) => sum + val, 0) / array.length;
+              return Math.sqrt(variance);
+            }
+          JS
+          sample_variance: <<~JS.strip,
+            (array) => {
+              if (array.length <= 1) return 0;
+              const mean = array.reduce((sum, val) => sum + val, 0) / array.length;
+              const squaredDiffs = array.map(val => Math.pow(val - mean, 2));
+              return squaredDiffs.reduce((sum, val) => sum + val, 0) / (array.length - 1);
+            }
+          JS
+          sample_stdev: <<~JS.strip,
+            (array) => {
+              if (array.length <= 1) return 0;
+              const mean = array.reduce((sum, val) => sum + val, 0) / array.length;
+              const squaredDiffs = array.map(val => Math.pow(val - mean, 2));
+              const variance = squaredDiffs.reduce((sum, val) => sum + val, 0) / (array.length - 1);
+              return Math.sqrt(variance);
+            }
+          JS
+          # Flattened statistics functions
+          flat_size: "(nestedArray) => nestedArray.flat(Infinity).length",
+          flat_sum: "(nestedArray) => nestedArray.flat(Infinity).reduce((sum, val) => sum + val, 0)",
+          flat_avg: <<~JS.strip,
+            (nestedArray) => {
+              const flattened = nestedArray.flat(Infinity);
+              return flattened.length === 0 ? 0 : flattened.reduce((sum, val) => sum + val, 0) / flattened.length;
+            }
+          JS
+          flat_max: "(nestedArray) => Math.max(...nestedArray.flat(Infinity))",
+          flat_min: "(nestedArray) => Math.min(...nestedArray.flat(Infinity))"
+        }
+      end
+    end
+  end
+end

data/lib/kumi/js.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Js
+    # JavaScript transpiler for Kumi schemas
+    # Extends the existing compiler architecture to output JavaScript instead of Ruby lambdas
+
+    # Export a compiled schema to JavaScript
+    def self.compile(schema_class, **options)
+      syntax_tree = schema_class.__syntax_tree__
+      analyzer_result = schema_class.__analyzer_result__
+
+      compiler = Compiler.new(syntax_tree, analyzer_result)
+      compiler.compile(**options)
+    end
+
+    # Export to JavaScript file
+    def self.export_to_file(schema_class, filename, **options)
+      js_code = compile(schema_class, **options)
+      File.write(filename, js_code)
+    end
+  end
+end

data/lib/kumi/registry.rb

@@ -1,6 +1,15 @@
+# frozen_string_literal: true
+
 module Kumi
+  # Public interface for registering custom functions in Kumi schemas
+  #
+  # Usage:
+  #   Kumi::Registry.register(:my_function) do |x|
+  #     x * 2
+  #   end
   module Registry
     extend Core::FunctionRegistry
+
     Entry = Core::FunctionRegistry::FunctionBuilder::Entry
 
     @functions = Core::FunctionRegistry::CORE_FUNCTIONS.transform_values(&:dup)
@@ -17,11 +26,62 @@ module Kumi
         end
       end
 
+      # Register a custom function with the Kumi function registry
+      #
+      # Example:
+      #   Kumi::Registry.register(:double) do |x|
+      #     x * 2
+      #   end
+      #
+      #   # Use in schema:
+      #   value :doubled, fn(:double, input.number)
       def register(name, &block)
         @lock.synchronize do
           raise FrozenError, "registry is frozen" if @frozen
+          raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
+
+          fn_lambda = block.is_a?(Proc) ? block : ->(*args) { yield(*args) }
+          @functions[name] = Entry.new(
+            fn: fn_lambda,
+            arity: fn_lambda.arity,
+            param_types: [:any],
+            return_type: :any,
+            description: nil,
+            inverse: nil,
+            reducer: false
+          )
+        end
+      end
+
+      # Register a custom function with detailed metadata for type and domain validation
+      #
+      # Example:
+      #   Kumi::Registry.register_with_metadata(
+      #     :add_tax,
+      #     ->(amount, rate) { amount * (1 + rate) },
+      #     arity: 2,
+      #     param_types: [:float, :float],
+      #     return_type: :float,
+      #     description: "Adds tax to an amount",
+      #   )
+      #
+      #   # Use in schema:
+      #   value :total, fn(:add_tax, input.price, input.tax_rate)
+      def register_with_metadata(name, fn_lambda, arity:, param_types: [:any], return_type: :any, description: nil, inverse: nil,
+                                 reducer: false)
+        @lock.synchronize do
+          raise FrozenError, "registry is frozen" if @frozen
+          raise ArgumentError, "Function #{name.inspect} already registered" if @functions.key?(name)
 
-          super
+          @functions[name] = Entry.new(
+            fn: fn_lambda,
+            arity: arity,
+            param_types: param_types,
+            return_type: return_type,
+            description: description,
+            inverse: inverse,
+            reducer: reducer
+          )
         end
       end
 

data/lib/kumi/schema.rb

@@ -8,7 +8,7 @@ module Kumi
 
     Inspector = Struct.new(:syntax_tree, :analyzer_result, :compiled_schema) do
       def inspect
-        "#<#{self.class} syntax_tree: #{syntax_tree.inspect}, analyzer_result: #{analyzer_result.inspect}, schema: #{schema.inspect}>"
+        "#<#{self.class} syntax_tree: #{syntax_tree.inspect}, analyzer_result: #{analyzer_result.inspect}, compiled_schema: #{compiled_schema.inspect}>"
       end
     end
 

data/lib/kumi/support/s_expression_printer.rb

@@ -0,0 +1,162 @@
+# 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
+        fields << "access_mode: #{node.access_mode.inspect}" if node.respond_to?(:access_mode) && node.access_mode
+
+        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
-        end
+      def size
+        elements.size
       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