sparkql 1.3.6 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c51d91b09c229564b83503e11d3ca453c91f5c280307effd1120d6a33b74010
-  data.tar.gz: ea90a995aa3dbd06ae7f187437c24abb81590ff396e837ec45e531ea25408f69
+  metadata.gz: aa4fb1fb72c6db01168e3b411de7fb2e1e409d6446ccb9cf34c8d5e486f7df47
+  data.tar.gz: f49564f84f78cb5deb97cdbd34c2bd177c47173f288ec841b15580b380a3be9e
 SHA512:
-  metadata.gz: c10a6629cc9606cdb49de2f60c64e6d0a38879c7abf4118e91fb23070eea06efa81b951a4f76daf185f5904efcbaa1b2ef4edb09a6124f24833e77865ecdd295
-  data.tar.gz: 9e073aa1c7963578f2ecf8e0a65230e7210c329a365a57e6b3fd7d4d0c7aa60e281b186e3c507ffe8f59a91fbefd16dbc9e99a9d97e8b603f4da6b1bb859c0e4
+  metadata.gz: 23aac5651ae1e314d79063c47f790c5fa4cbd63945d1ed390ca61fc89b747850ce8db1fe73a3a594b543a4fc225084481f5da75cdd0e817ff5810bbc88f6ca4c
+  data.tar.gz: f13283590cf799878cc1d1f064d93afeaab5c86f2f10e17abcf5bc9d094a5e3fd2f0e0830f8fba1095ebc902fc55ced385571fa451084be39ffc3348b777f7ca

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+v1.4.0 2026-10-13
+-------------------
+  * [IMPROVEMENT] `Parser#parse_tree` returns the filter as a syntax tree, with And/Not
+    binding tighter than Or. `Parser#parse` is now built by flattening that tree; its
+    output is unchanged.
+  * [CHANGE] The grammar actions `tokenize_expression`, `tokenize_conjunction`,
+    `tokenize_unary_conjunction`, and `tokenize_group` now return tree nodes instead of
+    expression arrays. Only relevant to subclasses overriding them (none known).
+  * [DOCS] Documented two Evaluator bugs with nested groups (see Sparkql::Evaluator), with
+    pending tests.
+
 v1.3.6, 2026-06-23
   * [BUGFIX] Parser crash when days()/weekdays() exceed max offset
 

data/README.md

@@ -39,6 +39,23 @@ The return value will be an array with one expression element containing the que
 	  # ...
 	}
 
+That flat list describes nesting through each expression's `:level`, `:block_group`,
+`:conjunction`, and `:unary` keys, which can't express every filter's structure (e.g. the
+middle group in `(A) And ((B) Or (C))`). When a consumer needs the real structure, use
+`parse_tree`, which returns a syntax tree instead:
+
+	tree = Parser.new.parse_tree("A Eq 1 Or B Eq 2 And C Eq 3")
+	# { node: :conjunction, conjunction: "Or",
+	#   left:  { node: :expression, expression: { field: "A", ... } },
+	#   right: { node: :conjunction, conjunction: "And",
+	#            left:  { node: :expression, expression: { field: "B", ... } },
+	#            right: { node: :expression, expression: { field: "C", ... } } } }
+
+Nodes are `:expression` (a comparison -- the same Hash `parse` returns), `:conjunction`
+(`And`/`Or`/`Not`, where `Not` means "And Not"), `:unary` (`Not`), and `:group`
+(parentheses). And/Not bind tighter than Or, as in SQL. `parse` is itself built by
+flattening this tree, so the two always agree. See test/unit/parse_tree_test.rb.
+
 
 Development
 -------------

data/VERSION

@@ -1 +1 @@
-1.3.6
+1.4.0

data/lib/sparkql/evaluator.rb

@@ -4,6 +4,40 @@
 # Namely, this class will handle all the nesting, boolean algebra, and dropped
 # fields. Plus, it has some optimizations built in to skip the processing for
 # any expressions that don't contribute to the net result of the filter.
