dentaku 3.5.8 → 4.0.0

data/lib/dentaku/parser.rb

@@ -41,41 +41,42 @@ module Dentaku
     end
 
     def consume(count = 2)
-      operator = operations.pop
-      fail! :invalid_statement if operator.nil?
+      operation = operations.pop
+      fail! :invalid_statement if operation.nil?
 
       output_size = output.length
-      args_size = operator.arity || count
-      min_size = operator.arity || operator.min_param_count || count
-      max_size = operator.arity || operator.max_param_count || count
+      args_size = operation.arity || count
+      min_size = operation.arity || operation.min_param_count || count
+      max_size = operation.arity || operation.max_param_count || count
 
       if output_size < min_size || args_size < min_size
-        expect = min_size == max_size ? min_size : min_size..max_size
-        fail! :too_few_operands, operator: operator, expect: expect, actual: output_size
+        expected = min_size == max_size ? min_size : min_size..max_size
+        fail! :too_few_operands, operation: operation, expected: expected, actual: output_size
       end
 
       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
+        expected = min_size == max_size ? min_size : min_size..max_size
+        fail! :too_many_operands, operation: operation, expected: expected, actual: output_size
       end
 
       args = []
-      if operator == AST::Array && output.empty?
+      if operation == AST::Array && output.empty?
         # special case: empty array literal '{}'
-        output.push(operator.new)
+        output.push(operation.new)
       else
         fail! :invalid_statement if output_size < args_size
         args = Array.new(args_size) { output.pop }.reverse
-        output.push operator.new(*args)
+        output.push operation.new(*args)
       end
 
-      if operator.respond_to?(:callback) && !operator.callback.nil?
-        operator.callback.call(args)
+      if operation.respond_to?(:callback) && !operation.callback.nil?
+        operation.callback.call(args)
       end
     rescue ::ArgumentError => e
-      raise Dentaku::ArgumentError, e.message
+      raise if e.is_a?(Dentaku::ArgumentError)
+      raise Dentaku::ArgumentError.for(:invalid_value), e.message
     rescue NodeError => e
-      fail! :node_invalid, operator: operator, child: e.child, expect: e.expect, actual: e.actual
+      raise ParseError.for(:node_invalid, operation: operation, operand: e.operand, expected: e.expected, actual: e.actual), e.message
     end
 
     def parse
@@ -190,8 +191,11 @@ module Dentaku
           operations.push(AST::CaseConditional)
           consume(2)
           arities[-1] += 1
-        elsif operations.last == AST::Case
-          # First WHEN: finalize switch variable expression.
+        elsif operations[token_index].nil? ||
+              (operations[token_index] != AST::CaseWhen && operations[token_index] < AST::Operation)
+          # First WHEN: fold any operators pending from an unparenthesized
+          # switch expression, then finalize the switch variable.
+          consume_until(AST::Case)
           operations.push(AST::CaseSwitchVariable)
           consume
         end
@@ -268,7 +272,7 @@ module Dentaku
       when :close
         consume while operations.any? && operations.last != AST::Grouping
         lparen = operations.pop
-        fail! :unbalanced_parenthesis, token unless lparen == AST::Grouping
+        fail! :unbalanced_parenthesis, token: token unless lparen == AST::Grouping
         if operations.last && operations.last < AST::Function
           consume(arities.pop.succ)
         end
@@ -284,35 +288,7 @@ module Dentaku
     end
 
     def fail!(reason, **meta)
-      message =
-        case reason
-        when :node_invalid
-          "#{meta.fetch(:operator)} requires #{meta.fetch(:expect).join(', ')} operands, but got #{meta.fetch(:actual)}"
-        when :too_few_operands
-          "#{meta.fetch(:operator)} has too few operands (given #{meta.fetch(:actual)}, expected #{meta.fetch(:expect)})"
-        when :too_many_operands
-          "#{meta.fetch(:operator)} has too many operands (given #{meta.fetch(:actual)}, expected #{meta.fetch(:expect)})"
-        when :undefined_function
-          "Undefined function #{meta.fetch(:function_name)}"
-        when :unprocessed_token
-          "Unprocessed token #{meta.fetch(:token_name)}"
-        when :unknown_case_token
-          "Unknown case token #{meta.fetch(:token_name)}"
-        when :unbalanced_bracket
-          "Unbalanced bracket"
-        when :unbalanced_parenthesis
-          "Unbalanced parenthesis"
-        when :unknown_grouping_token
-          "Unknown grouping token #{meta.fetch(:token_name)}"
-        when :not_implemented_token_category
-          "Not implemented for tokens of category #{meta.fetch(:token_category)}"
-        when :invalid_statement
-          "Invalid statement"
-        else
-          raise ::ArgumentError, "Unhandled #{reason}"
-        end
-
-      raise ParseError.for(reason, **meta), message
+      raise ParseError.for(reason, **meta)
     end
   end
 end

