scoped_search 4.1.12 → 4.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fe5811549cf2e222ac16ea429293269abdd0734793b9e83611e76527acd905b
-  data.tar.gz: 22463f4c28a03919dc7e42cd4942dcc3d66c0291bcb087fa5ad1688492726efd
+  metadata.gz: 2413a0e2075ccff25188af0a579df4b8cfde593f38ab801b99bd7379b2344c8b
+  data.tar.gz: edc1ec5d32cc2b410fdf9938e49aca0cfba46807850491c3ee6bba28642dfc5b
 SHA512:
-  metadata.gz: 3e36707917762b0f2759da997bceb96b2f91b91bcbdb920d03a1738e408bc72a545e380f55bd5c35b9448d2916ac7ddb5dcc0ec623b6a36726d464ac818e15cb
-  data.tar.gz: 1b0e4c026cffd08a3851a5929dd8ee7244c041c27d282789bac19fb7af77e2b0641e8d80cf52fcf8f8318190f15c647bcdf76ac98b3576c537a65a5250ec7784
+  metadata.gz: 4a31a5e76daac85ca7b36cff7fdf38a377258401f38da13fb789afb1d6ca55e01331ce88c78136e7bc4efc64704e59460de267b50bfd8dc47e479c881e2b84b7
+  data.tar.gz: 87d273283f63fbc83afb0ab29f163a5625f0fc074c551c5220f004eb902c43a407973bf5470395c90442666ff14e1a69b1b0e7b8aba653c997d180da969429ee

data/CHANGELOG.rdoc

@@ -6,6 +6,16 @@ Please add an entry to the "Unreleased changes" section in your pull requests.
 
 === Unreleased changes
 
