kumi 0.0.27 → 0.0.28

data/lib/kumi/core/functions/overload_resolver.rb

@@ -26,20 +26,37 @@ module Kumi
         def resolve(alias_or_id, arg_types)
           s = alias_or_id.to_s
 
-          # If it's already a full function ID, validate and return it
+          # If it's already a full function ID, validate arity and type constraints
           if @functions.key?(s)
             validate_arity!(s, arg_types)
-            return s
+            fn = @functions[s]
+            score = match_score(fn.params, arg_types)
+            if score > 0
+              return s
+            else
+              # Type constraints failed
+              raise ResolutionError,
+                    "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
+            end
           end
 
           # Get all candidate overloads for this alias
           candidates = @alias_overloads[s]
           raise ResolutionError, "unknown function #{alias_or_id}" if candidates.nil?
 
-          # Single overload - use it directly
+          # Single overload - validate type constraints too
           if candidates.size == 1
-            validate_arity!(candidates.first, arg_types)
-            return candidates.first
+            fn_id = candidates.first
+            validate_arity!(fn_id, arg_types)
+            fn = @functions[fn_id]
+            score = match_score(fn.params, arg_types)
+            if score > 0
+              return fn_id
+            else
+              # Type constraints failed for the only overload
+              raise ResolutionError,
+                    "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
+            end
           end
 
           # Multiple overloads - find best match by type constraints (prefer exact matches)
@@ -56,10 +73,8 @@ module Kumi
           end
 
           # No match found - provide helpful error
-          available = candidates.map { |id| @functions[id].id }.join(", ")
           raise ResolutionError,
-                "no overload of '#{alias_or_id}' matches argument types #{arg_types.inspect}. " \
-                "Available overloads: #{available}"
+                "#{alias_or_id}(#{format_types(arg_types)}) - type mismatch"
         end
 
         # Get function object by ID (already resolved)
@@ -99,7 +114,7 @@ module Kumi
 
         def match_score(params, arg_types)
           # Returns match quality: higher is better
-          # 0 = no match, 1 = matches with unconstrained params, 2 = exact match
+          # 0 = no match, 1+ = match (1 for unconstrained params, higher for exact matches)
           return 0 unless params_match?(params, arg_types)
 
           # Count exact constraint matches (all arg_types are Type objects now)
@@ -108,11 +123,22 @@ module Kumi
             score_type_object_match(param_dtype, arg_type)
           end
 
-          exact_matches
+          # Return exact_matches + 1 so that: unconstrained=1, one exact=2, all exact=N+1
+          exact_matches + 1
         end
 
         def score_type_object_match(param_dtype, type_obj)
-          case param_dtype&.to_s
+          constraint = param_dtype&.to_s
+          return false unless constraint
+
+          # Check if it's a type category
+          if TypeCategories.category?(constraint)
+            return false unless type_obj.is_a?(Kumi::Core::Types::ScalarType)
+            return TypeCategories.includes?(constraint, type_obj.kind)
+          end
+
+          # Individual scalar type constraints
+          case constraint
           when "string"
             type_obj.is_a?(Kumi::Core::Types::ScalarType) && type_obj.kind == :string
           when "array"
@@ -131,6 +157,13 @@ module Kumi
         def type_compatible?(param_dtype_str, arg_type)
           raise ArgumentError, "arg_type must be a Type object, got #{arg_type.inspect}" unless arg_type.is_a?(Kumi::Core::Types::Type)
 
+          # Check if it's a type category
+          if TypeCategories.category?(param_dtype_str)
+            return false unless arg_type.is_a?(Kumi::Core::Types::ScalarType)
+            return TypeCategories.includes?(param_dtype_str, arg_type.kind)
+          end
+
+          # Individual scalar type constraints
           case param_dtype_str
           when "string"
             arg_type.is_a?(Kumi::Core::Types::ScalarType) && arg_type.kind == :string
@@ -156,6 +189,19 @@ module Kumi
                 "function #{fn_id} expects #{fn.params.size} arguments, got #{arg_types.size}"
         end
 
+        private
+
+        def format_types(arg_types)
+          arg_types.map(&:to_s).join(", ")
+        end
+
+        def format_param_constraints(params)
+          params.map do |param|
+            dtype = param["dtype"]
+            dtype || "any"
+          end.join(", ")
+        end
+
         # Custom error for function resolution failures
         class ResolutionError < StandardError; end
       end

