kumi 0.0.0 → 0.0.4

data/lib/kumi/types/inference.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Kumi
+  module Types
+    # Infers types from Ruby values
+    class Inference
+      def self.infer_from_value(value)
+        case value
+        when String then :string
+        when Integer then :integer
+        when Float then :float
+        when TrueClass, FalseClass then :boolean
+        when Symbol then :symbol
+        when Regexp then :regexp
+        when Time then :time
+        when DateTime then :datetime
+        when Date then :date
+        when Array
+          return Kumi::Types.array(:any) if value.empty?
+
+          # Infer element type from first element (simple heuristic)
+          first_elem_type = infer_from_value(value.first)
+          Kumi::Types.array(first_elem_type)
+        when Hash
+          return Kumi::Types.hash(:any, :any) if value.empty?
+
+          # Infer key/value types from first pair (simple heuristic)
+          first_key, first_value = value.first
+          key_type = infer_from_value(first_key)
+          value_type = infer_from_value(first_value)
+          Kumi::Types.hash(key_type, value_type)
+        else
+          :any
+        end
+      end
+    end
+  end
+end

data/lib/kumi/types/normalizer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Kumi
+  module Types
+    # Normalizes different type inputs to canonical forms
+    class Normalizer
+      # Type normalization - convert various inputs to canonical type symbols
+      def self.normalize(type_input)
+        case type_input
+        when Symbol
+          return type_input if Validator.valid_type?(type_input)
+
+          raise ArgumentError, "Invalid type symbol: #{type_input}"
+        when String
+          symbol_type = type_input.to_sym
+          return symbol_type if Validator.valid_type?(symbol_type)
+
+          raise ArgumentError, "Invalid type string: #{type_input}"
+        when Hash
+          return type_input if Validator.valid_type?(type_input)
+
+          raise ArgumentError, "Invalid type hash: #{type_input}"
+        when Class
+          # Handle Ruby class inputs
+          case type_input.name
+          when "Integer" then :integer
+          when "String" then :string
+          when "Float" then :float
+          when "TrueClass", "FalseClass" then :boolean
+          when "Array" then raise ArgumentError, "Use array(:type) helper for array types"
+          when "Hash" then raise ArgumentError, "Use hash(:key_type, :value_type) helper for hash types"
+          else
+            raise ArgumentError, "Unsupported class type: #{type_input}"
+          end
+        else
+          case type_input
+          when Integer, Float, Numeric
+            raise ArgumentError, "Type must be a symbol, got #{type_input} (#{type_input.class})"
+          else
+            raise ArgumentError, "Invalid type input: #{type_input} (#{type_input.class})"
+          end
+        end
+      end
+
+      # Legacy compatibility - coerce old constants to symbols
+      def self.coerce(type_input)
+        # Handle legacy constant usage
+        return type_input if type_input.is_a?(Symbol) && Validator.valid_type?(type_input)
+
+        # Handle legacy constant objects
+        case type_input
+        when STRING then :string
+        when INT then :integer
+        when FLOAT, NUMERIC then :float # Both FLOAT and NUMERIC map to :float
+        when BOOL then :boolean
+        when ANY then :any
+        when SYMBOL then :symbol
+        when REGEXP then :regexp
+        when TIME then :time
+        when DATE then :date
+        when DATETIME then :datetime
+        else
+          normalize(type_input)
+        end
+      end
+    end
+  end
+end

data/lib/kumi/types/validator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Types
+    # Validates type definitions and structures
+    class Validator
+      VALID_TYPES = %i[string integer float boolean any symbol regexp time date datetime].freeze
+
+      def self.valid_type?(type)
+        return true if VALID_TYPES.include?(type)
+        return true if array_type?(type)
+        return true if hash_type?(type)
+
+        false
+      end
+
+      def self.array_type?(type)
+        type.is_a?(Hash) && type.keys == [:array] && valid_type?(type[:array])
+      end
+
+      def self.hash_type?(type)
+        type.is_a?(Hash) &&
+          type.keys.sort == [:hash] &&
+          type[:hash].is_a?(Array) &&
+          type[:hash].size == 2 &&
+          valid_type?(type[:hash][0]) &&
+          valid_type?(type[:hash][1])
+      end
+
+      def self.primitive_type?(type)
+        VALID_TYPES.include?(type)
+      end
+    end
+  end
+end

