kumi-parser 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e026bcf1261c346c2d2983cc968c16ad6dd715e988040d7d86df80de56011d1
-  data.tar.gz: bfd7ca7e038f89ac257ecee201e411064e0d850debfec504b65ecac0c6ac98a7
+  metadata.gz: 119563dd70c4e400274c70034d942036f1c07e8525d94dbb1a78fcd9f850be9b
+  data.tar.gz: 77e331ee47ac3428e2a13e58b461367d2a7d44756515e976cfc54a12a4749a90
 SHA512:
-  metadata.gz: 3ca24299aac80d72ea041cd6e642c8d26908254610cf44c09a82afc4f1306721669180f9352c9224ead49b0ef07ee0e82511d166a626b017cc1f99902c70b27b
-  data.tar.gz: eee3ba16a05ee53aec1e654dd6844205af21b51f12f59ba53fdd4c6c427caeac041fe6056cfe1e4469bd06c4a7d3e348206d4b17b2be80684d5acfd13da800f6
+  metadata.gz: d5a7802b011dc8e21c890e9fb3f0c981c856bd03a39c277479fc1e2736de08c345e72085407fb07c5d339b3cd948bfc81e40d19257572f6b415d16a14f68d466
+  data.tar.gz: a08624024f172abc6602e238c09c6250f23c082b7d7580e8289ad318aec7c41787d039ddf154cdbf8ec60929b4095e23d2585307612717117c8d6befc878cf94

data/lib/kumi/parser/direct_parser.rb

@@ -153,17 +153,64 @@ module Kumi
       end
 
       def parse_domain_specification
-        # For now, just skip the domain spec - we can implement this later
-        # This handles cases like: domain: 1..10, domain: %w[a b c], domain: ["x", "y"]
-        if current_token.type == :lbracket
-          parse_array_literal
+        # Parse domain specifications: domain: ["x", "y"], domain: [1, 2, 3], domain: 1..10, domain: 1...10
+        case current_token.type
+        when :lbracket
+          # Array domain: ["a", "b", "c"] or [1, 2, 3]
+          array_expr = parse_array_literal
+          # Convert ArrayExpression to Ruby Array for analyzer compatibility
+          convert_array_expression_to_ruby_array(array_expr)
+        when :integer, :float
+          # Range domain: 1..10 or 1...10
+          parse_range_domain
         else
-          # Skip until comma or newline
+          # Skip unknown domain specs for now
           advance until %i[comma newline eof end].include?(current_token.type)
           nil
         end
       end
 
+      def parse_range_domain
+        # Parse numeric ranges like 1..10 or 0.0...100.0
+        start_token = current_token
+        start_value = start_token.type == :integer ? start_token.value.to_i : start_token.value.to_f
+        advance
+        
+        case current_token.type
+        when :dot_dot
+          # Inclusive range: start..end
+          advance # consume ..
+          end_token = current_token
+          end_value = end_token.type == :integer ? end_token.value.to_i : end_token.value.to_f
+          advance
+          (start_value..end_value)
+        when :dot_dot_dot
+          # Exclusive range: start...end
+          advance # consume ...
+          end_token = current_token
+          end_value = end_token.type == :integer ? end_token.value.to_i : end_token.value.to_f
+          advance
+          (start_value...end_value)
+        else
+          # Just a single number, treat as single-element array
+          [start_value]
+        end
+      end
+
+      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
+          else
+            # For non-literal elements, we'd need more complex evaluation
+            # For now, just return the element as-is
+            element  
+          end
+        end
+      end
+
       # Value declaration: 'value :name, expression' or 'value :name do ... end'
       def parse_value_declaration
         value_token = expect_token(:value)
@@ -494,6 +541,13 @@ module Kumi
         case token_type
         when :eq then :==
         when :ne then :!=
+        when :gt then :>
+        when :lt then :<
+        when :gte then :>=
+        when :lte then :<=
+        when :and then :and
+        when :or then :or
+        when :exponent then :**
         else token_type
         end
       end

data/lib/kumi/parser/smart_tokenizer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'token_metadata'
+require_relative 'token'
+require_relative 'errors'
 
 module Kumi
   module Parser
@@ -243,6 +245,43 @@ module Kumi
             location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
             @tokens << Token.new(:lt, '<', location, Kumi::Parser::TOKEN_METADATA[:lt])
           end
+        when '*'
+          if peek_char == '*'
+            advance
+            advance
+            location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
+            @tokens << Token.new(:exponent, '**', location, Kumi::Parser::TOKEN_METADATA[:exponent])
+          else
+            # Single asterisk: fall through to single character handling
+            token_type = CHAR_TO_TOKEN[char]
+            metadata = Kumi::Parser::TOKEN_METADATA[token_type].dup
+            location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
+            @tokens << Token.new(token_type, char, location, metadata)
+            advance
+          end
+        when '.'
+          if peek_char == '.'
+            advance
+            if peek_char == '.'
+              # Three dots: ...
+              advance
+              advance
+              location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
+              @tokens << Token.new(:dot_dot_dot, '...', location, Kumi::Parser::TOKEN_METADATA[:dot_dot_dot])
+            else
+              # Two dots: ..
+              advance
+              location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
+              @tokens << Token.new(:dot_dot, '..', location, Kumi::Parser::TOKEN_METADATA[:dot_dot])
+            end
+          else
+            # Single dot: fall through to single character handling
+            token_type = CHAR_TO_TOKEN[char]
+            metadata = Kumi::Parser::TOKEN_METADATA[token_type].dup
+            location = Kumi::Syntax::Location.new(file: @source_file, line: @line, column: start_column)
+            @tokens << Token.new(token_type, char, location, metadata)
+            advance
+          end
         else
           # Single character operators/punctuation
           token_type = CHAR_TO_TOKEN[char]

data/lib/kumi/parser/text_parser.rb

@@ -2,6 +2,7 @@
 
 require_relative 'smart_tokenizer'
 require_relative 'direct_parser'
+require_relative 'errors'
 
 module Kumi
   module Parser

data/lib/kumi/parser/token_metadata.rb

@@ -36,6 +36,7 @@ module Kumi
       FN = :fn
 
       # Operators (by precedence)
+      EXPONENT = :exponent      # **
       MULTIPLY = :multiply       # *
       DIVIDE = :divide          # /
       MODULO = :modulo          # %
@@ -52,6 +53,8 @@ module Kumi
 
       # Punctuation
       DOT = :dot                # .
+      DOT_DOT = :dot_dot        # ..
+      DOT_DOT_DOT = :dot_dot_dot # ...
       COMMA = :comma            # ,
       COLON = :colon            # :
       LPAREN = :lparen          # (
@@ -149,6 +152,12 @@ module Kumi
       },
 
       # Operators with precedence and associativity
+      exponent: {
+        category: :operator,
+        precedence: 7,
+        associativity: :right,
+        arity: :binary
+      },
       multiply: {
         category: :operator,
         precedence: 6,
@@ -275,6 +284,12 @@ module Kumi
         category: :punctuation,
         indicates_member_access: true
       },
+      dot_dot: {
+        category: :range
+      },
+      dot_dot_dot: {
+        category: :range
+      },
       comma: {
         category: :punctuation,
         separates_items: true

data/lib/kumi/parser/version.rb

@@ -2,6 +2,6 @@
 
 module Kumi
   module Parser
-    VERSION = '0.0.5'
+    VERSION = '0.0.7'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi-parser
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Kumi Team