+#
+# == KNOWN ISSUES -- read before relying on this for nested filters
+#
+# Used by prospector's SparkqlReductor to decide whether a listing matches a
+# saved search (newsfeeds, listing matching), so a wrong answer here means a
+# listing matches in prospector but not in search, or vice versa.
+#
+# This class reconstructs the filter's structure from Parser#parse's *flat*
+# expression list (:level, :block_group, :conjunction, :unary, ...), and that
+# list can't always describe the structure. Two confirmed bugs follow (see the
+# pending tests in test/unit/evaluator_test.rb):
+#
+# 1. Sibling groups nested in a group with no expression of its own are
+#    attached to the wrong parent:
+#      "(A) And ((B) Or (C))" with A=false, B=true, C=true => true (should be false)
+#    The middle group never appears in the flat list, and :block_group is the
+#    most recently *opened* group, not the containing one, so #build_structures
+#    files (B)'s block under (A)'s.
+#
+# 2. A leading unary Not on a group of two or more expressions negates only
+#    the group's first expression:
+#      "Not (A Or B) And C" is evaluated as "((Not A) Or B) And C"
+#    The flat list records the Not on A with :unary_level 0 (outside the
+#    group), but #process_structures applies :unary per expression and
+#    ignores :unary_level. "Not (A)" -- a single expression -- is unaffected.
+#
+# And/Or precedence is *not* an issue: evaluating left to right, but stopping
+# at an Or once the result is true (and otherwise taking the Or's right side
+# afresh), gives the same result as SQL's And-before-Or.
+#
+# The fix is to evaluate Parser#parse_tree's syntax tree instead, which
+# represents both cases exactly -- a recursive walk over its
+# expression/conjunction/unary/group nodes, keeping this class's :drop and
+# short-circuit semantics.
 class Sparkql::Evaluator
   include Sparkql::Token
 

data/lib/sparkql/parser_tools.rb

@@ -9,16 +9,66 @@ module Sparkql::ParserTools
   GROUP = 'Group'.freeze
   NEGATION = 'Negation'.freeze
 
+  ##
+  # Parses a filter into the flat expression list every parser consumer
+  # (Parser#tokenize, Evaluator, the API's SQL parsers) has always used: one
+  # Hash per comparison, in source order, with nesting described by each
+  # expression's :level, :block_group, :conjunction, :conjunction_level,
+  # :unary, and :unary_level keys.
+  #
+  # Built by flattening the same syntax tree #parse_tree returns, so the two
+  # always agree; see #flatten_tree for how the flat metadata is derived.
+  #
+  # @return [Array<Hash>, nil, 0] the expressions; nil on a syntax error; 0
+  #   for an empty filter
   def parse(str)
-    @lexer = Sparkql::Lexer.new(str)
-    @expression_count = 0
-    results = do_parse
-    return if results.nil?
+    tree = build_tree(str)
+    return tree unless tree.is_a?(Hash)
 
+    results = flatten_tree(tree)
     validate_expressions results
     results
   end
 
+  ##
+  # Parses a filter into a syntax tree, for consumers that need the filter's
+  # real structure -- the flat #parse list can't always be turned back into
+  # it (e.g. "(A) And ((B) Or (C))": the middle group has no expression of
+  # its own, so nothing in the list records it).
+  #
+  # Nodes are Hashes keyed by :node --
+  #   { node: :expression,  expression: <Hash> }  -- a comparison; the same
+  #                                                  Hash #parse would return
+  #   { node: :conjunction, conjunction: "And" | "Or" | "Not",
+  #     conjunction_level:, left: <node>, right: <node> }
+  #   { node: :unary,       unary: "Not", unary_level:, operand: <node> }
+  #   { node: :group,       operand: <node> }  -- parentheses
+  #
+  # A "Not" conjunction means "And Not": "A Not B" is A AND NOT B. And/Not
+  # bind tighter than Or, as in SQL -- "A Or B And C" is A OR (B AND C) --
+  # and chained conjunctions of the same strength group left to right. A
+  # unary Not applies to the single comparison or group that follows it.
+  #
+  # Errors are reported exactly as #parse reports them (see #errors).
+  #
+  # @return [Hash, nil] the root node; nil for an empty filter or a syntax error
+  def parse_tree(str)
+    tree = build_tree(str)
+    return unless tree.is_a?(Hash)
+
+    # Annotates each leaf with #parse's flat metadata, so a tree's leaves
+    # match #parse's output. Must run on the raw tree, before
+    # #apply_precedence, and only once (see #flatten_tree).
+    expressions = flatten_tree(tree)
+
+    # Records the same fatal "maximum expression count" error #parse does.
+    # validate_expressions also truncates the list it's given, which only
+    # matters for #parse's return value -- here the list is discarded, so the
+    # tree keeps every expression; callers must check #errors either way.
+    validate_expressions(expressions)
+    apply_precedence(tree)
+  end
+
   def next_token
     t = @lexer.shift
     t = @lexer.shift while (t[0] == :SPACE) || (t[0] == :NEWLINE)