+=== Version 4.3.1
+- Autocomplete now offers only relevant options available through scopes set on associations (#233)
+
+=== Version 4.3.0
+
+- Prevent scoped_search from modifying an empty string on newer rubies (#229)
+- Autocomplete now wraps all strings in quotes, not just those containing whitespace (#230)
+- UUID search is now case insensitive (#232)
+- Autocomplete now honors scopes set on associations (#231)
+
 === Version 4.1.10
 
 - Fix querying through associations in Rails 6.1 (undefined method join_keys) (#201)

data/lib/scoped_search/auto_complete_builder.rb

@@ -207,6 +207,7 @@ module ScopedSearch
 
     def complete_value_from_db(field, special_values, val)
       count = 20 - special_values.count
+
       completer_scope(field)
         .where(@options[:value_filter])
         .where(value_conditions(field.quoted_field, val))
@@ -215,12 +216,20 @@ module ScopedSearch
         .distinct
         .map(&field.field)
         .compact
-        .map { |v| v.to_s =~ /\s/ ? "\"#{v.gsub('"', '\"')}\"" : v }
+        .map { |v| v.is_a?(String) ? "\"#{v.gsub('"', '\"')}\"" : v }
     end
 
     def completer_scope(field)
-      klass = field.klass
-      scope = klass.respond_to?(:completer_scope) ? klass.completer_scope(@options) : klass
+      scope = field.klass
+      scope = scope.completer_scope(@options) if scope.respond_to?(:completer_scope)
+
+      if field.klass != field.definition.klass
+        reflection = field.definition.reflection_by_name(field.definition.klass, field.relation)
+        sub_scope = reflection.active_record.joins(reflection.name)
+        sub_scope = sub_scope.select("#{field.klass.table_name}.#{field.klass.primary_key}")
+        scope = scope.where(field.klass.primary_key => sub_scope)
+      end
+
       scope.respond_to?(:reorder) ? scope.reorder(Arel.sql(field.quoted_field)) : scope.scoped(:order => field.quoted_field)
     end
 

data/lib/scoped_search/definition.rb

@@ -260,7 +260,7 @@ module ScopedSearch
 
     NUMERICAL_REGXP = /^\-?\d+(\.\d+)?$/
     INTEGER_REGXP = /^\-?\d+$/
-    UUID_REGXP = /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/
+    UUID_REGXP = /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i
 
     # Returns a list of appropriate fields to search in given a search keyword and operator.
     def default_fields_for(value, operator = nil)

data/lib/scoped_search/query_builder.rb

@@ -146,8 +146,22 @@ module ScopedSearch
       # but the field is of datetime type. Change the comparison to return
       # more logical results.
       if field.datetime?
-        span = 1.minute if(value =~ /\A\s*\d+\s+\bminutes?\b\s+\bago\b\s*\z/i)
-        span ||= (timestamp.day_fraction == 0) ? 1.day : 1.hour
+        if value =~ time_unit_regex("minutes?|hours?")
+          span = 1.minute
+        elsif value =~ time_unit_regex("days?|weeks?|months?|years?") || value =~ /\b(today|tomorrow|yesterday)\b/i
+          span = 1.day
+        else
+          tokens = DateTime._parse(value)
+          # find the smallest unit of time given in input and determine span for further adjustment of the search query
+          span = {
+            sec: 1.second,
+            min: 1.minute,
+            hour: 1.hour,
+            mday: 1.day,
+            mon: 1.month
+          }.find { |key, _| tokens[key] }&.last || 1.year
+        end
+
         if [:eq, :ne].include?(operator)
           # Instead of looking for an exact (non-)match, look for dates that
           # fall inside/outside the range of timestamps of that day.
@@ -155,13 +169,13 @@ module ScopedSearch
           field_sql = field.to_sql(operator, &block)
           return ["#{negate}(#{field_sql} >= ? AND #{field_sql} < ?)", timestamp, timestamp + span]
 
-        elsif operator == :gt
+        elsif span >= 1.day && operator == :gt
           # Make sure timestamps on the given date are not included in the results
           # by moving the date to the next day.
           timestamp += span
           operator = :gte
 
-        elsif operator == :lte
+        elsif span >= 1.day && operator == :lte
           # Make sure the timestamps of the given date are included by moving the
           # date to the next date.
           timestamp += span
@@ -320,6 +334,12 @@ module ScopedSearch
       definition.reflection_by_name(reflection.klass, as).options[:polymorphic]
     end
 
+    private
+
+    def time_unit_regex(time_unit)
+      /\A\s*\d+\s+\b(?:#{time_unit})\b\s+\b(ago|from\s+now)\b\s*\z/i
+    end
+
     # This module gets included into the Field class to add SQL generation.
     module Field
 

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/query_language/tokenizer.rb

@@ -69,7 +69,7 @@ module ScopedSearch::QueryLanguage::Tokenizer
   # Tokenizes a keyword that is quoted using double quotes. Allows escaping
   # of double quote characters by backslashes.
   def tokenize_quoted_keyword(&block)
-    keyword = ""
+    keyword = String.new
     until next_char.nil? || current_char == '"'
       keyword << (current_char == "\\" ? next_char : current_char)
     end

data/lib/scoped_search/version.rb

@@ -1,3 +1,3 @@
 module ScopedSearch
-  VERSION = "4.1.12"
+  VERSION = "4.3.1"
 end

data/lib/scoped_search.rb

@@ -1,3 +1,4 @@
+require 'logger' # a workaround for https://github.com/rails/rails/issues/54263
 require 'active_record'
 
 # ScopedSearch is the base module for the scoped_search plugin. This file

data/scoped_search.gemspec

@@ -34,6 +34,13 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency('rspec', '~> 3.0')
   gem.add_development_dependency('rake')
 
+  # Rails require these, but don't explicitly depend on them
+  gem.add_development_dependency('base64')
+  gem.add_development_dependency('benchmark')
+  gem.add_development_dependency('bigdecimal')
+  gem.add_development_dependency('logger')
+  gem.add_development_dependency('mutex_m')
+
   gem.rdoc_options << '--title' << gem.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
   gem.extra_rdoc_files = ['README.rdoc', 'CHANGELOG.rdoc', 'CONTRIBUTING.rdoc', 'LICENSE']
 end

data/spec/integration/auto_complete_spec.rb

@@ -41,6 +41,20 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         end
       end
 
+      ActiveRecord::Migration.create_table(:bazs, :force => true) do |t|
+        t.integer :foo_id
+      end
+
+      ActiveRecord::Migration.create_table(:asds, :force => true) do |t|
+        t.integer :baz_id
+        t.string :string
+      end
+
+      ActiveRecord::Migration.create_table(:qwes, :force => true) do |t|
+        t.integer :asd_id
+        t.string :string
+      end
+
       class ::Bar < ActiveRecord::Base
         belongs_to :foo
       end
@@ -65,28 +79,63 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         scoped_search :on => :other_c, :relation => :bars, :rename => 'bars.other_c'.to_sym
       end
 
+      class ::Baz < ActiveRecord::Base
+        belongs_to :foo, -> { where(string: 'foo') }
+        has_one :asd, -> { where(string: 'foo') }
+        has_one :qwe, through: :asd
+
+        scoped_search :on => :string, :relation => :foo, :complete_value => true, :rename => 'foos.string'.to_sym
+        scoped_search :on => :string, :relation => :asd, :complete_value => true, :rename => 'asds.string'.to_sym
+        scoped_search :on => :string, :relation => :qwe, :complete_value => true, :rename => 'qwes.string'.to_sym
+      end
+
       class ::Infoo < ::Foo
       end
 
+      class ::Asd < ActiveRecord::Base
+        belongs_to :baz
+        has_one :qwe
+      end
+
+      class ::Qwe < ActiveRecord::Base
+        belongs_to :asd
+      end
+
       @qux_1 = Qux.create!()
       @qux_2 = Qux.create!()
       @foo_1 = Foo.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz', :int => 9  , :date => 'February 8, 2011' , :unindexed => 10, :qux => @qux_1)
       @foo_2 = Foo.create!(:string => 'foo', :another => 'temp 2', :explicit => 'baz', :int => 10  , :date => 'February 8, 2011' , :unindexed => 10, :qux => @qux_2)
-      Foo.create!(:string => 'bar', :another => 'temp "2"', :explicit => 'baz', :int => 22  , :date => 'February 10, 2011', :unindexed => 10)
+      @foo_3 = Foo.create!(:string => 'bar', :another => 'temp "2"', :explicit => 'baz', :int => 22  , :date => 'February 10, 2011', :unindexed => 10)
       Foo.create!(:string => 'baz', :another => nil,      :explicit => nil  , :int => nil, :date => nil                 , :unindexed => nil)
       20.times { Foo.create!(:explicit => "aaa") }
 
+      @baz_1 = Baz.create!(:foo => @foo_1)
+      @baz_2 = Baz.create!(:foo => @foo_2)
+      Baz.create!(:foo => @foo_3)
+
       Bar.create!(:related => 'lala',         :foo => @foo_1)
       Bar.create!(:related => 'another lala', :foo => @foo_1)
+
+      @asd_1 = Asd.create!(:string => 'foo', :baz => @baz_1)
+      @asd_2 = Asd.create!(:string => 'bar', :baz => @baz_2)
+      Qwe.create!(:asd => @asd_1, :string => 'qwe1')
+      Qwe.create!(:asd => @asd_2, :string => 'qwe2')
     end
 
     after(:all) do
       ActiveRecord::Migration.drop_table(:foos)
       ActiveRecord::Migration.drop_table(:bars)
+      ActiveRecord::Migration.drop_table(:bazs)
+      ActiveRecord::Migration.drop_table(:asds)
+      ActiveRecord::Migration.drop_table(:qwes)
 
       Object.send :remove_const, :Foo
       Object.send :remove_const, :Bar
+      Object.send :remove_const, :Baz
+      Object.send :remove_const, :Qux
       Object.send :remove_const, :Infoo
+      Object.send :remove_const, :Asd
+      Object.send :remove_const, :Qwe
 
       ScopedSearch::RSpec::Database.close_connection
     end
@@ -169,10 +218,10 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       end
 
       it "should complete values should contain baz" do
-        Foo.complete_for('explicit = ').should contain('explicit =  baz')
+        Foo.complete_for('explicit = ').should contain('explicit =  "baz"')
       end
 
-      it "should complete values with quotes where required" do
+      it "should complete values with quotes where value is a string" do
         Foo.complete_for('alias = ').should contain('alias =  "temp \"2\""')
       end
     end
@@ -267,5 +316,15 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         Foo.complete_for('int =', value_filter: { qux_id: 99 }).should == []
       end
     end
+
+    context 'autocompleting with scopes' do
+      it 'should honor the scope' do
+        Baz.complete_for('foos.string =').should == ['foos.string = "foo"']
+      end
+
+      it 'should honor scope on the through relation' do
+        Baz.complete_for('qwes.string =').should == ['qwes.string = "qwe1"']
+      end
+    end
   end
 end

data/spec/integration/relation_querying_spec.rb

@@ -249,13 +249,13 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       before do
 
         # Create some tables
-        ActiveRecord::Migration.create_table(:mars) { |t| t.integer :koo_id; t.integer :baz_id }
-        ActiveRecord::Migration.create_table(:bazs) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:mars) { |t| t.integer :koo_id; t.integer :zab_id }
+        ActiveRecord::Migration.create_table(:zabs) { |t| t.string :related }
         ActiveRecord::Migration.create_table(:koos) { |t| t.string :foo }
 
         # The related classes
-        class Mar < ActiveRecord::Base; belongs_to :baz; belongs_to :koo; end
-        class Baz < ActiveRecord::Base; has_many :mars; end
+        class Mar < ActiveRecord::Base; belongs_to :zab; belongs_to :koo; end
+        class Zab < ActiveRecord::Base; has_many :mars; end
 
         # The class on which to call search_for
         class Koo < ActiveRecord::Base
@@ -263,38 +263,38 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
           # having the source option here is not needed for the statement correctness.
           # It is here to fail the code introduced in 2.6.2 that wrongly detected source instead of source_type
           # as an indication for a polymorphic relation.
-          has_many :bazs, :through => :mars, :source => :baz
+          has_many :zabs, :through => :mars, :source => :zab
 
-          scoped_search :relation => :bazs, :on => :related
+          scoped_search :relation => :zabs, :on => :related
         end
 
         @koo_1 = Koo.create!(:foo => 'foo')
         @koo_2 = Koo.create!(:foo => 'foo too')
         @koo_3 = Koo.create!(:foo => 'foo three')
 
-        @baz_1 = Baz.create(:related => 'baz')
-        @baz_2 = Baz.create(:related => 'baz too!')
+        @zab_1 = Zab.create(:related => 'zab')
+        @zab_2 = Zab.create(:related => 'zab too!')
 
-        @bar_1 = Mar.create!(:koo => @koo_1, :baz => @baz_1)
+        @bar_1 = Mar.create!(:koo => @koo_1, :zab => @zab_1)
         @bar_2 = Mar.create!(:koo => @koo_1)
-        @bar_3 = Mar.create!(:koo => @koo_2, :baz => @baz_1)
-        @bar_3 = Mar.create!(:koo => @koo_2, :baz => @baz_2)
-        @bar_3 = Mar.create!(:koo => @koo_2, :baz => @baz_2)
+        @bar_3 = Mar.create!(:koo => @koo_2, :zab => @zab_1)
+        @bar_3 = Mar.create!(:koo => @koo_2, :zab => @zab_2)
+        @bar_3 = Mar.create!(:koo => @koo_2, :zab => @zab_2)
         @bar_4 = Mar.create!(:koo => @koo_3)
       end
 
       after do
-        ActiveRecord::Migration.drop_table(:bazs)
+        ActiveRecord::Migration.drop_table(:zabs)
         ActiveRecord::Migration.drop_table(:mars)
         ActiveRecord::Migration.drop_table(:koos)
       end
 
-      it "should find the two records that are related to a baz record" do
-        Koo.search_for('baz').length.should == 2
+      it "should find the two records that are related to a zab record" do
+        Koo.search_for('zab').length.should == 2
       end
 
-      it "should find the two records that are related to a baz record" do
-        Koo.search_for('related=baz AND related="baz too!"').length.should == 1
+      it "should find the two records that are related to a zab record" do
+        Koo.search_for('related=zab AND related="zab too!"').length.should == 1
       end
     end
 
@@ -303,27 +303,27 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       before do
 
         # Create some tables
-        ActiveRecord::Migration.create_table(:zars) { |t| t.integer :baz_id }
-        ActiveRecord::Migration.create_table(:bazs) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:zars) { |t| t.integer :zab_id }
+        ActiveRecord::Migration.create_table(:zabs) { |t| t.string :related }
         ActiveRecord::Migration.create_table(:zoos) { |t| t.integer :zar_id; t.string :foo }
 
         # The related classes
-        class Zar < ActiveRecord::Base; belongs_to :baz; has_many :zoos; end
-        class Baz < ActiveRecord::Base; has_many :zars; end
+        class Zar < ActiveRecord::Base; belongs_to :zab; has_many :zoos; end
+        class Zab < ActiveRecord::Base; has_many :zars; end
 
         # The class on which to call search_for
         class Zoo < ActiveRecord::Base
           belongs_to :zar
-          has_many :bazs, :through => :zar
+          has_many :zabs, :through => :zar
 
-          scoped_search :relation => :bazs, :on => :related
+          scoped_search :relation => :zabs, :on => :related
         end
 
-        baz_1 = Baz.create(:related => 'baz')
-        baz_2 = Baz.create(:related => 'baz too!')
+        zab_1 = Zab.create(:related => 'zab')
+        zab_2 = Zab.create(:related => 'zab too!')
 
-        zar_1 = Zar.create!( :baz => baz_1)
-        zar_2 = Zar.create!( :baz => baz_2)
+        zar_1 = Zar.create!( :zab => zab_1)
+        zar_2 = Zar.create!( :zab => zab_2)
 
         Zoo.create!(:zar => zar_1, :foo => 'foo')
         Zoo.create!(:zar => zar_1, :foo => 'foo too')
@@ -331,17 +331,17 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       end
 
       after do
-        ActiveRecord::Migration.drop_table(:bazs)
+        ActiveRecord::Migration.drop_table(:zabs)
         ActiveRecord::Migration.drop_table(:zars)
         ActiveRecord::Migration.drop_table(:zoos)
       end
 
-      it "should find the three records that are related to a baz record" do
-        Zoo.search_for('baz').length.should == 3
+      it "should find the three records that are related to a zab record" do
+        Zoo.search_for('zab').length.should == 3
       end
 
-      it "should find no records that are related to a baz record" do
-        Zoo.search_for('related=baz AND related="baz too!"').length.should == 0
+      it "should find no records that are related to a zab record" do
+        Zoo.search_for('related=zab AND related="zab too!"').length.should == 0
       end
     end
 
@@ -392,8 +392,8 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         @tag_2 = Tag.create!(:foo => 'foo too')
         @tag_3 = Tag.create!(:foo => 'foo three')
 
-        @dog_1 = Dog.create(:related => 'baz')
-        @dog_2 = Dog.create(:related => 'baz too!')
+        @dog_1 = Dog.create(:related => 'zab')
+        @dog_2 = Dog.create(:related => 'zab too!')
         @cat_1 = Cat.create(:related => 'mitzi')
 
         @owner_1 = Owner.create(:name => 'Fred', :dogs => [@dog_1])
@@ -429,11 +429,11 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       end
 
       it "should find the two tags that are related to a dog record" do
-        Tag.search_for('dog=baz').length.should == 2
+        Tag.search_for('dog=zab').length.should == 2
       end
 
       it "should find the 3 tags that are related to dogs record" do
-        Tag.search_for('baz').length.should == 3
+        Tag.search_for('zab').length.should == 3
       end
     end
 
@@ -547,22 +547,22 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       before do
 
         # Create some tables with namespaces
-        ActiveRecord::Migration.create_table(:zan_mars) { |t| t.integer :koo_id; t.integer :baz_id }
-        ActiveRecord::Migration.create_table(:zan_bazs) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:zan_mars) { |t| t.integer :koo_id; t.integer :zab_id }
+        ActiveRecord::Migration.create_table(:zan_zabs) { |t| t.string :related }
         ActiveRecord::Migration.create_table(:zan_koos) { |t| t.string :foo }   
 
         # The related classes
-        module Zan; class Mar < ActiveRecord::Base; belongs_to :baz; belongs_to :koo; self.table_name = "zan_mars"; end; end
-        module Zan; class Baz < ActiveRecord::Base; has_many :mars; self.table_name = "zan_bazs"; end; end
+        module Zan; class Mar < ActiveRecord::Base; belongs_to :zab; belongs_to :koo; self.table_name = "zan_mars"; end; end
+        module Zan; class Zab < ActiveRecord::Base; has_many :mars; self.table_name = "zan_zabs"; end; end
 
         # The class on which to call search_for
         module Zan
           class Koo < ActiveRecord::Base
             has_many :mars, :class_name => "Zan::Mar"
-            has_many :bazs, :through => :mars
+            has_many :zabs, :through => :mars
             self.table_name = "zan_koos"
 
-            scoped_search :relation => :bazs, :on => :related
+            scoped_search :relation => :zabs, :on => :related
           end
         end
 
@@ -570,29 +570,29 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         @koo_2 = Zan::Koo.create!(:foo => 'foo too')
         @koo_3 = Zan::Koo.create!(:foo => 'foo three')
 
-        @baz_1 = Zan::Baz.create(:related => 'baz')
-        @baz_2 = Zan::Baz.create(:related => 'baz too!')
+        @zab_1 = Zan::Zab.create(:related => 'zab')
+        @zab_2 = Zan::Zab.create(:related => 'zab too!')
 
-        @bar_1 = Zan::Mar.create!(:koo => @koo_1, :baz => @baz_1)
+        @bar_1 = Zan::Mar.create!(:koo => @koo_1, :zab => @zab_1)
         @bar_2 = Zan::Mar.create!(:koo => @koo_1)
-        @bar_3 = Zan::Mar.create!(:koo => @koo_2, :baz => @baz_1)
-        @bar_3 = Zan::Mar.create!(:koo => @koo_2, :baz => @baz_2)
-        @bar_3 = Zan::Mar.create!(:koo => @koo_2, :baz => @baz_2)
+        @bar_3 = Zan::Mar.create!(:koo => @koo_2, :zab => @zab_1)
+        @bar_3 = Zan::Mar.create!(:koo => @koo_2, :zab => @zab_2)
+        @bar_3 = Zan::Mar.create!(:koo => @koo_2, :zab => @zab_2)
         @bar_4 = Zan::Mar.create!(:koo => @koo_3)
       end
 
       after do
-        ActiveRecord::Migration.drop_table(:zan_bazs)
+        ActiveRecord::Migration.drop_table(:zan_zabs)
         ActiveRecord::Migration.drop_table(:zan_mars)
         ActiveRecord::Migration.drop_table(:zan_koos)
       end
 
-      it "should find the two records that are related to a baz record" do
-        Zan::Koo.search_for('baz').length.should == 2
+      it "should find the two records that are related to a zab record" do
+        Zan::Koo.search_for('zab').length.should == 2
       end
 
-      it "should find the one record that is related to two baz records" do
-        Zan::Koo.search_for('related=baz AND related="baz too!"').length.should == 1
+      it "should find the one record that is related to two zab records" do
+        Zan::Koo.search_for('related=zab AND related="zab too!"').length.should == 1
       end
     end
 

data/spec/integration/uuid_query_spec.rb

@@ -43,8 +43,9 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         @class.search_for("uuid != #{@record3.uuid}").length.should == 2
       end
 
-      it "should find a record by just specifying the uuid" do
+      it "should find a record by just specifying the uuid (case insensitive)" do
         @class.search_for(@record1.uuid).first.uuid.should == @record1.uuid
+        @class.search_for(@record1.uuid.upcase).first.uuid.should == @record1.uuid
       end
 
       it "should not find a record if the uuid is not a valid uuid" do

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

@@ -155,4 +155,65 @@ describe ScopedSearch::QueryBuilder do
       lambda { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field = test_val') }.should raise_error(ScopedSearch::QueryNotSupported, /failed with error: test/)
     end
   end
+
+  context 'datetime_test' do
+    before(:each) do
+      @field = double('field')
+      @query_builder = ScopedSearch::QueryBuilder.new(@definition, nil, nil)
+
+      @field.stub(:datetime?).and_return(true)
+      @field.stub(:date?).and_return(false)
+      @field.stub(:to_sql).and_return('started_at')
+
+      [:virtual?, :set?, :temporal?, :relation, :offset].each { |key| @field.stub(key).and_return(false) }
+    end
+
+    it "should return correct SQL literal for equality operator" do
+      @definition.stub(:parse_temporal).and_return(DateTime.new(2023, 10, 10))
+      result = @query_builder.datetime_test(@field, :eq, '2023-10-10') { |type, value| }
+      result.should eq(["(started_at >= ? AND started_at < ?)", DateTime.new(2023, 10, 10), DateTime.new(2023, 10, 11)])
+    end
+
+    it "should return correct SQL literal for inequality operator" do
+      @definition.stub(:parse_temporal).and_return(DateTime.new(2023, 10, 10))
+      result = @query_builder.datetime_test(@field, :ne, '2023-10-10') { |type, value| }
+      result.should eq(["NOT (started_at >= ? AND started_at < ?)", DateTime.new(2023, 10, 10), DateTime.new(2023, 10, 11)])
+    end
+
+    it "should return correct SQL literal for greater operator" do
+      @definition.stub(:parse_temporal).and_return(DateTime.new(2023, 10, 9))
+      result = @query_builder.datetime_test(@field, :gt, '2023-10-9') { |type, value| }
+      result.should eq(["started_at >= ?", DateTime.new(2023, 10, 10)])
+    end
+
+    it "should return correct SQL literal for less than or equal operator" do
+      @definition.stub(:parse_temporal).and_return(DateTime.new(2023, 10, 10))
+      result = @query_builder.datetime_test(@field, :lte, '2023-10-10') { |type, value| }
+      result.should eq(["started_at < ?", DateTime.new(2023, 10, 11)])
+    end
+
+    it "should return empty array for invalid date" do
+      @definition.stub(:parse_temporal).and_return(nil)
+      result = @query_builder.datetime_test(@field, :eq, 'invalid-date') { |type, value| }
+      result.should eq([])
+    end
+
+    it "should count with 1 month deviation if only year and month is provided" do
+      @definition.stub(:parse_temporal).and_return(DateTime.new(2024, 1, 1))
+      result = @query_builder.datetime_test(@field, :gt, 'January 2024') { |type, value| }
+      result.should eq(["started_at >= ?", DateTime.new(2024, 2, 1)])
+    end
+
+    it "should not count with deviation if minute is the smallest unit provided" do
+      @definition.stub(:parse_temporal).and_return(DateTime.new(2023, 10, 10, 13, 0, 0))
+      result = @query_builder.datetime_test(@field, :gt, '2023-10-10 13:00') { |type, value| }
+      result.should eq(["started_at > ?", DateTime.new(2023, 10, 10, 13, 0, 0)])
+    end
+
+    it "should not count with deviation if second is the smallest unit provided" do
+      @definition.stub(:parse_temporal).and_return(DateTime.new(2023, 10, 10, 13, 0, 0, 1))
+      result = @query_builder.datetime_test(@field, :gt, '2023-10-10 13:00:01') { |type, value| }
+      result.should eq(["started_at > ?", DateTime.new(2023, 10, 10, 13, 0, 0, 1)])
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scoped_search
 version: !ruby/object:Gem::Version
-  version: 4.1.12
+  version: 4.3.1
 platform: ruby
 authors:
 - Amos Benari
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-26 00:00:00.000000000 Z
+date: 2025-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -54,6 +54,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       Scoped search makes it easy to search your ActiveRecord-based models.
 
@@ -165,7 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Easily search you ActiveRecord models with a simple query language using