kumi 0.0.7 → 0.0.9

data/lib/kumi/core/export/node_serializers.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Export
+      module NodeSerializers
+        # Root node: top-level container
+        def serialize_root(node)
+          {
+            type: "root",
+            inputs: node.inputs.map { |input| serialize_node(input) },
+            attributes: node.attributes.map { |attr| serialize_node(attr) },
+            traits: node.traits.map { |trait| serialize_node(trait) }
+          }
+        end
+
+        # Field Declaration: preserves type info for analyzer
+        def serialize_field_declaration(node)
+          {
+            name: node.name.to_s,
+            name_type: node.name.class.name,
+            field_type: serialize_type(node.type),
+            domain: serialize_domain(node.domain)
+          }
+        end
+
+        # Attribute Declaration: preserves name and expression tree
+        def serialize_attribute_declaration(node)
+          {
+            name: node.name.to_s,
+            name_type: node.name.class.name,
+            expression: serialize_node(node.expression)
+          }
+        end
+
+        # Trait Declaration: preserves name and expression tree
+        def serialize_trait_declaration(node)
+          {
+            name: node.name.to_s,
+            name_type: node.name.class.name,
+            expression: serialize_node(node.expression)
+          }
+        end
+
+        # Call Expression: critical for dependency analysis
+        def serialize_call_expression(node)
+          {
+            function_name: node.fn_name.to_s,
+            function_name_type: node.fn_name.class.name,
+            arguments: node.args.map { |arg| serialize_node(arg) }
+          }
+        end
+
+        # Literal: preserve exact value and Ruby type
+        def serialize_literal(node)
+          {
+            value: node.value,
+            ruby_type: node.value.class.name
+          }
+        end
+
+        # Field Reference: critical for dependency resolution
+        def serialize_field_reference(node)
+          {
+            field_name: node.name.to_s,
+            name_type: node.name.class.name
+          }
+        end
+
+        # DeclarationReference Reference: critical for dependency resolution
+        def serialize_binding_reference(node)
+          {
+            binding_name: node.name.to_s,
+            name_type: node.name.class.name
+          }
+        end
+
+        # List Expression: preserve order and elements
+        def serialize_list_expression(node)
+          {
+            elements: node.elements.map { |element| serialize_node(element) }
+          }
+        end
+
+        # Cascade Expression: preserve condition/result pairs
+        def serialize_cascade_expression(node)
+          {
+            cases: node.cases.map { |case_node| serialize_node(case_node) }
+          }
+        end
+
+        # When Case Expression: individual case in cascade
+        def serialize_when_case_expression(node)
+          {
+            condition: serialize_node(node.condition),
+            result: serialize_node(node.result)
+          }
+        end
+
+        private
+
+        def serialize_type(type)
+          case type
+          when Symbol
+            { type: "symbol", value: type.to_s }
+          when Hash
+            if type.key?(:array)
+              { type: "array", element_type: serialize_type(type[:array]) }
+            elsif type.key?(:hash)
+              { type: "hash", key_type: serialize_type(type[:hash][0]), value_type: serialize_type(type[:hash][1]) }
+            else
+              { type: "hash", value: type }
+            end
+          when String, Integer, Float, TrueClass, FalseClass, NilClass
+            { type: "literal", value: type }
+          else
+            { type: "unknown", value: type.to_s }
+          end
+        end
+
+        def serialize_domain(domain)
+          return nil unless domain
+
+          case domain
+          when Range
+            { type: "range", min: domain.min, max: domain.max, exclude_end: domain.exclude_end? }
+          when Array
+            { type: "array", values: domain }
+          else
+            { type: "custom", value: domain.to_s }
+          end
+        end
+
+        def serialize_node(node)
+          type_name = NodeRegistry.type_name_for(node)
+
+          base_data = {
+            type: type_name,
+            **send("serialize_#{type_name}", node)
+          }
+
+          add_location_if_present(base_data, node) if @include_locations
+          base_data
+        end
+
+        def add_location_if_present(data, node)
+          return unless node.respond_to?(:loc) && node.loc
+
+          data[:location] = {
+            line: node.loc.line,
+            column: node.loc.column,
+            file: node.loc.file
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/export/serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Export
+      class Serializer
+        include NodeSerializers
+
+        def initialize(pretty: false, include_locations: false)
+          @pretty = pretty
+          @include_locations = include_locations
+        end
+
+        def serialize(syntax_root)
+          json_data = {
+            kumi_version: VERSION,
+            ast: serialize_root(syntax_root)
+          }
+
+          @pretty ? JSON.pretty_generate(json_data) : JSON.generate(json_data)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/export.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kumi
+  module Core
+    module Export
+      # Core interface - only depends on Syntax::Root
+      def self.to_json(syntax_root, **options)
+        Serializer.new(**options).serialize(syntax_root)
+      end
+
+      def self.from_json(json_string, **options)
+        Deserializer.new(**options).deserialize(json_string)
+      end
+
+      # Convenience methods
+      def self.to_file(syntax_root, filepath, **options)
+        File.write(filepath, to_json(syntax_root, **options))
+      end
+
+      def self.from_file(filepath, **options)
+        from_json(File.read(filepath), **options)
+      end
+
+      # Validation without import
+      def self.valid?(json_string)
+        from_json(json_string)
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/kumi/core/function_registry/collection_functions.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # Collection manipulation and query functions
+      module CollectionFunctions
+        def self.definitions
+          {
+            # Collection queries (these are reducers - they reduce arrays to scalars)
+            empty?: FunctionBuilder.collection_unary(:empty?, "Check if collection is empty", :empty?, reducer: true),
+            size: FunctionBuilder.collection_unary(:size, "Get collection size", :size, return_type: :integer, reducer: true),
+            length: FunctionBuilder.collection_unary(:length, "Get collection length", :length, return_type: :integer, reducer: true),
+
+            # Element access
+            first: FunctionBuilder::Entry.new(
+              fn: lambda(&:first),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: :any,
+              description: "Get first element of collection",
+              reducer: true
+            ),
+
+            last: FunctionBuilder::Entry.new(
+              fn: lambda(&:last),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: :any,
+              description: "Get last element of collection",
+              reducer: true
+            ),
+
+            # Mathematical operations on collections
+            sum: FunctionBuilder::Entry.new(
+              fn: lambda(&:sum),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:float)],
+              return_type: :float,
+              description: "Sum all numeric elements in collection",
+              reducer: true
+            ),
+
+            min: FunctionBuilder::Entry.new(
+              fn: lambda(&:min),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:float)],
+              return_type: :float,
+              description: "Find minimum value in numeric collection",
+              reducer: true
+            ),
+
+            max: FunctionBuilder::Entry.new(
+              fn: lambda(&:max),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:float)],
+              return_type: :float,
+              description: "Find maximum value in numeric collection",
+              reducer: true
+            ),
+
+            # Collection operations
+            include?: FunctionBuilder::Entry.new(
+              fn: ->(collection, element) { collection.include?(element) },
+              arity: 2,
+              param_types: [Kumi::Core::Types.array(:any), :any],
+              return_type: :boolean,
+              description: "Check if collection includes element"
+            ),
+
+            reverse: FunctionBuilder::Entry.new(
+              fn: lambda(&:reverse),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Reverse collection order"
+            ),
+
+            sort: FunctionBuilder::Entry.new(
+              fn: lambda(&:sort),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Sort collection"
+            ),
+
+            unique: FunctionBuilder::Entry.new(
+              fn: lambda(&:uniq),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Remove duplicate elements from collection"
+            ),
+
+            # Array transformation functions
+            flatten: FunctionBuilder::Entry.new(
+              fn: lambda(&:flatten),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Flatten nested arrays into a single array"
+            ),
+
+            # Mathematical transformation functions
+            map_multiply: FunctionBuilder::Entry.new(
+              fn: ->(collection, factor) { collection.map { |x| x * factor } },
+              arity: 2,
+              param_types: [Kumi::Core::Types.array(:float), :float],
+              return_type: Kumi::Core::Types.array(:float),
+              description: "Multiply each element by factor"
+            ),
+
+            map_add: FunctionBuilder::Entry.new(
+              fn: ->(collection, value) { collection.map { |x| x + value } },
+              arity: 2,
+              param_types: [Kumi::Core::Types.array(:float), :float],
+              return_type: Kumi::Core::Types.array(:float),
+              description: "Add value to each element"
+            ),
+
+            # Conditional transformation functions
+            map_conditional: FunctionBuilder::Entry.new(
+              fn: lambda { |collection, condition_value, true_value, false_value|
+                collection.map { |x| x == condition_value ? true_value : false_value }
+              },
+              arity: 4,
+              param_types: %i[array any any any],
+              return_type: :array,
+              description: "Transform elements based on condition: if element == condition_value then true_value else false_value"
+            ),
+
+            # Range/index functions for grid operations
+            build_array: FunctionBuilder::Entry.new(
+              fn: lambda { |size, &generator|
+                (0...size).map { |i| generator ? generator.call(i) : i }
+              },
+              arity: 1,
+              param_types: [:integer],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Build array of given size with index values"
+            ),
+
+            range: FunctionBuilder::Entry.new(
+              fn: ->(start, finish) { (start...finish).to_a },
+              arity: 2,
+              param_types: %i[integer integer],
+              return_type: Kumi::Core::Types.array(:integer),
+              description: "Generate range of integers from start to finish (exclusive)"
+            ),
+
+            # Array slicing and grouping for rendering
+            each_slice: FunctionBuilder::Entry.new(
+              fn: ->(array, size) { array.each_slice(size).to_a },
+              arity: 2,
+              param_types: %i[array integer],
+              return_type: Kumi::Core::Types.array(:array),
+              description: "Group array elements into subarrays of given size"
+            ),
+
+            join: FunctionBuilder::Entry.new(
+              fn: lambda { |array, separator = ""|
+                array.map(&:to_s).join(separator.to_s)
+              },
+              arity: 2,
+              param_types: %i[array string],
+              return_type: :string,
+              description: "Join array elements into string with separator"
+            ),
+
+            # Transform each subarray to string and join the results
+            map_join_rows: FunctionBuilder::Entry.new(
+              fn: lambda { |array_of_arrays, row_separator = "", column_separator = "\n"|
+                array_of_arrays.map { |row| row.join(row_separator.to_s) }.join(column_separator.to_s)
+              },
+              arity: 3,
+              param_types: [Kumi::Core::Types.array(:array), :string, :string],
+              return_type: :string,
+              description: "Join 2D array into string with row and column separators"
+            ),
+
+            # Higher-order collection functions (limited to common patterns)
+            map_with_index: FunctionBuilder::Entry.new(
+              fn: ->(collection) { collection.map.with_index.to_a },
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Map collection elements to [element, index] pairs"
+            ),
+
+            indices: FunctionBuilder::Entry.new(
+              fn: ->(collection) { (0...collection.size).to_a },
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:integer),
+              description: "Generate array of indices for the collection"
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/function_registry/comparison_functions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # Comparison and equality functions
+      module ComparisonFunctions
+        def self.definitions
+          {
+            # Equality operators
+            :== => FunctionBuilder.equality(:==, "Equality comparison", :==),
+            :!= => FunctionBuilder.equality(:!=, "Inequality comparison", :!=),
+
+            # Comparison operators
+            :> => FunctionBuilder.comparison(:>, "Greater than comparison", :>),
+            :< => FunctionBuilder.comparison(:<, "Less than comparison", :<),
+            :>= => FunctionBuilder.comparison(:>=, "Greater than or equal comparison", :>=),
+            :<= => FunctionBuilder.comparison(:<=, "Less than or equal comparison", :<=),
+
+            # Range comparison
+            :between? => FunctionBuilder::Entry.new(
+              fn: ->(value, min, max) { value.between?(min, max) },
+              arity: 3,
+              param_types: %i[float float float],
+              return_type: :boolean,
+              description: "Check if value is between min and max"
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/function_registry/conditional_functions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # Conditional and control flow functions
+      module ConditionalFunctions
+        def self.definitions
+          {
+            conditional: FunctionBuilder::Entry.new(
+              fn: ->(condition, true_value, false_value) { condition ? true_value : false_value },
+              arity: 3,
+              param_types: %i[boolean any any],
+              return_type: :any,
+              description: "Ternary conditional operator"
+            ),
+
+            if: FunctionBuilder::Entry.new(
+              fn: ->(condition, true_value, false_value = nil) { condition ? true_value : false_value },
+              arity: -1, # Variable arity (2 or 3)
+              param_types: %i[boolean any any],
+              return_type: :any,
+              description: "If-then-else conditional"
+            ),
+
+            coalesce: FunctionBuilder::Entry.new(
+              fn: ->(*values) { values.find { |v| !v.nil? } },
+              arity: -1, # Variable arity
+              param_types: [:any],
+              return_type: :any,
+              description: "Return first non-nil value"
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/function_registry/function_builder.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # Utility class to reduce repetition in function definitions
+      class FunctionBuilder
+        Entry = Struct.new(:fn, :arity, :param_types, :return_type, :description, :inverse, :reducer, keyword_init: true)
+
+        def self.comparison(_name, description, operation)
+          Entry.new(
+            fn: ->(a, b) { a.public_send(operation, b) },
+            arity: 2,
+            param_types: %i[float float],
+            return_type: :boolean,
+            description: description
+          )
+        end
+
+        def self.equality(_name, description, operation)
+          Entry.new(
+            fn: ->(a, b) { a.public_send(operation, b) },
+            arity: 2,
+            param_types: %i[any any],
+            return_type: :boolean,
+            description: description
+          )
+        end
+
+        def self.math_binary(_name, description, operation, return_type: :float)
+          Entry.new(
+            fn: lambda { |a, b|
+              a.public_send(operation, b)
+            },
+            arity: 2,
+            param_types: %i[float float],
+            return_type: return_type,
+            description: description
+          )
+        end
+
+        def self.math_unary(_name, description, operation, return_type: :float)
+          Entry.new(
+            fn: proc(&operation),
+            arity: 1,
+            param_types: [:float],
+            return_type: return_type,
+            description: description
+          )
+        end
+
+        def self.string_unary(_name, description, operation)
+          Entry.new(
+            fn: ->(str) { str.to_s.public_send(operation) },
+            arity: 1,
+            param_types: [:string],
+            return_type: :string,
+            description: description
+          )
+        end
+
+        def self.string_binary(_name, description, operation, return_type: :string)
+          Entry.new(
+            fn: ->(str, arg) { str.to_s.public_send(operation, arg.to_s) },
+            arity: 2,
+            param_types: %i[string string],
+            return_type: return_type,
+            description: description
+          )
+        end
+
+        def self.logical_variadic(_name, description, operation)
+          Entry.new(
+            fn: ->(conditions) { conditions.public_send(operation) },
+            arity: -1,
+            param_types: [:boolean],
+            return_type: :boolean,
+            description: description
+          )
+        end
+
+        def self.collection_unary(_name, description, operation, return_type: :boolean, reducer: false)
+          Entry.new(
+            fn: proc(&operation),
+            arity: 1,
+            param_types: [Kumi::Core::Types.array(:any)],
+            return_type: return_type,
+            description: description,
+            reducer: reducer
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/function_registry/logical_functions.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module FunctionRegistry
+      # Logical operations and boolean functions
+      module LogicalFunctions
+        def self.definitions
+          {
+            # Basic logical operations
+            and: FunctionBuilder::Entry.new(
+              fn: ->(*conditions) { conditions.all? },
+              arity: -1,
+              param_types: [:boolean],
+              return_type: :boolean,
+              description: "Logical AND of multiple conditions"
+            ),
+
+            or: FunctionBuilder::Entry.new(
+              fn: ->(*conditions) { conditions.any? },
+              arity: -1,
+              param_types: [:boolean],
+              return_type: :boolean,
+              description: "Logical OR of multiple conditions"
+            ),
+
+            not: FunctionBuilder::Entry.new(
+              fn: lambda(&:!),
+              arity: 1,
+              param_types: [:boolean],
+              return_type: :boolean,
+              description: "Logical NOT"
+            ),
+
+            # Collection logical operations
+            all?: FunctionBuilder.collection_unary(:all?, "Check if all elements in collection are truthy", :all?),
+            any?: FunctionBuilder.collection_unary(:any?, "Check if any element in collection is truthy", :any?),
+            none?: FunctionBuilder.collection_unary(:none?, "Check if no elements in collection are truthy", :none?)
+          }
+        end
+      end
+    end
+  end
+end