dentaku 3.5.3 → 3.5.5

data/lib/dentaku/dependency_resolver.rb

@@ -4,13 +4,18 @@ module Dentaku
   class DependencyResolver
     include TSort
 
-    def self.find_resolve_order(vars_to_dependencies_hash)
-      self.new(vars_to_dependencies_hash).tsort
+    def self.find_resolve_order(vars_to_dependencies_hash, case_sensitive = false)
+      self.new(vars_to_dependencies_hash).sort
     end
 
     def initialize(vars_to_dependencies_hash)
-      # ensure variables are strings
-      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.to_s, v] }]
+      @key_mapping = Hash[vars_to_dependencies_hash.keys.map { |k| [k.downcase, k] }]
+      # ensure variables are normalized strings
+      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.downcase.to_s, v] }]
+    end
+
+    def sort
+      tsort.map { |k| @key_mapping.fetch(k, k) }
     end
 
     def tsort_each_node(&block)

data/lib/dentaku/parser.rb

@@ -43,8 +43,6 @@ module Dentaku
       operator = operations.pop
       fail! :invalid_statement if operator.nil?
 
-      operator.peek(output)
-
       output_size = output.length
       args_size = operator.arity || count
       min_size = operator.arity || operator.min_param_count || count
@@ -55,17 +53,18 @@ module Dentaku
         fail! :too_few_operands, operator: operator, expect: expect, actual: output_size
       end
 
-      if output_size > max_size && operations.empty? || args_size > max_size
+      if (output_size > max_size && operations.empty?) || args_size > max_size
         expect = min_size == max_size ? min_size : min_size..max_size
         fail! :too_many_operands, operator: operator, expect: expect, actual: output_size
       end
 
+      args = []
       if operator == AST::Array && output.empty?
-        output.push(operator.new())
+        # special case: empty array literal '{}'
+        output.push(operator.new)
       else
         fail! :invalid_statement if output_size < args_size
         args = Array.new(args_size) { output.pop }.reverse
-
         output.push operator.new(*args)
       end
 
@@ -81,250 +80,244 @@ module Dentaku
     def parse
       return AST::Nil.new if input.empty?
 
-      while token = input.shift
-        case token.category
-        when :datetime
-          output.push AST::DateTime.new(token)
+      i = 0
+      while i < input.length
+        token = input[i]
+        lookahead = input[i + 1]
+        process_token(token, lookahead, i, input)
+        i += 1
+      end
 
-        when :numeric
-          output.push AST::Numeric.new(token)
+      while operations.any?
+        consume
+      end
 
-        when :logical
-          output.push AST::Logical.new(token)
+      unless output.count == 1
+        fail! :invalid_statement
+      end
 
-        when :string
-          output.push AST::String.new(token)
+      output.first
+    end
 
-        when :identifier
-          output.push AST::Identifier.new(token, case_sensitive: case_sensitive)
+    def operation(token)
+      AST_OPERATIONS.fetch(token.value)
+    end
 
-        when :operator, :comparator, :combinator
-          op_class = operation(token)
+    def function(token)
+      function_registry.get(token.value)
+    end
 
-          if op_class.right_associative?
-            while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
-              consume
-            end
+    def function_registry
+      @function_registry ||= Dentaku::AST::FunctionRegistry.new
+    end
 
-            operations.push op_class
-          else
-            while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
-              consume
-            end
+    private
 
-            operations.push op_class
-          end
+    def process_token(token, lookahead, index, tokens)
+      case token.category
+      when :datetime      then output << AST::DateTime.new(token)
+      when :numeric       then output << AST::Numeric.new(token)
+      when :logical       then output << AST::Logical.new(token)
+      when :string        then output << AST::String.new(token)
+      when :identifier    then output << AST::Identifier.new(token, case_sensitive: case_sensitive)
+      when :operator, :comparator, :combinator
+        handle_operator(token, lookahead)
+      when :null
+        output << AST::Nil.new
+      when :function
+        handle_function(token)
+      when :case
+        handle_case(token, index, tokens)
+      when :access
+        handle_access(token)
+      when :array
+        handle_array(token)
+      when :grouping
+        handle_grouping(token, lookahead, tokens)
+      else
+        fail! :not_implemented_token_category, token_category: token.category
+      end
+    end
 
-        when :null
-          output.push AST::Nil.new
+    def handle_operator(token, lookahead)
+      op_class = operation(token).resolve_class(lookahead)
+      if op_class.right_associative?
+        while operations.last && operations.last < AST::Operation && op_class.precedence < operations.last.precedence
+          consume
+        end
+      else
+        while operations.last && operations.last < AST::Operation && op_class.precedence <= operations.last.precedence
+          consume
+        end
+      end
+      operations.push op_class
+    end
 
-        when :function
-          func = function(token)
-          if func.nil?
-            fail! :undefined_function, function_name: token.value
-          end
+    def handle_function(token)
+      func = function(token)
+      fail! :undefined_function, function_name: token.value if func.nil?
+      arities.push 0
+      operations.push func
+    end
 
-          arities.push 0
-          operations.push func
-
-        when :case
-          case_index = operations.index { |o| o == AST::Case } || -1
-          token_index = case_index + 1
-
-          case token.value
-          when :open
-            # special handling for case nesting: strip out inner case
-            # statements and parse their AST segments recursively
-            if operations.include?(AST::Case)
-              open_cases = 0
-              case_end_index = nil
-
-              input.each_with_index do |input_token, index|
-                if input_token.category == :case
-                  if input_token.value == :open
-                    open_cases += 1
-                  end
-
-                  if input_token.value == :close
-                    if open_cases > 0
-                      open_cases -= 1
-                    else
-                      case_end_index = index
-                      break
-                    end
-                  end
+    def handle_case(token, index, tokens)
+      case_index = operations.index { |o| o == AST::Case } || -1
+      token_index = case_index + 1
+
+      case token.value
+      when :open
+        if operations.include?(AST::Case)
+          # nested case extraction (non-recursive outer parser)
+          open_cases = 0
+          case_end_index = nil
+          j = index + 1
+          while j < tokens.length
+            t = tokens[j]
+            if t.category == :case
+              if t.value == :open
+                open_cases += 1
+              elsif t.value == :close
+                if open_cases > 0
+                  open_cases -= 1
+                else
+                  case_end_index = j
+                  break
                 end
               end
-              inner_case_inputs = input.slice!(0..case_end_index)
-              subparser = Parser.new(
-                inner_case_inputs,
-                operations: [AST::Case],
-                arities: [0],
-                function_registry: @function_registry,
-                case_sensitive: case_sensitive
-              )
-              subparser.parse
-              output.concat(subparser.output)
-            else
-              operations.push AST::Case
-              arities.push(0)
-            end
-          when :close
-            if operations[token_index] == AST::CaseThen
-              while operations.last != AST::Case
-                consume
-              end
-
-              operations.push(AST::CaseConditional)
-              consume(2)
-              arities[-1] += 1
-            elsif operations[token_index] == AST::CaseElse
-              while operations.last != AST::Case
-                consume
-              end
-
-              arities[-1] += 1
-            end
-
-            unless operations.count >= 1 && operations.last == AST::Case
-              fail! :unprocessed_token, token_name: token.value
             end
-            consume(arities.pop.succ)
-          when :when
-            if operations[token_index] == AST::CaseThen
-              while ![AST::CaseWhen, AST::Case].include?(operations.last)
-                consume
-              end
-              operations.push(AST::CaseConditional)
-              consume(2)
-              arities[-1] += 1
-            elsif operations.last == AST::Case
-              operations.push(AST::CaseSwitchVariable)
-              consume
-            end
-
-            operations.push(AST::CaseWhen)
-          when :then
-            if operations[token_index] == AST::CaseWhen
-              while ![AST::CaseThen, AST::Case].include?(operations.last)
-                consume
-              end
-            end
-            operations.push(AST::CaseThen)
-          when :else
-            if operations[token_index] == AST::CaseThen
-              while operations.last != AST::Case
-                consume
-              end
-
-              operations.push(AST::CaseConditional)
-              consume(2)
-              arities[-1] += 1
-            end
-
-            operations.push(AST::CaseElse)
-          else
-            fail! :unknown_case_token, token_name: token.value
+            j += 1
           end
+          inner_case_inputs = tokens.slice!(index + 1, case_end_index - index) || []
+          subparser = Parser.new(
+            inner_case_inputs,
+            operations: [AST::Case],
+            arities: [0],
+            function_registry: @function_registry,
+            case_sensitive: case_sensitive
+          )
+          subparser.parse
+          output.concat(subparser.output)
+        else
+          operations.push AST::Case
+          arities.push(0)
+        end
 
-        when :access
-          case token.value
-          when :lbracket
-            operations.push AST::Access
-          when :rbracket
-            while operations.any? && operations.last != AST::Access
-              consume
-            end
-
-            unless operations.last == AST::Access
-              fail! :unbalanced_bracket, token: token
-            end
+      when :close
+        if operations[token_index] == AST::CaseThen
+          while operations.last != AST::Case
             consume
           end
-
-        when :array
-          case token.value
-          when :array_start
-            operations.push AST::Array
-            arities.push 0
-          when :array_end
-            while operations.any? && operations.last != AST::Array
-              consume
-            end
-
-            unless operations.last == AST::Array
-              fail! :unbalanced_bracket, token: token
-            end
-
-            consume(arities.pop.succ)
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        elsif operations[token_index] == AST::CaseElse
+          while operations.last != AST::Case
+            consume
           end
+          arities[-1] += 1
+        end
+        fail! :unprocessed_token, token_name: token.value unless operations.count >= 1 && operations.last == AST::Case
+        consume(arities.pop.succ)
 
-        when :grouping
-          case token.value
-          when :open
-            if input.first && input.first.value == :close
-              input.shift
-              arities.pop
-              consume(0)
-            else
-              operations.push AST::Grouping
-            end
-
-          when :close
-            while operations.any? && operations.last != AST::Grouping
-              consume
-            end
-
-            lparen = operations.pop
-            unless lparen == AST::Grouping
-              fail! :unbalanced_parenthesis, token
-            end
-
-            if operations.last && operations.last < AST::Function
-              consume(arities.pop.succ)
-            end
-
-          when :comma
-            fail! :invalid_statement if arities.empty?
-            arities[-1] += 1
-            while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
-              consume
-            end
+      when :when
+        if operations[token_index] == AST::CaseThen
+          while ![AST::CaseWhen, AST::Case].include?(operations.last)
+            consume
+          end
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
+        elsif operations.last == AST::Case
+          operations.push(AST::CaseSwitchVariable)
+          consume
+        end
+        operations.push(AST::CaseWhen)
 
-          else
-            fail! :unknown_grouping_token, token_name: token.value
+      when :then
+        if operations[token_index] == AST::CaseWhen
+          while ![AST::CaseThen, AST::Case].include?(operations.last)
+            consume
           end
+        end
+        operations.push(AST::CaseThen)
 
-        else
-          fail! :not_implemented_token_category, token_category: token.category
+      when :else
+        if operations[token_index] == AST::CaseThen
+          while operations.last != AST::Case
+            consume
+          end
+          operations.push(AST::CaseConditional)
+          consume(2)
+          arities[-1] += 1
         end
+        operations.push(AST::CaseElse)
+      else
+        fail! :unknown_case_token, token_name: token.value
       end
+    end
 
-      while operations.any?
+    def handle_access(token)
+      case token.value
+      when :lbracket
+        operations.push AST::Access
+
+      when :rbracket
+        while operations.any? && operations.last != AST::Access
+          consume
+        end
+        fail! :unbalanced_bracket, token: token unless operations.last == AST::Access
         consume
       end
+    end
 
-      unless output.count == 1
-        fail! :invalid_statement
-      end
+    def handle_array(token)
+      case token.value
+      when :array_start
+        operations.push AST::Array
+        arities.push 0
 
-      output.first
+      when :array_end
+        while operations.any? && operations.last != AST::Array
+          consume
+        end
+        fail! :unbalanced_bracket, token: token unless operations.last == AST::Array
+        consume(arities.pop.succ)
+      end
     end
 
-    def operation(token)
-      AST_OPERATIONS.fetch(token.value)
-    end
+    def handle_grouping(token, lookahead, tokens)
+      case token.value
+      when :open
+        if lookahead && lookahead.value == :close
+          # empty grouping (e.g. function with zero arguments) — we trigger consume later
+          tokens.delete_at(tokens.index(lookahead)) # remove the close to mimic previous shift behavior
+          arities.pop
+          consume(0)
+        else
+          operations.push AST::Grouping
+        end
 
-    def function(token)
-      function_registry.get(token.value)
-    end
+      when :close
+        while operations.any? && operations.last != AST::Grouping
+          consume
+        end
+        lparen = operations.pop
+        fail! :unbalanced_parenthesis, token unless lparen == AST::Grouping
+        if operations.last && operations.last < AST::Function
+          consume(arities.pop.succ)
+        end
 
-    def function_registry
-      @function_registry ||= Dentaku::AST::FunctionRegistry.new
+      when :comma
+        fail! :invalid_statement if arities.empty?
+        arities[-1] += 1
+        while operations.any? && operations.last != AST::Grouping && operations.last != AST::Array
+          consume
+        end
+      else
+        fail! :unknown_grouping_token, token_name: token.value
+      end
     end
 
-    private
-
     def fail!(reason, **meta)
       message =
         case reason

data/lib/dentaku/print_visitor.rb

@@ -7,13 +7,13 @@ module Dentaku
 
     def visit_operation(node)
       if node.left
-        visit_operand(node.left, node.class.precedence, suffix: " ", dir: :left)
+        visit_operand(node.left, node.class.precedence, suffix: node.operator_spacing, dir: :left)
       end
 
       @output << node.display_operator
 
       if node.right
-        visit_operand(node.right, node.class.precedence, prefix: " ", dir: :right)
+        visit_operand(node.right, node.class.precedence, prefix: node.operator_spacing, dir: :right)
       end
     end
 

data/lib/dentaku/token.rb

