kumi-parser 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83ae18a38c78f9513121f579f024309c162ebbc1fdf909aecbe8aceff04e100a
-  data.tar.gz: 8bfab6fb7250f7e39289ceb07b84ae556958a77be19b66fe253b19c7284359ba
+  metadata.gz: b7c82cf28e39c53592ff6acb03772bc9d346716cb1dee414f4d1bce450629b9e
+  data.tar.gz: e9464f66ff1aae2b9d38770bdf1c9fe9d96eef114838eaec532a4408f87b8435
 SHA512:
-  metadata.gz: 39f5759930377f813b10d8ce148dc5f26bd9a6b4a21a577b91bbb24fe7d47d923cf3967f25454666bb9c8c23f0190909f6283fe629a7bd935d51ca9033c25047
-  data.tar.gz: d06bd58249f51ef7edafb51f291c2b18720ea259b3a375b9624ac593631f7786aa2c920da92bea99ec1ad27fc517c71c9b7bbd41e7626faa814949e317b56f29
+  metadata.gz: a4902e5502a0298fd6f9f24a9f80701910f641fa8098917d40cf0daa84f0845861c1f97aebd940bd704d213d1bce91fc1ad6971796bef76bfb2f5382aee60840
+  data.tar.gz: 512f5f4b80d7be91c543e1ae4f85c95835f9b52e2eb5768b4b55d4f69f27e17e640392851f3e2ee1b40003254d6160e533559f24a8e7546951b4d507c5d55950

data/README.md

