kumi-parser 0.0.28 → 0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc1abe5a6e23f15904189f2d1f8550a5c88b5441318ba95a2df9b6437daca570
-  data.tar.gz: 851f8dbdd42fcc3210214e48223466d7e3dbb19a8802227c184a5b7b442df48b
+  metadata.gz: 6662f28685ceb786c8ce4153325bf7bfa3456317b0cfa60d1a488bbc8889db8b
+  data.tar.gz: 67210cf3da7c670e7c5ad06027cd7c096cd7ea568f254ace4ebeec6996cd34ce
 SHA512:
-  metadata.gz: 433f85f8185b8d4b88982358ef3291c5b445e811b107cd9c0300414fd47066dd70f2b5970357d79406d02c1dc0ec72611f3282d4f39c23dbc820c127dbbbd6ba
-  data.tar.gz: df753a5c5b8bcf4fdcb50e03d6f4ebef3162af9f0ff4d445941aa39da3e2b5265cdc460942f099cbfc8c191451088098a55d19d47102cb9b629f4bcedafc6426
+  metadata.gz: 41672379669848d7e722eb58446e7aa95e2fbead517e7654bb2b48dba8be5448c17082184ecbb6554ed764506f4215daf6dea42b7d1024754c5f5497726cddef
+  data.tar.gz: 64627c6a31190147044795cc4a458e5c29b927090b3572775f59117e5ed79c6158cbce4178b2f3d1cd83c744baaa887941f844c92f8e10303293879a739625ba

data/lib/kumi/parser/direct_parser.rb

@@ -9,11 +9,24 @@ module Kumi
       def initialize(tokens)
         @tokens = tokens
         @pos = 0
+        @imported_names = Set.new
       end
 
       def parse
         skip_comments_and_newlines
+
+        # Parse root-level imports (before schema)
+        root_imports = parse_imports
+        @imported_names.merge(root_imports.flat_map(&:names))
+
         schema_node = parse_schema
+
+        # If we have root imports, add them to the schema
+        if root_imports.any?
+          # Merge root imports with schema imports
+          schema_node.imports.concat(root_imports)
+        end
+
         skip_comments_and_newlines
         expect_token(:eof)
         schema_node
@@ -49,6 +62,9 @@ module Kumi
         expect_token(:do)
 
         skip_comments_and_newlines
+        import_declarations = parse_imports
+        @imported_names.merge(import_declarations.flat_map(&:names))
+
         input_declarations = parse_input_block
 
         value_declarations = []
@@ -73,10 +89,76 @@ module Kumi
           input_declarations,
           value_declarations, # values
           trait_declarations,
+          import_declarations,
           loc: schema_token.location
         )
       end
 
+      # Parse import declarations: 'import' :symbol, from: Module
+      def parse_imports
+        imports = []
+        skip_comments_and_newlines
+
+        while current_token.type == :import
+          import_token = expect_token(:import)
+
+          names = []
+          names << expect_token(:symbol).value.to_sym
+
+          while current_token.type == :comma
+            expect_token(:comma)
+            skip_comments_and_newlines
+
+            # Check if this is the 'from:' keyword argument or another symbol to import
+            if current_token.type == :label && current_token.value == 'from'
+              # This is 'from:' - end of imports list
+              break
+            else
+              # Another symbol to import
+              names << expect_token(:symbol).value.to_sym
+            end
+          end
+
+          skip_comments_and_newlines
+
+          # Handle 'from:' keyword argument
+          if current_token.type == :label && current_token.value == 'from'
+            expect_token(:label) # consume 'from:'
+          else
+            raise_parse_error("Expected 'from:' keyword argument in import statement")
+          end
+
+          skip_comments_and_newlines
+
+          module_ref = parse_constant
+
+          imports << Kumi::Syntax::ImportDeclaration.new(
+            names,
+            module_ref,
+            loc: import_token.location
+          )
+
+          skip_comments_and_newlines
+        end
+
+        imports
+      end
+
+      # Parse a constant reference like Schemas::Tax
+      def parse_constant
+        const_parts = []
+        const_parts << expect_token(:constant).value
+
+        while current_token.type == :colon && peek_token.type == :colon
+          expect_token(:colon)
+          expect_token(:colon)
+          const_parts << expect_token(:constant).value
+        end
+
+        # Return the full constant path as a string that will be evaluated at runtime
+        const_parts.join('::')
+      end
+
       # Input block: 'input' 'do' ... 'end'
       def parse_input_block
         expect_token(:input)
@@ -341,6 +423,9 @@ module Kumi
             parse_input_reference
           elsif token.value == 'index' && peek_token.type == :lparen
             parse_index_intrinsic
+          elsif peek_token.type == :lparen
+            # This is a function call like tax(amount: input.amount)
+            parse_imported_function_call
           else
             advance
             Kumi::Syntax::DeclarationReference.new(token.value.to_sym, loc: token.location)