@@ -20,10 +20,22 @@ module Dentaku
       length.zero?
     end
 
+    def operator?
+      is?(:operator)
+    end
+
     def grouping?
       is?(:grouping)
     end
 
+    def open?
+      grouping? && value == :open
+    end
+
+    def close?
+      grouping? && value == :close
+    end
+
     def is?(c)
       category == c
     end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.3"
+  VERSION = "3.5.5"
 end

data/lib/dentaku/visitor/infix.rb

@@ -83,4 +83,4 @@ module Dentaku
       end
     end
   end
-end
+end

data/spec/ast/addition_spec.rb

@@ -20,22 +20,21 @@ describe Dentaku::AST::Addition do
     expect(node.value).to eq(11)
   end
 
-  it 'requires numeric operands' do
+  it 'requires operands that respond to +' do
     expect {
-      described_class.new(five, t)
-    }.to raise_error(Dentaku::NodeError, /requires numeric operands/)
+      described_class.new(five, t).value
+    }.to raise_error(Dentaku::ArgumentError, /requires operands that respond to +/)
 
     expression = Dentaku::AST::Multiplication.new(five, five)
     group = Dentaku::AST::Grouping.new(expression)
 
     expect {
-      described_class.new(group, five)
+      described_class.new(group, five).value
     }.not_to raise_error
   end
 
   it 'allows operands that respond to addition' do
     # Sample struct that has a custom definition for addition
-
     Addable = Struct.new(:value) do
       def +(other)
         case other
@@ -51,12 +50,18 @@ describe Dentaku::AST::Addition do
     operand_six = Dentaku::AST::Numeric.new Dentaku::Token.new(:numeric, Addable.new(6))
 
     expect {
-      described_class.new(operand_five, operand_six)
+      described_class.new(operand_five, operand_six).value
     }.not_to raise_error
 
     expect {
-      described_class.new(operand_five, six)
+      described_class.new(operand_five, six).value
     }.not_to raise_error
+  end
+
+  it 'does not try to parse nested string as date' do
+    a = ['2017-01-01', '2017-01-02']
+    b = ['2017-01-01']
 
+    expect(Dentaku('a + b', a: a, b: b)).to eq(['2017-01-01', '2017-01-02', '2017-01-01'])
   end
 end

data/spec/ast/all_spec.rb

@@ -4,6 +4,7 @@ require 'dentaku'
 
 describe Dentaku::AST::All do
   let(:calculator) { Dentaku::Calculator.new }
+
   it 'performs ALL operation' do
     result = Dentaku('ALL(vals, val, val > 1)', vals: [1, 2, 3])
     expect(result).to eq(false)
@@ -22,4 +23,16 @@ describe Dentaku::AST::All do
       Dentaku::ParseError, 'ALL() requires second argument to be an identifier'
     )
   end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('ALL(items, item, item.value)', items: [{value: 1}, {}])
+    ).to be_falsy
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('ALL(items, item, item.value)', items: [{value: 1}, {}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
 end

data/spec/ast/any_spec.rb

@@ -4,6 +4,7 @@ require 'dentaku'
 
 describe Dentaku::AST::Any do
   let(:calculator) { Dentaku::Calculator.new }
+
   it 'performs ANY operation' do
     result = Dentaku('ANY(vals, val, val > 1)', vals: [1, 2, 3])
     expect(result).to eq(true)
@@ -20,4 +21,16 @@ describe Dentaku::AST::Any do
   it 'raises argument error if a string is passed as identifier' do
     expect { calculator.evaluate!('ANY({1, 2, 3}, "val", val % 2 == 0)') }.to raise_error(Dentaku::ParseError)
   end
+
+  it 'treats missing keys in hashes as NULL in permissive mode' do
+    expect(
+      calculator.evaluate('ANY(items, item, item.value)', items: [{value: 1}, {}])
+    ).to be_truthy
+  end
+
+  it 'raises an error if accessing a missing key in a hash in strict mode' do
+    expect {
+      calculator.evaluate!('ANY(items, item, item.value)', items: [{}, {value: 1}])
+    }.to raise_error(Dentaku::UnboundVariableError)
+  end
 end

data/spec/ast/arithmetic_spec.rb

@@ -111,6 +111,13 @@ describe Dentaku::AST::Arithmetic do
     end
   end
 
+  it 'does not try to parse nested string as date' do
+    a = ['2017-01-01', '2017-01-02']
+    b = ['2017-01-01']
+
+    expect(Dentaku('a - b', a: a, b: b)).to eq(['2017-01-02'])
+  end
+
   it 'raises ArgumentError if given individually valid but incompatible arguments' do
     expect { add(one, date) }.to raise_error(Dentaku::ArgumentError)
     expect { add(x, one, 'x' => [1]) }.to raise_error(Dentaku::ArgumentError)