data/lib/dentaku/token_matcher.rb

@@ -93,46 +93,40 @@ module Dentaku
       @values.empty? || @values.key?(value)
     end
 
-    def self.datetime;       new(:datetime);                       end
-    def self.numeric;        new(:numeric);                        end
-    def self.string;         new(:string);                         end
-    def self.logical;        new(:logical);                        end
+    def self.datetime = new(:datetime)
+    def self.numeric = new(:numeric)
+    def self.string = new(:string)
+    def self.logical = new(:logical)
     def self.value
       new(:datetime) | new(:numeric) | new(:string) | new(:logical)
     end
 
-    def self.addsub;         new(:operator, [:add, :subtract]);    end
-    def self.subtract;       new(:operator, :subtract);            end
-    def self.anchored_minus; new(:operator, :subtract).caret;      end
-    def self.muldiv;         new(:operator, [:multiply, :divide]); end
-    def self.pow;            new(:operator, :pow);                 end
-    def self.mod;            new(:operator, :mod);                 end
-    def self.combinator;     new(:combinator);                     end
-
-    def self.comparator;     new(:comparator);                     end
-    def self.comp_gt;        new(:comparator, [:gt, :ge]);         end
-    def self.comp_lt;        new(:comparator, [:lt, :le]);         end
-
-    def self.open;           new(:grouping, :open);                end
-    def self.close;          new(:grouping, :close);               end
-    def self.comma;          new(:grouping, :comma);               end
-    def self.non_group;      new(:grouping).invert;                end
-    def self.non_group_star; new(:grouping).invert.star;           end
-    def self.non_close_plus; new(:grouping, :close).invert.plus;   end
-    def self.arguments;      (value | comma).plus;                 end
-
-    def self.if;             new(:function, :if);                  end
-    def self.round;          new(:function, :round);               end
-    def self.roundup;        new(:function, :roundup);             end
-    def self.rounddown;      new(:function, :rounddown);           end
-    def self.not;            new(:function, :not);                 end
-
-    def self.method_missing(name, *args, &block)
-      new(:function, name)
-    end
-
-    def self.respond_to_missing?(name, include_priv)
-      true
-    end
+    def self.addsub = new(:operator, [:add, :subtract])
+    def self.subtract = new(:operator, :subtract)
+    def self.anchored_minus = new(:operator, :subtract).caret
+    def self.muldiv = new(:operator, [:multiply, :divide])
+    def self.pow = new(:operator, :pow)
+    def self.mod = new(:operator, :mod)
+    def self.combinator = new(:combinator)
+
+    def self.comparator = new(:comparator)
+    def self.comp_gt = new(:comparator, [:gt, :ge])
+    def self.comp_lt = new(:comparator, [:lt, :le])
+
+    def self.open = new(:grouping, :open)
+    def self.close = new(:grouping, :close)
+    def self.comma = new(:grouping, :comma)
+    def self.non_group = new(:grouping).invert
+    def self.non_group_star = new(:grouping).invert.star
+    def self.non_close_plus = new(:grouping, :close).invert.plus
+    def self.arguments = (value | comma).plus
+
+    def self.function(name) = new(:function, name)
+
+    def self.if = function(:if)
+    def self.round = function(:round)
+    def self.roundup = function(:roundup)
+    def self.rounddown = function(:rounddown)
+    def self.not = function(:not)
   end
 end

data/lib/dentaku/token_matchers.rb

@@ -6,7 +6,7 @@ module Dentaku
 
     def self.function_token_matchers(function_name, *symbols)
       token_matchers(:open, *symbols, :close).unshift(
-        TokenMatcher.send(function_name)
+        TokenMatcher.function(function_name)
       )
     end
 