@@ -448,7 +533,51 @@ module Kumi
           args, opts = parse_args_and_opts_inside_parens
         end
         # expect_token(:rparen)
-        Kumi::Syntax::CallExpression.new(fn_name_token.value, args, opts, loc: fn_name_token.location)
+
+        # Check if this is an imported function call
+        if @imported_names.include?(fn_name_token.value) && args.empty? && opts.any?
+          # Convert to ImportCall - opts become the input mapping
+          Kumi::Syntax::ImportCall.new(fn_name_token.value, opts, loc: fn_name_token.location)
+        else
+          # Regular call expression
+          Kumi::Syntax::CallExpression.new(fn_name_token.value, args, opts, loc: fn_name_token.location)
+        end
+      end
+
+      def parse_imported_function_call
+        fn_name_token = current_token
+        fn_name = fn_name_token.value.to_sym
+        advance # consume identifier
+        expect_token(:lparen)
+
+        # Parse keyword arguments for imported function calls
+        # Imported functions only accept keyword arguments
+        opts = {}
+
+        unless current_token.type == :rparen
+          # Parse keyword arguments with full expression values
+          while current_token.type == :label
+            key = current_token.value.to_sym
+            advance
+
+            opts[key] = parse_expression
+
+            break unless current_token.type == :comma
+            advance
+            skip_comments_and_newlines
+          end
+        end
+
+        expect_token(:rparen)
+
+        # Check if this is an imported function call
+        if @imported_names.include?(fn_name) && opts.any?
+          # Convert to ImportCall - opts become the input mapping
+          Kumi::Syntax::ImportCall.new(fn_name, opts, loc: fn_name_token.location)
+        else
+          # Regular call expression (shouldn't happen for imported functions)
+          Kumi::Syntax::CallExpression.new(fn_name, [], opts, loc: fn_name_token.location)
+        end
       end
 
       def parse_array_literal

data/lib/kumi/parser/smart_tokenizer.rb

@@ -163,7 +163,18 @@ module Kumi
         identifier_or_label_name = consume_while { |c| c.match?(/[a-zA-Z0-9_]/) }
         location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
 
-        # Check if the next character is a colon
+        # Check if it's a constant FIRST (e.g., Float::INFINITY or GoldenSchemas::Tax)
+        # This needs to be checked before label detection because labels also start with `:``
+        if current_char == ':' && peek_char == ':'
+          advance # consume first :
+          advance # consume second :
+          constant_name = consume_while { |c| c.match?(/[a-zA-Z0-9_]/) }
+          full_constant = "#{identifier_or_label_name}::#{constant_name}"
+          add_token(:constant, full_constant, Kumi::Parser::TOKEN_METADATA[:constant])
+          return
+        end
+
+        # Check if the next character is a single colon (label)
         if current_char == ':'
           # It's a hash key or a label (e.g., `name:`)
           advance # consume the colon
@@ -174,16 +185,6 @@ module Kumi
         # If it's not a label, proceed to check for keywords and identifiers
         # The logic below is adapted from your original `consume_identifier_or_keyword` method
 
-        # Check if it's a constant (e.g., Float::INFINITY)
-        if identifier_or_label_name == 'Float' && current_char == ':' && peek_char == ':'
-          advance # consume first :
-          advance # consume second :
-          constant_name = consume_while { |c| c.match?(/[a-zA-Z0-9_]/) }
-          full_constant = "#{identifier_or_label_name}::#{constant_name}"
-          add_token(:constant, full_constant, Kumi::Parser::TOKEN_METADATA[:constant])
-          return
-        end
-
         # Check if it's a keyword
         if keyword_type = Kumi::Parser::KEYWORDS[identifier_or_label_name]
           metadata = Kumi::Parser::TOKEN_METADATA[keyword_type].dup

data/lib/kumi/parser/token_constants.rb

@@ -20,6 +20,8 @@ module Kumi
       INPUT = :input
       VALUE = :value
       TRAIT = :trait
+      IMPORT = :import
+      FROM = :from
       DO = :do
       END_KW = :end
       ON = :on
@@ -100,6 +102,14 @@ module Kumi
         expects_expression: true,
         declaration_type: :trait
       },
+      import: {
+        category: :keyword,
+        import_declaration: true
+      },
+      from: {
+        category: :keyword,
+        import_source: true
+      },
       do: {
         category: :keyword,
         block_opener: true
@@ -421,6 +431,8 @@ module Kumi
       'value' => :value,
       'let' => :let,
       'trait' => :trait,
+      'import' => :import,
+      'from' => :from,
       'do' => :do,
       'end' => :end,
       'on' => :on,

data/lib/kumi/parser/version.rb

@@ -2,6 +2,6 @@
 
 module Kumi
   module Parser
-    VERSION = '0.0.28'
+    VERSION = '0.0.29'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumi-parser
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.0.29
 platform: ruby
 authors:
 - Kumi Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-10-20 00:00:00.000000000 Z
+date: 2025-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet