scoped_search 4.1.11 → 4.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a3be22acffe6a33b115957197a5eca96b2e9cf2abe445b657b302663594abbe
-  data.tar.gz: a97d2cd9a8db87347dee308b1340e87967a887dd6b3c5c7b2124f7d9859a9843
+  metadata.gz: fbd1e857e3b248d6d585ac7c41679b536949dc945f4c7e067b2b16e86ce325b2
+  data.tar.gz: b4c1dc92102ff1d56b1f23406b16cf0523c6bdc17ab336ee92300993de5fd7f9
 SHA512:
-  metadata.gz: 840841fa78847d12b0f71ef620dbc73905e34a48325e10864ac56bf4aa746659d12f5cbbb18847c660e019bd42700700afb04928e7ccd48871bfe427ca8ba824
-  data.tar.gz: 11839160ebde29751173c28c718546d92a4378c316f081632f18eef2d688d569a4f1277caf14c40c4896f2168a7e4f42d0717af7482d430de13e9b04b3e77b9a
+  metadata.gz: 1fe965444b5640251c4ca34c5fc1fca34857f2c8cc96a8f759096165391490ca7deb7f5b3f9d8ed8c9219a5ddfa82716660e2739adb5d7dfdb2d61ca95a968a7
+  data.tar.gz: f9ce7c87b95ceec5f3f5d1cc46f6401ef121870bf58a8cffe1b07cb7de597b8bcd3bcd1069e98ef52007df2209b26998f3f1c05a9719eefe17351d1f6da1eebf

data/lib/scoped_search/query_builder.rb

@@ -509,7 +509,7 @@ module ScopedSearch
           raise ScopedSearch::QueryNotSupported, "Field '#{lhs.value}' not recognized for searching!" unless field
 
           # see if the value passes user defined validation
-          if operator == :in
+          if [:in, :notin].include?(operator)
             rhs.value.split(',').each { |v| validate_value(field, v) }
           else
             validate_value(field, rhs.value)

data/lib/scoped_search/query_language/parser.rb

@@ -31,7 +31,7 @@ module ScopedSearch::QueryLanguage::Parser
     next_token if !root_node && peek_token == :lparen # skip starting :lparen
     expressions << parse_logical_expression until peek_token.nil? || peek_token == :rparen
     next_token if !root_node && peek_token == :rparen # skip final :rparen
-    
+
     return ScopedSearch::QueryLanguage::AST::LogicalOperatorNode.new(DEFAULT_SEQUENCE_OPERATOR, expressions, root_node)
   end
 
@@ -42,18 +42,23 @@ module ScopedSearch::QueryLanguage::Parser
       when :lparen;         parse_expression_sequence
       when :not;            parse_logical_not_expression
       when :null, :notnull; parse_null_expression
+      when *LOGICAL_INFIX_OPERATORS; parse_logical_infix_expression
       else;                 parse_comparison
     end
 
     if LOGICAL_INFIX_OPERATORS.include?(peek_token)
-      operator = next_token
-      rhs = parse_logical_expression
-      ScopedSearch::QueryLanguage::AST::LogicalOperatorNode.new(operator, [lhs, rhs])
+      parse_logical_infix_expression([lhs])
     else
       lhs
     end
   end
 
+  def parse_logical_infix_expression(previous = [])
+    operator = next_token
+    rhs = parse_logical_expression
+    ScopedSearch::QueryLanguage::AST::LogicalOperatorNode.new(operator, previous + [rhs])
+  end
+
   # Parses a NOT expression
   def parse_logical_not_expression
     next_token # = skip NOT operator
@@ -80,7 +85,24 @@ module ScopedSearch::QueryLanguage::Parser
 
   # Parses a prefix comparison, i.e. without an explicit field: <operator> <value>
   def parse_prefix_comparison