@@ -91,36 +141,23 @@ module Sparkql::ParserTools
                       message: "Operator not supported for this type and value string", status: :fatal)
     end
     @expression_count += 1
-    [expression]
+    { node: :expression, expression: expression }
   end
 
-  def tokenize_conjunction(exp1, conj, exp2)
-    exp2.first[:conjunction] = conj
-    exp2.first[:conjunction_level] = @lexer.level
-    exp1 + exp2
+  # Grammar action for "expressions CONJUNCTION expression". The grammar
+  # chains conjunctions left to right; #apply_precedence regroups them.
+  # @lexer.level here is the level the conjunction itself sits at.
+  def tokenize_conjunction(left, conj, right)
+    { node: :conjunction, conjunction: conj, conjunction_level: @lexer.level, left: left, right: right }
   end
 
-  def tokenize_unary_conjunction(conj, exp)
-    # Handles the case when a SparkQL filter string
-    # begins with a unary operator, and is nested, such as:
-    #   Not (Not Field Eq 1)
-    # In this instance we treat the outer unary as a conjunction. With any other
-    # expression this would be the case, so that should make processing
-    # consistent.
-    if exp.first[:unary] && @lexer.level.zero?
-      exp.first[:conjunction] = conj
-      exp.first[:conjunction_level] = @lexer.level
-    else
-      exp.first[:unary] = conj
-      exp.first[:unary_level] = @lexer.level
-    end
-
-    exp
+  def tokenize_unary_conjunction(conj, operand)
+    { node: :unary, unary: conj, unary_level: @lexer.level, operand: operand }
   end
 
-  def tokenize_group(expressions)
+  def tokenize_group(operand)
     @lexer.leveldown
-    expressions
+    { node: :group, operand: operand }
   end
 
   def tokenize_arithmetic_group(lhs)
@@ -374,6 +411,16 @@ module Sparkql::ParserTools
     end
   end
 