data/lib/kumi/types.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Types
+    # Re-export constants for compatibility
+    VALID_TYPES = Validator::VALID_TYPES
+
+    # Validation methods
+    def self.valid_type?(type)
+      Validator.valid_type?(type)
+    end
+
+    # Type builders
+    def self.array(elem_type)
+      Builder.array(elem_type)
+    end
+
+    def self.hash(key_type, val_type)
+      Builder.hash(key_type, val_type)
+    end
+
+    # Normalization
+    def self.normalize(type_input)
+      Normalizer.normalize(type_input)
+    end
+
+    def self.coerce(type_input)
+      Normalizer.coerce(type_input)
+    end
+
+    # Compatibility and unification
+    def self.compatible?(type1, type2)
+      Compatibility.compatible?(type1, type2)
+    end
+
+    def self.unify(type1, type2)
+      Compatibility.unify(type1, type2)
+    end
+
+    # Type inference
+    def self.infer_from_value(value)
+      Inference.infer_from_value(value)
+    end
+
+    # Formatting
+    def self.type_to_s(type)
+      Formatter.type_to_s(type)
+    end
+
+    # Legacy compatibility constants (will be phased out)
+    # These should be replaced with symbols in user code over time
+    STRING = :string
+    INT = :integer # NOTE: using :integer instead of :int for clarity
+    FLOAT = :float
+    BOOL = :boolean
+    ANY = :any
+    SYMBOL = :symbol
+    REGEXP = :regexp
+    TIME = :time
+    DATE = :date
+    DATETIME = :datetime
+    NUMERIC = :float # Legacy: represents numeric compatibility
+  end
+end

data/lib/kumi/version.rb

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

data/lib/kumi.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "kumi/version"
+require "zeitwerk"
+# require "pry" # COMMENT AFTER DEBUGGING
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/kumi-cli")
+loader.setup
 
 module Kumi
-  class Error < StandardError; end
-  # Your code goes here...
+  extend Schema
 end

data/scripts/generate_function_docs.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This script loads the Kumi library and introspects the FunctionRegistry
+# to generate a Markdown reference for the standard function library.
+
+require "bundler/setup"
+require "kumi"
+
+# Helper to format the type information for display.
+def format_type(type)
+  Kumi::Types.type_to_s(type)
+end
+
+# Helper to generate a signature string for a function.
+def generate_signature(name, signature)
+  params = if signature[:arity].negative?
+             # Variadic function (e.g., add, concat)
+             param_type = format_type(signature[:param_types].first || :any)
+             "#{param_type}1, #{param_type}2, ..."
+           else
+             # Fixed arity function
+             signature[:param_types].map.with_index { |type, i| "#{format_type(type)} arg#{i + 1}" }.join(", ")
+           end
+
+  return_type = format_type(signature[:return_type])
+  "`fn(:#{name}, #{params})` → `#{return_type}`"
+end
+
+# Main documentation generation logic.
+def generate_docs
+  output = []
+  output << "# Kumi Standard Function Library Reference"
+  output << "\nKumi provides a rich library of built-in functions for use within `value` and `trait` expressions via `fn(...)`."
+
+  categories = {
+    "Logical Functions" => Kumi::FunctionRegistry.logical_operations,
+    "Comparison Functions" => Kumi::FunctionRegistry.comparison_operators,
+    "Math Functions" => Kumi::FunctionRegistry.math_operations,
+    "String Functions" => Kumi::FunctionRegistry.string_operations,
+    "Collection Functions" => Kumi::FunctionRegistry.collection_operations,
+    "Conditional Functions" => Kumi::FunctionRegistry.conditional_operations,
+    "Type & Hash Functions" => Kumi::FunctionRegistry.type_operations
+  }
+
+  categories.each do |title, functions|
+    output << "\n## #{title}\n"
+    functions.sort.each do |name|
+      signature = Kumi::FunctionRegistry.signature(name)
+      output << "* **`#{name}`**: #{signature[:description]}"
+      output << "  * **Usage**: #{generate_signature(name, signature)}"
+    end
+  end
+
+  output.join("\n")
+end
+
+# Execute the script and print the documentation.
+puts generate_docs