data/lib/kumi/core/functions/type_categories.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    module Functions
+      # Type categories define reusable type constraints
+      # Instead of hardcoding type checks scattered throughout the codebase,
+      # we define categories once and reference them in function definitions
+      class TypeCategories
+        # Define type categories as unions of scalar kinds
+        CATEGORIES = {
+          numeric: [:integer, :float, :decimal],
+          comparable: [:integer, :float, :decimal, :string],
+          boolean: [:boolean],
+          stringable: [:string],
+          orderable: [:integer, :float, :decimal, :string]
+        }.freeze
+
+        def self.expand(dtype_constraint)
+          return dtype_constraint unless dtype_constraint.is_a?(String)
+
+          category = dtype_constraint.to_sym
+          CATEGORIES[category] || dtype_constraint
+        end
+
+        def self.includes?(dtype_constraint, kind)
+          kinds = expand(dtype_constraint)
+          return kinds.include?(kind) if kinds.is_a?(Array)
+
+          # Fall back to string comparison for uncategorized constraints
+          kinds == kind.to_s
+        end
+
+        def self.category?(name)
+          CATEGORIES.key?(name.to_sym)
+        end
+
+        def self.categories
+          CATEGORIES
+        end
+      end
+    end
+  end
+end

data/lib/kumi/frontends/text.rb

@@ -13,20 +13,48 @@ module Kumi
         raise ArgumentError, "provide either :path or :src" if (path.nil? && src.nil?) || (path && src)
 
         src ||= File.read(path)
-        file_label = path || "(string)"
+        file_label = path || "schema"
 
         begin
           require "kumi-parser"
-          ast = Kumi::Parser::TextParser.parse(src)
+          ast = Kumi::Parser::TextParser.parse(src, source_file: path || "schema")
           Core::Analyzer::Debug.info(:parse, kind: :text, file: file_label, ok: true) if Core::Analyzer::Debug.enabled?
           [ast, inputs]
         rescue LoadError
           raise "kumi-parser gem not available. Install: gem install kumi-parser"
         rescue StandardError => e
-          loc = (e.respond_to?(:location) && e.location) || {}
-          line, col = loc.values_at(:line, :column)
+          # Try to extract line/column from exception object first
+          line, col = extract_line_column(e)
           snippet = code_frame(src, line, col)
-          raise StandardError, "#{file_label}:#{line || '?'}:#{col || '?'}: #{e.message}\n#{snippet}"
+
+          # Strip file:line:col prefix from e.message if it exists (from parser)
+          # Also strip embedded "at FILE line=N column=M" to avoid duplication
+          error_message = e.message
+            .sub(/^\S+:\d+:\d+:\s+/, '')
+            .gsub(/\s+at\s+\S+\s+line=\d+\s+column=\d+/, '')
+            .strip
+          raise StandardError, "#{file_label}:#{line || '?'}:#{col || '?'}: #{error_message}\n#{snippet}"
+        end
+      end
+
+      def self.extract_line_column(exception)
+        # Try to access Location object from exception
+        if exception.respond_to?(:location) && exception.location
+          loc = exception.location
+          if loc.respond_to?(:line) && loc.respond_to?(:column)
+            return [loc.line, loc.column]
+          end
+        end
+
+        # Fall back to parsing error message if no Location object
+        extract_line_column_from_message(exception.message)
+      end
+
+      def self.extract_line_column_from_message(message)
+        if message =~ /line=(\d+)\s+column=(\d+)/
+          [::Regexp.last_match(1).to_i, ::Regexp.last_match(2).to_i]
+        else
+          [nil, nil]
         end
       end
 

data/lib/kumi/syntax/location.rb

@@ -1,5 +1,9 @@
 module Kumi
   module Syntax
-    Location = Struct.new(:file, :line, :column, keyword_init: true)
+    class Location < Struct.new(:file, :line, :column, keyword_init: true)
+      def to_s
+        "#{file} line=#{line} column=#{column}"
+      end
+    end
   end
 end

data/lib/kumi/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.27
+  version: 0.0.28
 platform: ruby
 authors:
 - André Muta
@@ -701,6 +701,7 @@ files:
 - lib/kumi/core/functions/function_spec.rb
 - lib/kumi/core/functions/loader.rb
 - lib/kumi/core/functions/overload_resolver.rb
+- lib/kumi/core/functions/type_categories.rb
 - lib/kumi/core/functions/type_error_reporter.rb
 - lib/kumi/core/functions/type_rules.rb
 - lib/kumi/core/input/type_matcher.rb