-    return ScopedSearch::QueryLanguage::AST::OperatorNode.new(next_token, [parse_value])
+    token = next_token
+    case token
+    when :in
+      parse_prefix_in(true)
+    when :notin
+      parse_prefix_in(false)
+    else
+      ScopedSearch::QueryLanguage::AST::OperatorNode.new(token, [parse_value])
+    end
+  end
+
+  def parse_prefix_in(inclusion)
+    cmp, log = inclusion ? [:eq, :or] : [:ne, :and]
+    leaves = parse_multiple_values.map do |x|
+      leaf = ScopedSearch::QueryLanguage::AST::LeafNode.new(x)
+      ScopedSearch::QueryLanguage::AST::OperatorNode.new(cmp, [leaf])
+    end
+    ScopedSearch::QueryLanguage::AST::LogicalOperatorNode.new(log, leaves)
   end
 
   # Parses an infix expression, i.e. <field> <operator> <value>
@@ -109,7 +131,7 @@ module ScopedSearch::QueryLanguage::Parser
     value = []
     value << current_token if String === next_token until peek_token.nil? || peek_token == :rparen
     next_token if peek_token == :rparen  # consume the :rparen
-    value.join(',')
+    value
   end
 
   # This can either be a constant value or a field name.
@@ -117,7 +139,7 @@ module ScopedSearch::QueryLanguage::Parser
     if String === peek_token
       ScopedSearch::QueryLanguage::AST::LeafNode.new(next_token)
     elsif ([:in, :notin].include? current_token)
-      value = parse_multiple_values()
+      value = parse_multiple_values().join(',')
       ScopedSearch::QueryLanguage::AST::LeafNode.new(value)
     else
       raise ScopedSearch::QueryNotSupported, "Value expected but found #{peek_token.inspect}"

data/lib/scoped_search/version.rb

@@ -1,3 +1,3 @@
 module ScopedSearch
-  VERSION = "4.1.11"
+  VERSION = "4.1.13"
 end

data/spec/unit/parser_spec.rb

@@ -102,7 +102,27 @@ describe ScopedSearch::QueryLanguage::Parser do
     'set? a b null? c'.should parse_to([:and, [:notnull, 'a'], 'b', [:null, 'c']])
   end
 
+  it 'should parse logical operators with a single argument' do
+    '& a'.should parse_to('a')
+    '& & & & a & b & & &'.should parse_to([:and, 'a', 'b'])
+  end
+
+  it 'should parse in and not in operators with no lhs' do
+    '^ a'.should parse_to([:eq, 'a'])
+    '^ a b'.should parse_to([:or, [:eq, 'a'], [:eq, 'b']])
+    '^ a,b'.should parse_to([:or, [:eq, 'a'], [:eq, 'b']])
+
+    '^ (a b)'.should parse_to([:or, [:eq, 'a'], [:eq, 'b']])
+    '^ (a,b)'.should parse_to([:or, [:eq, 'a'], [:eq, 'b']])
+
+    '!^ a'.should parse_to([:ne, 'a'])
+    '!^ a b'.should parse_to([:and, [:ne, 'a'], [:ne, 'b']])
+    '!^ a,b'.should parse_to([:and, [:ne, 'a'], [:ne, 'b']])
+    '!^ (a b)'.should parse_to([:and, [:ne, 'a'], [:ne, 'b']])
+    '!^ (a,b)'.should parse_to([:and, [:ne, 'a'], [:ne, 'b']])
+  end
+
   it "should refuse to parse an empty not expression" do
     lambda { ScopedSearch::QueryLanguage::Compiler.parse('!()|*') }.should raise_error(ScopedSearch::QueryNotSupported)
-  end  
+  end
 end

data/spec/unit/query_builder_spec.rb

@@ -68,6 +68,8 @@ describe ScopedSearch::QueryBuilder do
 
     lambda { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field ^ (1,2)') }.should_not raise_error
     lambda { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field ^ (1,a)') }.should raise_error(ScopedSearch::QueryNotSupported)
+    lambda { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field !^ (1,2)') }.should_not raise_error
+    lambda { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field !^ (1,a)') }.should raise_error(ScopedSearch::QueryNotSupported)
   end
 
   it "should display custom error from validator" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scoped_search
 version: !ruby/object:Gem::Version
-  version: 4.1.11
+  version: 4.1.13
 platform: ruby
 authors:
 - Amos Benari
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-05 00:00:00.000000000 Z
+date: 2024-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -165,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.3.27
 signing_key:
 specification_version: 4
 summary: Easily search you ActiveRecord models with a simple query language using