data/test_impossible_cascade.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "lib/kumi"
+
+# This test demonstrates that the UnsatDetector still correctly catches
+# genuinely impossible cascade conditions after our fix
+
+puts "🧪 Testing UnsatDetector Catches Impossible Cascade Conditions"
+puts "=" * 60
+
+begin
+  impossible_schema = Class.new do
+    extend Kumi::Schema
+
+    schema do
+      input do
+        integer :age, domain: 0..150
+      end
+
+      # These traits are individually satisfiable
+      trait :very_young, input.age, :<, 25
+      trait :very_old, input.age, :>, 65
+
+      # This cascade condition combines contradictory traits - should be caught!
+      value :impossible_condition do
+        on :very_young, :very_old, "Impossible: young AND old"  # age < 25 AND age > 65
+        base "Normal"
+      end
+    end
+  end
+  
+  puts "❌ ERROR: Should have caught impossible cascade condition!"
+  
+rescue Kumi::Errors::SemanticError => e
+  if e.message.include?("conjunction") && e.message.include?("logically impossible")
+    puts "✅ CORRECTLY CAUGHT impossible cascade condition!"
+    puts "   Error: #{e.message}"
+    puts
+    puts "   This proves the UnsatDetector still works for genuinely impossible conditions"
+    puts "   while allowing valid mutually exclusive cascades."
+  else
+    puts "❌ UNEXPECTED ERROR: #{e.message}"
+  end
+end
+
+puts
+puts "🎉 UnsatDetector Fix Validation Complete!"
+puts "   ✅ Valid mutually exclusive cascades: WORK"
+puts "   ✅ Impossible cascade conditions: CAUGHT"
+puts "   ✅ Existing functionality: PRESERVED"

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.4
 platform: ruby
 authors:
 - André Muta
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -15,17 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: 2.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
-description: Kumi replaces nested if/else logic with a concise DSL that maps data
-  sources                          to derived attributes using reusable traits, functions,
-  and decision tables.
+        version: 2.6.0
 email:
 - andremuta@gmail.com
 executables: []
@@ -35,12 +32,95 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/development/README.md
+- docs/development/error-reporting.md
+- documents/AST.md
+- documents/DSL.md
+- documents/FUNCTIONS.md
+- documents/SYNTAX.md
+- examples/deep_schema_compilation_and_evaluation_benchmark.rb
+- examples/federal_tax_calculator_2024.rb
+- examples/wide_schema_compilation_and_evaluation_benchmark.rb
+- lib/generators/trait_engine/templates/schema_spec.rb.erb
 - lib/kumi.rb