@@ -16,9 +16,9 @@ module Dentaku
         :comparator, :comp_gt, :comp_lt, :open, :close, :comma,
         :non_close_plus, :non_group, :non_group_star, :arguments,
         :logical, :combinator, :if, :round, :roundup, :rounddown, :not,
-        :anchored_minus, :math_neg_pow, :math_neg_mul
+        :anchored_minus
       ].each_with_object({}) do |name, matchers|
-        matchers[name] = TokenMatcher.send(name)
+        matchers[name] = TokenMatcher.public_send(name)
       end
 
       @matchers.fetch(symbol) do

data/lib/dentaku/tokenizer.rb

@@ -94,21 +94,7 @@ module Dentaku
     end
 
     def fail!(reason, **meta)
-      message =
-        case reason
-        when :parse_error
-          "parse error at: '#{meta.fetch(:at)}'"
-        when :too_many_opening_parentheses
-          "too many opening parentheses"
-        when :too_many_closing_parentheses
-          "too many closing parentheses"
-        when :unexpected_zero_width_match
-          "unexpected zero-width match (:#{meta.fetch(:category)}) at '#{meta.fetch(:at)}'"
-        else
-          raise ::ArgumentError, "Unhandled #{reason}"
-        end
-
-      raise TokenizerError.for(reason, **meta), message
+      raise TokenizerError.for(reason, **meta)
     end
   end
 end

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "3.5.8"
+  VERSION = "4.0.0"
 end

data/spec/ast/case_spec.rb

@@ -80,5 +80,12 @@ describe Dentaku::AST::Case do
       node = described_class.new(switch, conditional1, conditional2, else2)
       expect(node.dependencies).to eq([:fruit, :tax, :fallback])
     end
+
+    it 'short-circuits to the matched branch when the switch is resolvable' do
+      node = described_class.new(switch, conditional1, conditional2, else2)
+      expect(node.dependencies(fruit: 'apple')).to eq([])
+      expect(node.dependencies(fruit: 'banana')).to eq([:tax])
+      expect(node.dependencies(fruit: 'orange')).to eq([:fallback])
+    end
   end
 end

data/spec/bulk_expression_solver_spec.rb

@@ -195,7 +195,7 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       described_class.new(expressions, calculator).solve do |ex|
         exception = ex
       end
-      expect(exception.recipient_variable).to eq('more_apples')
+      expect(exception.assigned_to).to eq('more_apples')
     end
 
     it 'stores the recipient variable on the exception when there is an unbound variable' do
@@ -204,7 +204,17 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       described_class.new(expressions, calculator).solve do |ex|
         exception = ex
       end
-      expect(exception.recipient_variable).to eq('more_apples')
+      expect(exception.assigned_to).to eq('more_apples')
+    end
+
+    it 'sets the recipient variable before the solve block is invoked' do
+      expressions = {more_apples: "apples + 1"}
+      seen = :unset
+      described_class.new(expressions, calculator).solve do |ex|
+        seen = ex.assigned_to
+        :err
+      end
+      expect(seen).to eq('more_apples')
     end
 
     it 'stores the recipient variable on the exception when there is an ArgumentError' do
@@ -213,7 +223,7 @@ RSpec.describe Dentaku::BulkExpressionSolver do
       described_class.new(expressions, calculator).solve do |ex|
         exception = ex
       end
-      expect(exception.recipient_variable).to eq('more_apples')
+      expect(exception.assigned_to).to eq('more_apples')
     end
 
     it 'safely handles argument errors' do

data/spec/calculator_spec.rb

@@ -195,6 +195,21 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate!('a[x+1]', x: 1)).to eq(3)
     end
 
+    it 'accesses into strings and nested arrays' do
+      expect(calculator.evaluate!('a[1]', a: 'abc')).to eq('b')
+      expect(calculator.evaluate!('a[1][0]', a: [[1], [2, 3]])).to eq(2)
+    end
+
+    it 'raises an argument error when accessing into a non-indexable value' do
+      expect { calculator.evaluate!('a[0]', a: 5) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('a[0]', a: nil) }.to raise_error(Dentaku::ArgumentError)
+      expect { calculator.evaluate!('a[0]', a: true) }.to raise_error(Dentaku::ArgumentError)
+    end
+
+    it 'raises an argument error when the index type is incompatible' do
+      expect { calculator.evaluate!("a['one']", a: [1, 2, 3]) }.to raise_error(Dentaku::ArgumentError)
+    end
+
     it 'evaluates arrays' do
       expect(calculator.evaluate([1, 2, 3])).to eq([1, 2, 3])
       expect(calculator.evaluate!('{1,2,3}')).to eq([1, 2, 3])