@@ -57,7 +57,7 @@ end
 ```
 
 **Function calls**: `fn(:name, arg1, arg2, ...)`  
-**Operators**: `+` `-` `*` `/` `%` `>` `<` `>=` `<=` `==` `!=` `&` `|`  
+**Operators**: `+` `-` `*` `**` `` `/` `%` `>` `<` `>=` `<=` `==` `!=` `&` `|`  
 **References**: `input.field`, `value_name`, `array[index]`  
 **Strings**: Both `"double"` and `'single'` quotes supported  
 **Element syntax**: `element :type, :name` for array element specifications

data/lib/kumi/parser/direct_parser.rb

@@ -25,6 +25,7 @@ module Kumi
       def peek_token(offset = 1)
         peek_pos = @pos + offset
         return @tokens.last if peek_pos >= @tokens.length # Return EOF
+
         @tokens[peek_pos]
       end
 
@@ -89,6 +90,7 @@ module Kumi
 
         until %i[end eof].include?(current_token.type)
           break unless current_token.metadata[:category] == :type_keyword
+
           declarations << parse_input_declaration
           skip_comments_and_newlines
         end
@@ -232,6 +234,7 @@ module Kumi
 
       def convert_array_expression_to_ruby_array(array_expr)
         return nil unless array_expr.is_a?(Kumi::Syntax::ArrayExpression)
+
         array_expr.elements.map do |element|
           if element.is_a?(Kumi::Syntax::Literal)
             element.value
@@ -365,14 +368,15 @@ module Kumi
           value = convert_literal_value(token)
           advance
           Kumi::Syntax::Literal.new(value, loc: token.location)
+        when :function_sugar
+          parse_function_sugar
 
         when :identifier
+
           if token.value == 'input' && peek_token.type == :dot
             parse_input_reference
           elsif peek_token.type == :lbracket
             parse_array_access_reference
-          elsif token.value == 'fn'
-            parse_function_call
           else
             advance
             Kumi::Syntax::DeclarationReference.new(token.value.to_sym, loc: token.location)
@@ -394,8 +398,12 @@ module Kumi
         when :lbracket
           parse_array_literal
 
+        when :left_brace
+          parse_hash_literal
+
         when :fn
-          parse_function_call_from_fn_token
+          # expect_token(:fn)
+          parse_function_call
 
         when :subtract
           advance
@@ -460,26 +468,15 @@ module Kumi
         Kumi::Syntax::CallExpression.new(:at, [base_ref, index_expr], loc: name_token.location)
       end
 
-      def parse_function_call
-        fn_token = expect_token(:identifier)
-        if current_token.type == :lparen
-          advance
-          fn_name_token = expect_token(:symbol)
-          fn_name = fn_name_token.value
-          args = []
-          while current_token.type == :comma
-            advance
-            args << parse_expression
-          end
-          expect_token(:rparen)
-          Kumi::Syntax::CallExpression.new(fn_name, args, loc: fn_name_token.location)
-        else
-          raise_parse_error("Expected '(' after 'fn'")
-        end
+      def parse_function_sugar
+        sugar_token = current_token
+        advance
+        args = parse_argument_list
+        Kumi::Syntax::CallExpression.new(sugar_token.value.to_sym, args, loc: sugar_token.location)
       end
 
-      def parse_function_call_from_fn_token
-        fn_token = expect_token(:fn)
+      def parse_function_call
+        advance
         if current_token.type == :lparen
           advance
           fn_name_token = expect_token(:symbol)
@@ -498,6 +495,8 @@ module Kumi
 
       def parse_argument_list
         args = []
+
+        expect_token(:lparen)
         unless current_token.type == :rparen
           args << parse_expression
           while current_token.type == :comma
@@ -505,6 +504,8 @@ module Kumi
             args << parse_expression
           end
         end
+        expect_token(:rparen)
+
         args
       end
 
@@ -522,6 +523,57 @@ module Kumi
         Kumi::Syntax::ArrayExpression.new(elements, loc: start_token.location)
       end
 
+      def parse_hash_literal
+        start_token = expect_token(:left_brace)
+        skip_comments_and_newlines
+        pairs = []
+
+        # Handle empty hash: {}
+        unless current_token.type == :right_brace
+          pairs << parse_hash_pair
+          skip_comments_and_newlines
+
+          while current_token.type == :comma
+            advance
+            skip_comments_and_newlines
+            # Allow trailing comma
+            break if current_token.type == :right_brace
+
+            pairs << parse_hash_pair
+            skip_comments_and_newlines
+          end
+        end
+
+        expect_token(:right_brace)
+        Kumi::Syntax::HashExpression.new(pairs, loc: start_token.location)
+      end
+
+      def parse_hash_pair
+        key_token_type = current_token.type
+        key = case key_token_type
+              when :label, :string
+                value = current_token.value.to_sym if key_token_type == :label
+                advance
+                Kumi::Syntax::Literal.new(value, loc: current_token.location)
+              else
+                raise_parse_error("Hash keys must be symbols (:key) or strings (\"key\"), got #{current_token.type}")
+              end
+
+        skip_comments_and_newlines
+
+        case current_token.type
+        when :arrow
+          advance
+        else
+          raise_parse_error("Expected '=>' in hash pair") unless key_token_type == :label
+        end
+
+        skip_comments_and_newlines
+        value = parse_expression
+
+        [key, value]
+      end
+
       def convert_literal_value(token)
         case token.type
         when :integer  then token.value.gsub('_', '').to_i

data/lib/kumi/parser/smart_tokenizer.rb

@@ -34,7 +34,7 @@ module Kumi
             else
               consume_operator_or_punctuation
             end
-          when /[a-zA-Z_]/ then consume_identifier_or_keyword
+          when /[a-zA-Z_]/ then consume_identifier_or_label_or_keyword
           when ':' then consume_symbol_or_colon
           else
             consume_operator_or_punctuation
@@ -158,24 +158,34 @@ module Kumi
         @tokens << Token.new(token_type, number_str, location, Kumi::Parser::TOKEN_METADATA[token_type])
       end
 
-      def consume_identifier_or_keyword
+      def consume_identifier_or_label_or_keyword
         start_column = @column
-        identifier = consume_while { |c| c.match?(/[a-zA-Z0-9_]/) }
+        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
+        if current_char == ':'
+          # It's a hash key or a label (e.g., `name:`)
+          advance # consume the colon
+          add_token(:label, identifier_or_label_name, Kumi::Parser::TOKEN_METADATA[:label])
+          return
+        end
+
+        # 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 == 'Float' && current_char == ':' && peek_char == ':'
+        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}::#{constant_name}"
-          
-          location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
-          @tokens << Token.new(:constant, full_constant, location, Kumi::Parser::TOKEN_METADATA[:constant])
+          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]
+        if keyword_type = Kumi::Parser::KEYWORDS[identifier_or_label_name]
           metadata = Kumi::Parser::TOKEN_METADATA[keyword_type].dup
 
           # Update context based on keyword
@@ -187,24 +197,26 @@ module Kumi
             closed_context = @context_stack.pop if @context_stack.length > 1
             metadata[:closes_context] = closed_context
           end
+          add_token(keyword_type, identifier_or_label_name, metadata)
+          return
+        end
 
-          location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
-          @tokens << Token.new(keyword_type, identifier, location, metadata)
-        else
-          # It's an identifier - determine its role based on context
-          metadata = Kumi::Parser::TOKEN_METADATA[:identifier].dup
-
-          # Add context-specific metadata
-          case current_context
-          when :input
-            metadata[:context] = :input_declaration
-          when :schema
-            metadata[:context] = :schema_body
-          end
+        # Check if its a function sugar
+        if Kumi::Parser::FUNCTION_SUGAR[identifier_or_label_name]
+          metadata = Kumi::Parser::TOKEN_METADATA[:function_sugar].dup
+          add_token(:function_sugar, identifier_or_label_name, metadata)
+          return
+        end
 
-          location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
-          @tokens << Token.new(:identifier, identifier, location, metadata)
+        # Otherwise is an Identifier
+        metadata = Kumi::Parser::TOKEN_METADATA[:identifier].dup
+        case current_context
+        when :input
+          metadata[:context] = :input_declaration
+        when :schema
+          metadata[:context] = :schema_body
         end
+        add_token(:identifier, identifier_or_label_name, metadata)
       end
 
       def consume_symbol_or_colon
@@ -232,7 +244,12 @@ module Kumi
         # Handle multi-character operators
         case char
         when '='
-          if peek_char == '='
+          if peek_char == '>'
+            advance
+            advance
+            location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
+            @tokens << Token.new(:arrow, '=>', location, Kumi::Parser::TOKEN_METADATA[:arrow])
+          elsif peek_char == '='
             advance
             advance
             location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)

data/lib/kumi/parser/token.rb

@@ -81,4 +81,4 @@ module Kumi
       end
     end
   end
-end
+end

data/lib/kumi/parser/token_metadata.rb

@@ -38,8 +38,8 @@ module Kumi
       FN = :fn
 
       # Operators (by precedence)
-      EXPONENT = :exponent      # **
-      MULTIPLY = :multiply       # *
+      EXPONENT = :exponent # **
+      MULTIPLY = :multiply # *
       DIVIDE = :divide          # /
       MODULO = :modulo          # %
       ADD = :add                # +
@@ -67,7 +67,7 @@ module Kumi
       # Special
       NEWLINE = :newline
       EOF = :eof
-      COMMENT = :comment        # # comment
+      COMMENT = :comment # # comment
     end
 
     # Rich metadata for each token type
@@ -163,6 +163,11 @@ module Kumi
         starts_expression: true
       },
 
+      function_sugar: {
+        function_keyword: true,
+        starts_expression: true
+      },
+
       # Operators with precedence and associativity
       exponent: {
         category: :operator,
@@ -256,7 +261,6 @@ module Kumi
         arity: :binary,
         requires_boolean: true
       },
-
       # Literals with type information
       integer: {
         category: :literal,
@@ -278,7 +282,6 @@ module Kumi
         starts_expression: true,
         ast_class: 'Kumi::Syntax::Literal'
       },
-
       # Identifiers and references
       identifier: {
         category: :identifier,
@@ -339,6 +342,15 @@ module Kumi
         terminates_expression: true
       },
 
+      left_brace: {
+        category: :punctuation,
+        opens_scope: :hash
+      },
+      right_brace: {
+        category: :punctuation,
+        closes_scope: :hash
+      },
+
       # Special tokens
       newline: {
         category: :whitespace,
@@ -360,6 +372,8 @@ module Kumi
       ')' => :rparen,
       '[' => :lbracket,
       ']' => :rbracket,
+      '{' => :left_brace,
+      '}' => :right_brace,
       ',' => :comma,
       '.' => :dot,
       ':' => :colon,
@@ -369,9 +383,14 @@ module Kumi
       '/' => :divide,
       '%' => :modulo,
       '&' => :and,
-      '|' => :or
+      '|' => :or,
+      '=>' => :arrow
     }.freeze
 
+    FUNCTION_SUGAR = {
+      'select' => '__select__'
+    }
+
     # Keywords mapping
     KEYWORDS = {
       'schema' => :schema,
@@ -401,4 +420,4 @@ module Kumi
       rbracket: :lbracket
     }.freeze
   end
-end
+end

data/lib/kumi/parser/version.rb

@@ -2,6 +2,6 @@
 
 module Kumi
   module Parser
-    VERSION = '0.0.14'
+    VERSION = '0.0.16'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kumi-parser
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - Kumi Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-08-30 00:00:00.000000000 Z
+date: 2025-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kumi