+- lib/kumi/analyzer.rb
+- lib/kumi/analyzer/constant_evaluator.rb
+- lib/kumi/analyzer/passes/definition_validator.rb
+- lib/kumi/analyzer/passes/dependency_resolver.rb
+- lib/kumi/analyzer/passes/input_collector.rb
+- lib/kumi/analyzer/passes/name_indexer.rb
+- lib/kumi/analyzer/passes/pass_base.rb
+- lib/kumi/analyzer/passes/toposorter.rb
+- lib/kumi/analyzer/passes/type_checker.rb
+- lib/kumi/analyzer/passes/type_consistency_checker.rb
+- lib/kumi/analyzer/passes/type_inferencer.rb
+- lib/kumi/analyzer/passes/unsat_detector.rb
+- lib/kumi/analyzer/passes/visitor_pass.rb
+- lib/kumi/atom_unsat_solver.rb
+- lib/kumi/compiled_schema.rb
+- lib/kumi/compiler.rb
+- lib/kumi/domain.rb
+- lib/kumi/domain/enum_analyzer.rb
+- lib/kumi/domain/range_analyzer.rb
+- lib/kumi/domain/validator.rb
+- lib/kumi/domain/violation_formatter.rb
+- lib/kumi/error_reporter.rb
+- lib/kumi/error_reporting.rb
+- lib/kumi/errors.rb
+- lib/kumi/evaluation_wrapper.rb
+- lib/kumi/explain.rb
+- lib/kumi/export.rb
+- lib/kumi/export/deserializer.rb
+- lib/kumi/export/errors.rb
+- lib/kumi/export/node_builders.rb
+- lib/kumi/export/node_registry.rb
+- lib/kumi/export/node_serializers.rb
+- lib/kumi/export/serializer.rb
+- lib/kumi/function_registry.rb
+- lib/kumi/function_registry/collection_functions.rb
+- lib/kumi/function_registry/comparison_functions.rb
+- lib/kumi/function_registry/conditional_functions.rb
+- lib/kumi/function_registry/function_builder.rb
+- lib/kumi/function_registry/logical_functions.rb
+- lib/kumi/function_registry/math_functions.rb
+- lib/kumi/function_registry/string_functions.rb
+- lib/kumi/function_registry/type_functions.rb
+- lib/kumi/input.rb
+- lib/kumi/input/type_matcher.rb
+- lib/kumi/input/validator.rb
+- lib/kumi/input/violation_creator.rb
+- lib/kumi/parser/build_context.rb
+- lib/kumi/parser/dsl.rb
+- lib/kumi/parser/dsl_cascade_builder.rb
+- lib/kumi/parser/expression_converter.rb
+- lib/kumi/parser/guard_rails.rb
+- lib/kumi/parser/input_builder.rb
+- lib/kumi/parser/input_proxy.rb
+- lib/kumi/parser/parser.rb
+- lib/kumi/parser/schema_builder.rb
+- lib/kumi/parser/sugar.rb
+- lib/kumi/schema.rb
+- lib/kumi/schema_instance.rb
+- lib/kumi/syntax.rb
+- lib/kumi/syntax/declarations.rb
+- lib/kumi/syntax/expressions.rb
+- lib/kumi/syntax/node.rb
+- lib/kumi/syntax/root.rb
+- lib/kumi/syntax/terminal_expressions.rb
+- lib/kumi/types.rb
+- lib/kumi/types/builder.rb
+- lib/kumi/types/compatibility.rb
+- lib/kumi/types/formatter.rb
+- lib/kumi/types/inference.rb
+- lib/kumi/types/normalizer.rb
+- lib/kumi/types/validator.rb
 - lib/kumi/version.rb
-- sig/kumi.rbs
+- scripts/generate_function_docs.rb
+- test_impossible_cascade.rb
 homepage: https://github.com/amuta/kumi
 licenses:
 - MIT
@@ -49,6 +129,7 @@ metadata:
   homepage_uri: https://github.com/amuta/kumi
   source_code_uri: https://github.com/amuta/kumi
   changelog_uri: https://github.com/amuta/kumi/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -63,7 +144,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.1
 specification_version: 4
-summary: Declarative trait-driven attribute mapping DSL for Ruby.
+summary: A declarative Ruby DSL for defining business rules and calculations with
+  static dependency checks, cycle detection, domain validation, and human‑readable
+  explainability.
 test_files: []

data/sig/kumi.rbs

@@ -1,4 +0,0 @@
-module Kumi
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end