@@ -967,6 +982,25 @@ describe Dentaku::Calculator do
     end
   end
 
+  describe 'logical operators with unbound operands' do
+    it 'short-circuits OR when the bound operand is true' do
+      expect(calculator.evaluate!('a OR b', a: true)).to eq(true)
+      expect(calculator.evaluate!('a OR b', b: true)).to eq(true)
+    end
+
+    it 'short-circuits AND when the bound operand is false' do
+      expect(calculator.evaluate!('a AND b', a: false)).to eq(false)
+      expect(calculator.evaluate!('a AND b', b: false)).to eq(false)
+    end
+
+    it 'still raises when the unbound operand is needed to decide' do
+      expect { calculator.evaluate!('a OR b', a: false) }
+        .to raise_error(Dentaku::UnboundVariableError)
+      expect { calculator.evaluate!('a AND b', a: true) }
+        .to raise_error(Dentaku::UnboundVariableError)
+    end
+  end
+
   describe 'aliases' do
     it 'accepts aliases as instance option' do
       expect(with_aliases.evaluate('rrround(5.1)')).to eq(5)
@@ -975,6 +1009,39 @@ describe Dentaku::Calculator do
     it 'accepts aliases with whitespace before parentheses' do
       expect(with_aliases.evaluate('rrround (5.1)')).to eq(5)
     end
+
+    it 'applies module-level aliases set after calculator creation' do
+      Dentaku.aliases = { round: ['redondear'] }
+      expect(calculator.evaluate('redondear(5.1)')).to eq(5)
+    ensure
+      Dentaku.aliases = {}
+    end
+  end
+
+  describe 'constructor options' do
+    it 'raises on unknown options' do
+      expect { described_class.new(case_sensitve: true) }
+        .to raise_error(::ArgumentError, /unknown keyword/)
+    end
+
+    it 'accepts a pre-warmed AST cache' do
+      node = calculator.ast('1+1')
+      warmed = described_class.new(ast_cache: { '1+1' => node })
+      expect(warmed.ast_cache).to eq('1+1' => node)
+    end
+
+    it 'caches ASTs when caching is enabled on the instance' do
+      caching = described_class.new(cache_ast: true)
+      caching.ast('1+1')
+      expect(caching.ast_cache.keys).to eq(['1+1'])
+    end
+
+    it 'does not cache ASTs when disabled on the instance, even if enabled globally' do
+      allow(Dentaku).to receive(:cache_ast?) { true }
+      non_caching = described_class.new(cache_ast: false)
+      non_caching.ast('1+1')
+      expect(non_caching.ast_cache).to be_empty
+    end
   end
 
   describe 'nested_data' do

data/spec/exceptions_spec.rb

@@ -7,3 +7,90 @@ describe Dentaku::UnboundVariableError do
     expect(exception.unbound_variables).to include('length')
   end
 end