+  # Records a fatal error past max_expressions and truncates results in
+  # place. Unlike the value/argument limits below, which trim mid-parse and
+  # so cap later work, this runs after parsing: the truncation only shortens
+  # the list #parse returns. The error is fatal, so callers shouldn't use
+  # the results anyway; kept for backward compatibility.
+  #
+  # TODO(2.0): stop slicing results here -- record the error and leave the
+  # list whole. A behavior change for #parse's return value (on an already
+  # fatal parse), so it waits for a major release. The value/argument
+  # slicing in validate_multiple_values/validate_multiple_arguments stays.
   def validate_expressions(results)
     if results.size > max_expressions
       compile_error(token: results[max_expressions][:field], expression: results[max_expressions],
@@ -383,6 +430,7 @@ module Sparkql::ParserTools
     end
   end
 
+  # TODO(2.0): stop slicing results here
   def validate_multiple_values(values)
     values = Array(values)
     if values.size > max_values
@@ -393,6 +441,7 @@ module Sparkql::ParserTools
     end
   end
 
+  # TODO(2.0): stop slicing results here
   def validate_multiple_arguments(args)
     args = Array(args)
     if args.size > max_values
@@ -463,6 +512,101 @@ module Sparkql::ParserTools
 
   private
 
+  # Runs the grammar, whose actions (#tokenize_expression,
+  # #tokenize_conjunction, #tokenize_unary_conjunction, #tokenize_group)
+  # build the raw tree: conjunctions chained left to right, before
+  # #apply_precedence.
+  # @return [Hash, nil, 0] the root node; nil on a syntax error; 0 when empty
+  def build_tree(str)
+    @lexer = Sparkql::Lexer.new(str)
+    @expression_count = 0
+    do_parse
+  end
+
+  ##
+  # Flattens a raw tree (straight from #build_tree, before #apply_precedence)
+  # into #parse's expression list, annotating each expression Hash in place.
+  #
+  # :level and :block_group were already set from the lexer as each
+  # expression was parsed. The conjunction and unary keys are applied here in
+  # the order the grammar reduces them -- bottom-up, left to right -- because
+  # the unary rule depends on what's already been applied: a Not in front of
+  # a group whose first expression already has a unary Not becomes that
+  # expression's :conjunction instead, e.g. "Not (Not Field Eq 1)".
+  #
+  # Annotates in place, so must run exactly once per parse.
+  def flatten_tree(node)
+    case node[:node]
+    when :expression
+      [node[:expression]]
+    when :group
+      flatten_tree(node[:operand])
+    when :unary
+      expressions = flatten_tree(node[:operand])
+      first = expressions.first
+      if first[:unary] && node[:unary_level].zero?
+        first[:conjunction] = node[:unary]
+        first[:conjunction_level] = node[:unary_level]
+      else
+        first[:unary] = node[:unary]
+        first[:unary_level] = node[:unary_level]
+      end
+      expressions
+    when :conjunction
+      left = flatten_tree(node[:left])
+      right = flatten_tree(node[:right])
+      right.first[:conjunction] = node[:conjunction]
+      right.first[:conjunction_level] = node[:conjunction_level]
+      left + right
+    end
+  end
+
+  ##
+  # Regroups the grammar's left-to-right conjunction chains so And/Not bind
+  # tighter than Or: "A Or B And C" becomes Or(A, And(B, C)). Returns new
+  # conjunction/unary/group nodes; expression nodes (and their Hashes) are
+  # shared with the input.
+  #
+  # The grammar's right operand is never itself a conjunction (only a
+  # comparison or a group), so a chain is the run of conjunctions down the
+  # left side of the tree.
+  def apply_precedence(node)
+    case node[:node]
+    when :conjunction
+      operators = []
+      operands = []
+      current = node
+      while current[:node] == :conjunction
+        operators.unshift(current)
+        operands.unshift(apply_precedence(current[:right]))
+        current = current[:left]
+      end
+      operands.unshift(apply_precedence(current))
+
+      or_operators = []
+      or_terms = []
+      term = operands.first
+      operators.each_with_index do |operator, i|
+        if operator[:conjunction] == Sparkql::Token::OR
+          or_operators << operator
+          or_terms << term
+          term = operands[i + 1]
+        else
+          term = operator.merge(left: term, right: operands[i + 1])
+        end
+      end
+      or_terms << term
+
+      or_terms.drop(1).each_with_index.inject(or_terms.first) do |left, (right, i)|
+        or_operators[i].merge(left: left, right: right)
+      end
+    when :unary, :group
+      node.merge(operand: apply_precedence(node[:operand]))
+    else
+      node
+    end
+  end
+
   def report_function_resolver_errors(resolver)
     resolver.errors.each do |error|
       tokenizer_error(token: error.token || @lexer.last_field,

data/test/unit/evaluator_test.rb

@@ -189,6 +189,29 @@ class EvaluatorTest < Test::Unit::TestCase
     assert_equal 3, @evaluator.processed_count
   end
 
+  # And/Or precedence matches SQL's (And before Or), not just left to right.
+  def test_and_before_or
+    assert sample("Test Eq true Or Test Eq true And Test Eq false")
+    assert sample("Test Eq false And Test Eq false Or Test Eq true")
+    assert !sample("Test Eq false Or Test Eq true And Test Eq false")
+    assert sample("Test Eq true And Test Eq false Or Test Eq true And Test Eq true")
+  end
+
+  # Known issue 1 in Sparkql::Evaluator's class comment. These pend while the
+  # bug exists, and fail once it's fixed -- move them to real tests then.
+  def test_known_issue_sibling_groups_in_an_expressionless_group
+    pend("Evaluator mis-nests sibling groups -- see Sparkql::Evaluator KNOWN ISSUES") do
+      assert !sample("(Test Eq false) And ((Test Eq true) Or (Test Eq true))")
+    end
+  end
+
+  # Known issue 2 in Sparkql::Evaluator's class comment.
+  def test_known_issue_unary_not_on_a_multi_expression_group
+    pend("Evaluator negates only the group's first expression -- see Sparkql::Evaluator KNOWN ISSUES") do
+      assert !sample("Not (Test Eq true Or Test Eq true) And Test Eq true")
+    end
+  end
+
   # Here's some examples from prospector's tests that have been simplified a bit.
   def test_advanced
     assert !sample("MlsStatus Eq false And PropertyType Eq true And (City Eq true Or City Eq false)")

data/test/unit/parse_tree_test.rb

@@ -0,0 +1,130 @@
+require 'test_helper'
+
+class ParseTreeTest < Test::Unit::TestCase
+  include Sparkql
+
+  def setup
+    @parser = Parser.new
+  end
+
+  # Renders a tree compactly by field name, e.g. "Or[A, And[B, C]]".
+  def shape(node)
+    case node[:node]
+    when :expression then node[:expression][:field]
+    when :group then "(#{shape(node[:operand])})"
+    when :unary then "#{node[:unary]} #{shape(node[:operand])}"
+    when :conjunction then "#{node[:conjunction]}[#{shape(node[:left])}, #{shape(node[:right])}]"
+    end
+  end
+
+  def assert_shape(expected, filter)
+    tree = @parser.parse_tree(filter)
+    assert !@parser.errors?, "#{filter}: #{@parser.errors.map(&:message)}"
+    assert_equal expected, shape(tree), filter
+  end
+
+  def leaves(node)
+    case node[:node]
+    when :expression then [node[:expression]]
+    when :group, :unary then leaves(node[:operand])
+    when :conjunction then leaves(node[:left]) + leaves(node[:right])
+    end
+  end
+
+  def test_single_expression
+    tree = @parser.parse_tree('Test Eq 10')
+
+    assert_equal :expression, tree[:node]
+    assert_equal 'Test', tree[:expression][:field]
+    assert_equal 'Eq', tree[:expression][:operator]
+    assert_equal '10', tree[:expression][:value]
+  end
+
+  def test_conjunctions_of_one_kind_group_left_to_right
+    assert_shape 'And[And[A, B], C]', 'A Eq 1 And B Eq 1 And C Eq 1'
+    assert_shape 'Or[Or[A, B], C]', 'A Eq 1 Or B Eq 1 Or C Eq 1'
+  end
+
+  def test_and_binds_tighter_than_or
+    assert_shape 'Or[A, And[B, C]]', 'A Eq 1 Or B Eq 1 And C Eq 1'
+    assert_shape 'Or[And[A, B], C]', 'A Eq 1 And B Eq 1 Or C Eq 1'
+    assert_shape 'Or[And[A, B], And[C, D]]', 'A Eq 1 And B Eq 1 Or C Eq 1 And D Eq 1'
+    assert_shape 'Or[Or[A, And[B, C]], D]', 'A Eq 1 Or B Eq 1 And C Eq 1 Or D Eq 1'
+  end
+
+  # A binary Not means "And Not", so it binds like And.
+  def test_binary_not_binds_like_and
+    assert_shape 'Or[A, Not[B, C]]', 'A Eq 1 Or B Eq 1 Not C Eq 1'
+    assert_shape 'Or[Not[And[A, B], C], D]', 'A Eq 1 And B Eq 1 Not C Eq 1 Or D Eq 1'
+  end
+
+  def test_groups_override_precedence
+    assert_shape 'And[(Or[A, B]), C]', '(A Eq 1 Or B Eq 1) And C Eq 1'
+    assert_shape 'Or[A, And[B, (Or[C, And[D, E]])]]', 'A Eq 1 Or B Eq 1 And (C Eq 1 Or D Eq 1 And E Eq 1)'
+  end
+
+  # The flat #parse list can't represent these: the middle group has no
+  # expression of its own, and block_group is the most recently opened group
+  # rather than the containing one.
+  def test_sibling_groups_keep_their_structure
+    assert_shape 'And[(A), (Or[(B), (C)])]', '(A Eq 1) And ((B Eq 1) Or (C Eq 1))'
+    assert_shape 'Or[(And[A, (B)]), (And[(C), D])]', '(A Eq 1 And (B Eq 1)) Or ((C Eq 1) And D Eq 1)'
+  end
+
+  def test_unary_not_applies_to_the_following_comparison_or_group
+    assert_shape 'And[Not A, B]', 'Not A Eq 1 And B Eq 1'
+    assert_shape 'And[Not (Or[A, B]), C]', 'Not (A Eq 1 Or B Eq 1) And C Eq 1'
+    assert_shape 'Not (Not A)', 'Not (Not A Eq 1)'
+  end
+
+  def test_conjunction_and_unary_nodes_carry_their_levels
+    tree = @parser.parse_tree('Not (A Eq 1 Or B Eq 1) And C Eq 1')
+    unary = tree[:left]
+    inner_or = unary[:operand][:operand]
+
+    assert_equal [:conjunction, 'And', 0], tree.values_at(:node, :conjunction, :conjunction_level)
+    assert_equal [:unary, 'Not', 0], unary.values_at(:node, :unary, :unary_level)
+    assert_equal [:conjunction, 'Or', 1], inner_or.values_at(:node, :conjunction, :conjunction_level)
+  end
+
+  # A tree's leaves are the same expression Hashes #parse returns, with the
+  # same flat metadata.
+  def test_leaves_match_parse_output
+    [
+      'A Eq 1 Or B Eq 1 And C Eq 1',
+      '(A Eq 1) And ((B Eq 1) Or (C Eq 1))',
+      'Not (A Eq 1 Or B Eq 1) And C Eq 1',
+      'Not (Not A Eq 1)',
+      "A Eq 1 Not (B Eq 'x' Or C Bt 1,2)"
+    ].each do |filter|
+      assert_equal Parser.new.parse(filter), leaves(@parser.parse_tree(filter)), filter
+    end
+  end
+
+  def test_empty_filter_is_nil
+    assert_nil @parser.parse_tree('')
+    assert !@parser.errors?
+  end
+
+  def test_syntax_error_is_nil_with_errors
+    assert_nil @parser.parse_tree('A Eq 1 And')
+    assert @parser.fatal_errors?
+  end
+
+  def test_validation_errors_are_reported_like_parse
+    filter = (1..80).map { |i| "F#{i} Eq #{i}" }.join(' And ')
+    tree = @parser.parse_tree(filter)
+
+    assert_not_nil tree
+    assert(@parser.errors.any? { |e| e.message.include?('maximum expression count') })
+
+    nested = Parser.new
+    nested.parse_tree('A Eq 1 And (((B Eq 1)))')
+    assert(nested.errors.any? { |e| e.message.include?('maximum nesting level') })
+  end
+
+  def test_parser_can_be_reused
+    assert_shape 'And[A, B]', 'A Eq 1 And B Eq 1'
+    assert_shape 'Or[C, D]', 'C Eq 1 Or D Eq 1'
+  end
+end

data/test/unit/parser_test.rb

@@ -11,6 +11,28 @@ class ParserTest < Test::Unit::TestCase
     parse "Test Eq 'false'", "'false'"
   end
 
+  # #parse is built by flattening #parse_tree's tree; these pin the flat
+  # nesting metadata to what the grammar has always produced, quirks
+  # included (block_group is the most recently opened group, not the
+  # containing one -- see D below), so existing consumers see no change.
+  def test_flat_nesting_metadata_is_unchanged
+    keys = %i[field conjunction conjunction_level level block_group unary unary_level]
+    flat = ->(filter) { Parser.new.parse(filter).map { |e| e.values_at(*keys).compact } }
+
+    assert_equal [['A', 'And', 0, 1, 1], ['B', 'And', 0, 2, 3], ['C', 'Or', 1, 2, 4]],
+                 flat.call('(A Eq 1) And ((B Eq 1) Or (C Eq 1))')
+    assert_equal [['A', 'And', 0, 1, 1], ['B', 'And', 1, 2, 2], ['C', 'Or', 0, 2, 4], ['D', 'And', 1, 1, 4]],
+                 flat.call('(A Eq 1 And (B Eq 1)) Or ((C Eq 1) And D Eq 1)')
+    # The outer Not becomes A's conjunction when A already has a unary Not.
+    assert_equal [['A', 'Not', 0, 1, 1, 'Not', 1]], flat.call('Not (Not A Eq 1)')
+    assert_equal [['A', 'And', 0, 1, 1, 'Not', 0], ['B', 'Or', 1, 1, 1], ['C', 'And', 0, 0, 0]],
+                 flat.call('Not (A Eq 1 Or B Eq 1) And C Eq 1')
+  end
+
+  def test_empty_filter_parses_to_zero
+    assert_equal 0, Parser.new.parse('')
+  end
+
   def test_conjunction
     @parser = Parser.new
     expression = @parser.parse('Test Eq 10 And Test Ne 11')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparkql
 version: !ruby/object:Gem::Version
-  version: 1.3.6
+  version: 1.4.0
 platform: ruby
 authors:
 - Wade McEwen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-25 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: georuby
@@ -153,6 +153,7 @@ files:
 - test/unit/function_resolver_test.rb
 - test/unit/geo/record_circle_test.rb
 - test/unit/lexer_test.rb
+- test/unit/parse_tree_test.rb
 - test/unit/parser_compatability_test.rb
 - test/unit/parser_test.rb
 - test/unit/security_test.rb