+
+describe Dentaku::Error do
+  it 'is included in every Dentaku exception, even those subclassing Ruby built-ins' do
+    [
+      Dentaku::UnboundVariableError.new(['x']),
+      Dentaku::MathDomainError.new(:asin, [2]),
+      Dentaku::NodeError.new(:numeric, :string, :left),
+      Dentaku::ParseError.for(:node_invalid),
+      Dentaku::TokenizerError.for(:parse_error),
+      Dentaku::ArgumentError.for(:invalid_value),
+      Dentaku::ZeroDivisionError.new,
+    ].each do |exception|
+      expect(exception).to be_a(described_class)
+    end
+  end
+
+  it 'preserves stdlib ancestry for exceptions subclassing Ruby built-ins' do
+    expect(Dentaku::ArgumentError.for(:invalid_value)).to be_a(::ArgumentError)
+    expect(Dentaku::ZeroDivisionError.new).to be_a(::ZeroDivisionError)
+  end
+end
+
+describe Dentaku::ParseError do
+  it 'builds a message from reason and metadata' do
+    exception = described_class.for(:too_few_operands, operation: Dentaku::AST::Addition, expected: 2, actual: 1)
+    expect(exception.message).to eq('Dentaku::AST::Addition has too few operands (given 1, expected 2)')
+  end
+
+  it 'constructs with sparse metadata' do
+    expect(described_class.for(:node_invalid).message).to eq('Node is invalid')
+  end
+
+  it 'describes an :incompatible expectation as requiring compatible operands' do
+    exception = described_class.for(:node_invalid, operation: Dentaku::AST::Addition, expected: :incompatible, actual: :string)
+    expect(exception.message).to eq('Dentaku::AST::Addition requires compatible operands, but got string')
+  end
+
+  it 'allows call sites to override the default message' do
+    expect {
+      raise described_class.for(:node_invalid), 'Case missing switch variable'
+    }.to raise_error(described_class, 'Case missing switch variable')
+  end
+end
+
+describe Dentaku::TokenizerError do
+  it 'builds a message from reason and metadata' do
+    exception = described_class.for(:parse_error, at: '$5')
+    expect(exception.message).to eq("parse error at: '$5'")
+  end
+end
+
+describe Dentaku::ArgumentError do
+  it 'builds an incompatible_type message from a function context' do
+    exception = described_class.for(:incompatible_type, function_name: 'AND', expected: :logical, actual: 5)
+    expect(exception.message).to eq('AND() requires logical arguments, but got Integer')
+  end
+
+  it 'builds an incompatible_type message from expected and actual' do
+    exception = described_class.for(:incompatible_type, expected: Integer, actual: 2.5)
+    expect(exception.message).to eq('Float is not compatible with Integer')
+  end
+
+  it 'builds an invalid_operator message' do
+    exception = described_class.for(:invalid_operator, operation: Dentaku::AST::Addition, operator: :+)
+    expect(exception.message).to eq('Dentaku::AST::Addition requires operands that respond to +')
+  end
+
+  it 'describes an at-least arity as a range' do
+    exception = described_class.for(:too_few_arguments, function_name: 'SUM', expected: 1.., actual: 0)
+    expect(exception.message).to eq('SUM() has too few arguments (given 0, expected at least 1)')
+  end
+
+  it 'describes an exact arity as a count' do
+    exception = described_class.for(:wrong_number_of_arguments, function_name: 'INTERCEPT', expected: 2, actual: 4)
+    expect(exception.message).to eq('INTERCEPT() has the wrong number of arguments (given 4, expected 2)')
+  end
+
+  it 'constructs with sparse metadata' do
+    expect(described_class.for(:invalid_value).message).to eq('Invalid value')
+  end
+
+  it 'allows call sites to override the default message' do
+    expect {
+      raise described_class.for(:invalid_value), 'INTERCEPT() requires arrays of equal length'
+    }.to raise_error(described_class, 'INTERCEPT() requires arrays of equal length')
+  end
+end

data/spec/gemspec_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'dentaku.gemspec' do
+  # tsort no longer ships as a default gem in Ruby 4.1 (PR #334)
+  it 'declares tsort as a runtime dependency' do
+    gemspec = Gem::Specification.load(File.expand_path('../dentaku.gemspec', __dir__))
+    runtime_deps = gemspec.dependencies.select { |d| d.type == :runtime }.map(&:name)
+    expect(runtime_deps).to include('tsort')
+  end
+end

data/spec/identifiers_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'dentaku'
+require 'dentaku/calculator'
+
+describe Dentaku::Calculator do
+  describe '#identifiers' do
+    let(:calculator) { described_class.new }
+
+    it 'does not prune literal guards' do
+      expect(calculator.identifiers('IF(1 > 0, a, b)')).to eq(%w(a b))
+    end
+
+    it 'includes the guard identifiers themselves' do
+      expect(calculator.identifiers('IF(x > 5, y, z)')).to eq(%w(x y z))
+    end
+
+    it 'never executes functions, pure or volatile' do
+      count = { pure: 0, volatile: 0 }
+      calculator.add_function(:purefn, :numeric, ->(x) { count[:pure] += 1; x })
+      calculator.add_function(:volfn, :numeric, ->(x) { count[:volatile] += 1; x }, volatile: true)
+
+      expect(calculator.identifiers('IF(purefn(1) > 0, a, IF(volfn(2) > 0, b, c))')).to eq(%w(a b c))
+      expect(count).to eq(pure: 0, volatile: 0)
+    end
+
+    it 'includes switch and every branch of CASE' do
+      formula = 'CASE fruit WHEN w1 THEN t1 WHEN 2 THEN t2 ELSE e1 END'
+      expect(calculator.identifiers(formula)).to eq(%w(fruit w1 t1 t2 e1))
+    end
+
+    it 'includes both operands of AND/OR even when one is decisive' do
+      expect(calculator.identifiers('1 > 2 AND x')).to eq(['x'])
+      expect(calculator.identifiers('a AND b OR c')).to eq(%w(a b c))
+    end
+
+    it 'excludes enum-bound variables' do
+      expect(calculator.identifiers('MAP(users, u, u.age + bonus)')).to eq(%w(users bonus))
+    end
+
+    it 'ignores stored memory' do
+      calculator.store(a: 1)
+      expect(calculator.identifiers('a + b')).to eq(%w(a b))
+    end
+
+    it 'accepts an AST node' do
+      node = calculator.ast('x + y')
+      expect(calculator.identifiers(node)).to eq(%w(x y))
+    end
+
+    it 'accepts an array of expressions and deduplicates' do
+      expect(calculator.identifiers(['a + b', 'b + c'])).to eq(%w(a b c))
+    end
+
+    it 'deduplicates repeated identifiers' do
+      expect(calculator.identifiers('a + a * a')).to eq(['a'])
+    end
+
+    it 'lists all inputs of a formula using external-state functions' do
+      user_attr = ->(name, default = 0) { default }
+      calculator.add_function(:user_attr, :numeric, user_attr)
+
+      identifiers = calculator.identifiers("IF(user_attr('level') > 50, high_level_value, low_level_value)")
+      expect(identifiers).to eq(%w(high_level_value low_level_value))
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -84,6 +84,17 @@ describe Dentaku::Parser do
     expect(node.value("x" => 1, "y" => "A", "Y" => "B")).to eq(3)
   end
 
+  it 'evaluates a case statement with an unparenthesized operation as switch' do
+    node = parse('CASE a % 5 WHEN 0 THEN a ELSE b END')
+    expect(node.value("a" => 10, "b" => 1)).to eq(10)
+    expect(node.value("a" => 7, "b" => 1)).to eq(1)
+  end
+
+  it 'evaluates a case statement with a comparator as switch' do
+    node = parse('CASE a > 5 WHEN true THEN a ELSE b END')
+    expect(node.value("a" => 10, "b" => 1)).to eq(10)
+  end
+
   it 'evaluates arrays' do
     node = parse('{}')
     expect(node.value).to eq([])
@@ -111,6 +122,21 @@ describe Dentaku::Parser do
       }.to raise_error(Dentaku::ParseError)
     end
 
+    it 'preserves the node-level message for incompatible operands' do
+      expect {
+        parse('"hello" + 1')
+      }.to raise_error(
+        Dentaku::ParseError,
+        /requires operands that are numeric or compatible types, not string/
+      )
+    end
+
+    it 'preserves the node-level message for non-logical combinator operands' do
+      expect {
+        parse('1 AND 2')
+      }.to raise_error(Dentaku::ParseError, /requires logical operands/)
+    end
+
     it 'raises a parse error for too many operands' do
       expect {
         parse("IF(1, 0, IF(1, 2, 3, 4))")
@@ -167,6 +193,15 @@ describe Dentaku::Parser do
         parse("undefined()")
       }.to raise_error(Dentaku::ParseError)
     end
+
+    it 'raises a parse error for an unbalanced closing parenthesis' do
+      # the tokenizer catches unbalanced parentheses in a string expression,
+      # so exercise the parser directly with a hand-built token list
+      rparen = Dentaku::Token.new(:grouping, :close)
+      expect {
+        described_class.new([rparen]).parse
+      }.to raise_error(Dentaku::ParseError)
+    end
   end
 
   it "evaluates explicit 'NULL' as nil" do

data/spec/print_visitor_spec.rb

@@ -49,6 +49,11 @@ describe Dentaku::PrintVisitor do
     expect(repr).to eq('CASE a % 5 WHEN 0 THEN a ELSE b END')
   end
 
+  it 'prints a case statement that can be re-parsed' do
+    repr = roundtrip('case (a % 5) when 0 then a else b end')
+    expect(roundtrip(repr)).to eq(repr)
+  end
+
   it 'handles a bitwise operators' do
     repr = roundtrip('0xCAFE & 0xDECAF | 0xBEEF')
     expect(repr).to eq('0xCAFE & 0xDECAF | 0xBEEF')