scoped_search 4.1.5 → 4.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25198636d3a83a3be37b174722b43786bfb66c40
-  data.tar.gz: 2d51410c045dd98edffd782900a960f5111c47f4
+  metadata.gz: c94c65fc191d2afdddd82f3177121d2ade7e6238
+  data.tar.gz: 36dd864d06aafd40bd3015184a17222a92d5627f
 SHA512:
-  metadata.gz: 467be1c841cb5a0ce8eff10af66df07db0527a8b7423f386ad8a5ea29bea2ab4e3d02edb0b480ff427bfbdc0078ca1ac138690866db4fb67f13c31322334320b
-  data.tar.gz: fbc5a32d17479d8e919ca7b9e198416a0acb60bcbf0e1b2b3b7b850ad97af135a7cb5d57b0f93d3fee7a1b27c8ee7b47871367506ebe100e8beb58179041c01d
+  metadata.gz: 2a41edacae0b5140f56dc60bc921c8afb3349132b9ad3453313fc407abbda58b251c08d1da8d56706f9307520882e9e8006f18147833c91b7e3d0995962d843e
+  data.tar.gz: 31932dcd317193df257a4d0fd0c46fea28866e7670a0cfbd1d840d4477ada8381906d5f83b9289b322de3bbc44048ec249d9bf6af67f605bfc76589be9ccc7e3

data/CHANGELOG.rdoc

@@ -8,6 +8,11 @@ Please add an entry to the "Unreleased changes" section in your pull requests.
 
 - Nothing yet
 
+=== Version 4.1.6
+
+- Support for UUID columns on PostgreSQL (#184)
+- Allow value mapping on runtime to allow queries like "user = current" (#183)
+
 === Version 4.1.5
 
 - Bugfix related to auto-completion of virtual fields (#182)

data/lib/scoped_search/auto_complete_builder.rb

@@ -201,10 +201,16 @@ module ScopedSearch
       return complete_date_value if field.temporal?
       return complete_key_value(field, token, val) if field.key_field
 
+      special_values = field.special_values.select { |v| v =~ /\A#{val}/ }
+      special_values + complete_value_from_db(field, special_values, val)
+    end
+
+    def complete_value_from_db(field, special_values, val)
+      count = 20 - special_values.count
       completer_scope(field)
         .where(value_conditions(field.quoted_field, val))
         .select(field.quoted_field)
-        .limit(20)
+        .limit(count)
         .distinct
         .map(&field.field)
         .compact

data/lib/scoped_search/definition.rb

@@ -17,7 +17,7 @@ module ScopedSearch
 
       attr_reader :definition, :field, :only_explicit, :relation, :key_relation, :full_text_search,
                   :key_field, :complete_value, :complete_enabled, :offset, :word_size, :ext_method, :operators,
-                  :validator
+                  :validator, :value_translation, :special_values
 
       # Initializes a Field instance given the definition passed to the
       # scoped_search call on the ActiveRecord-based model class.
@@ -42,7 +42,9 @@ module ScopedSearch
                      profile: nil,
                      relation: nil,
                      rename: nil,
+                     special_values: [],
                      validator: nil,
+                     value_translation: nil,
                      word_size: 1,
                      **kwargs)
 
@@ -50,6 +52,8 @@ module ScopedSearch
         raise ArgumentError, "Missing field or 'on' keyword argument" if on.nil?
         @field = on.to_sym
 
+        raise ArgumentError, "'special_values' must be an Array" unless special_values.kind_of?(Array)
+
         # Reserved Ruby keywords so access via kwargs instead, but deprecate them for future versions
         if kwargs.key?(:in)
           relation = kwargs.delete(:in)
@@ -77,8 +81,10 @@ module ScopedSearch
         @only_explicit    = !!only_explicit
         @operators        = operators
         @relation         = relation
+        @special_values   = special_values
         @validator        = validator
         @word_size        = word_size
+        @value_translation = value_translation
 
         # Store this field in the field array
         definition.define_field(rename || @field, self)
@@ -154,6 +160,10 @@ module ScopedSearch
         [:string, :text].include?(type)
       end
 
+      def uuid?
+        type == :uuid
+      end
+
       # Returns true if this is a set.
       def set?
         complete_value.is_a?(Hash)
@@ -238,7 +248,7 @@ module ScopedSearch
       return [] if field.nil?
       return field.operators                                          if field.operators
       return ['=', '!=', '>', '<', '<=', '>=', '~', '!~', '^', '!^']  if field.virtual?
-      return ['=', '!=']                                              if field.set?
+      return ['=', '!=']                                              if field.set? || field.uuid?
       return ['=', '>', '<', '<=', '>=', '!=', '^', '!^']             if field.numerical?
       return ['=', '!=', '~', '!~', '^', '!^']                        if field.textual?
       return ['=', '>', '<']                                          if field.temporal?
@@ -247,6 +257,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}$/
 
     # Returns a list of appropriate fields to search in given a search keyword and operator.
     def default_fields_for(value, operator = nil)
@@ -255,6 +266,7 @@ module ScopedSearch
       column_types += [:string, :text]                if [nil, :like, :unlike, :ne, :eq].include?(operator)
       column_types += [:double, :float, :decimal]     if value =~ NUMERICAL_REGXP
       column_types += [:integer]                      if value =~ INTEGER_REGXP
+      column_types += [:uuid]                         if value =~ UUID_REGXP
       column_types += [:datetime, :date, :timestamp]  if (parse_temporal(value))
 
       default_fields.select { |field| !field.set? && column_types.include?(field.type) }

data/lib/scoped_search/query_builder.rb

@@ -181,6 +181,14 @@ module ScopedSearch
       translated_value
     end
 
+    def map_value(field, value)
+      old_value = value
+      translator = field.value_translation
+      value = translator.call(value) if translator
+      raise ScopedSearch::QueryNotSupported, "Translation from any value to nil is not allowed, translated '#{old_value}'" if value.nil?
+      value
+    end
+
     # A 'set' is group of possible values, for example a status might be "on", "off" or "unknown" and the database representation
     # could be for example a numeric value. This method will validate the input and translate it into the database representation.
     def set_test(field, operator,value, &block)
@@ -219,7 +227,7 @@ module ScopedSearch
         return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?"
 
       elsif [:in, :notin].include?(operator)
-        value.split(',').collect { |v| yield(:parameter, field.set? ? translate_value(field, v) : v.strip) }
+        value.split(',').collect { |v| yield(:parameter, map_value(field, field.set? ? translate_value(field, v) : v.strip)) }
         value = value.split(',').collect { "?" }.join(",")
         return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} (#{value})"
 
@@ -231,6 +239,7 @@ module ScopedSearch
 
       elsif field.relation && definition.reflection_by_name(field.definition.klass, field.relation).macro == :has_many
         value = value.to_i if field.offset
+        value = map_value(field, value)
         yield(:parameter, value)
         connection = field.definition.klass.connection
         primary_key = "#{connection.quote_table_name(field.definition.klass.table_name)}.#{connection.quote_column_name(field.definition.klass.primary_key)}"
@@ -244,6 +253,7 @@ module ScopedSearch
 
       else
         value = value.to_i if field.offset
+        value = map_value(field, value)
         yield(:parameter, value)
         return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?"
       end
@@ -517,7 +527,7 @@ module ScopedSearch
         def validate_value(field, value)
           validator = field.validator
           if validator
-            valid = validator.call(value)
+            valid = field.special_values.include?(value) || validator.call(value)
             raise ScopedSearch::QueryNotSupported, "Value '#{value}' is not valid for field '#{field.field}'" unless valid
           end
         end

data/lib/scoped_search/version.rb

@@ -1,3 +1,3 @@
 module ScopedSearch
-  VERSION = "4.1.5"
+  VERSION = "4.1.6"
 end

data/spec/integration/auto_complete_spec.rb

@@ -25,6 +25,12 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         t.integer :int
         t.date    :date
         t.integer :unindexed
+
+        if on_postgresql?
+          t.uuid :uuid
+        else
+          t.string :uuid
+        end
       end
 
       class ::Bar < ActiveRecord::Base
@@ -35,7 +41,7 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         has_many :bars
         default_scope { order(:string) }
 
-        scoped_search :on => [:string, :date]
+        scoped_search :on => [:string, :date, :uuid]
         scoped_search :on => [:int], :complete_value => true
         scoped_search :on => :another,  :default_operator => :eq, :aliases => [:alias], :complete_value => true
         scoped_search :on => :explicit, :only_explicit => true, :complete_value => true
@@ -90,6 +96,12 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         Foo.complete_for('date ').should =~ (["date  = ", "date  < ", "date  > "])
       end
 
+      it "should complete the uuid comparators" do
+        if on_postgresql?
+          Foo.complete_for('uuid ').should =~ (["uuid  = ", "uuid  != "])
+        end
+      end
+
       it "should complete when query is already distinct" do
         Foo.distinct.complete_for('int =').length.should > 0
       end
@@ -190,7 +202,7 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
     context 'exceptional search strings' do
 
       it "query that starts with 'or'" do
-        Foo.complete_for('or ').length.should == 9
+        Foo.complete_for('or ').length.should == 10
       end
 
       it "value completion with quotes" do
@@ -212,7 +224,7 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
     # the string.
     context 'dotted options in the completion list' do
       it "query that starts with space should not include the dotted options" do
-        Foo.complete_for(' ').length.should == 9
+        Foo.complete_for(' ').length.should == 10
       end
 
       it "query that starts with the dotted string should include the dotted options" do

data/spec/integration/uuid_query_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+require 'securerandom'
+
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::RSpec::Database.test_databases.each do |db|
+  describe ScopedSearch, "using a #{db} database" do
+    before(:all) do
+      ScopedSearch::RSpec::Database.establish_named_connection(db)
+
+      columns = on_postgresql? ? { :uuid => :uuid } : { :uuid => :string }
+
+      @class = ScopedSearch::RSpec::Database.create_model(columns.merge(:string => :string)) do |klass|
+        klass.scoped_search :on => :uuid
+        klass.scoped_search :on => :string
+      end
+    end
+
+    after(:all) do
+      ScopedSearch::RSpec::Database.drop_model(@class)
+      ScopedSearch::RSpec::Database.close_connection
+    end
+
+    context 'querying boolean fields' do
+
+      before(:all) do
+        @record1 = @class.create!(:uuid => SecureRandom.uuid)
+        @record2 = @class.create!(:uuid => SecureRandom.uuid)
+        @record3 = @class.create!(:uuid => SecureRandom.uuid)
+      end
+
+      after(:all) do
+        @record1.destroy
+        @record2.destroy
+        @record3.destroy
+      end
+
+      it "should find the first record" do
+        @class.search_for("uuid = #{@record1.uuid}").length.should == 1
+      end
+
+      it "should find two records with negative match" do
+        @class.search_for("uuid != #{@record3.uuid}").length.should == 2
+      end
+
+      it "should find a record by just specifying the uuid" do
+        @class.search_for(@record1.uuid).first.uuid.should == @record1.uuid
+      end
+
+      it "should not find a record if the uuid is not a valid uuid" do
+        if on_postgresql?
+          @class.search_for(@record1.uuid[0..-2]).length.should == 0
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -10,6 +10,9 @@ require "#{File.dirname(__FILE__)}/lib/matchers"
 require "#{File.dirname(__FILE__)}/lib/database"
 require "#{File.dirname(__FILE__)}/lib/mocks"
 
+def on_postgresql?
+  ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+end
 
 RSpec.configure do |config|
   config.include ScopedSearch::RSpec::Mocks

data/spec/unit/auto_complete_builder_spec.rb

@@ -9,6 +9,8 @@ describe ScopedSearch::AutoCompleteBuilder do
     @definition.stub(:klass).and_return(klass)
     @definition.stub(:profile).and_return(:default)
     @definition.stub(:profile=).and_return(true)
+    @definition.klass.stub(:connection).and_return(double())
+    @definition.stub(:default_order).and_return(nil)
   end
 
   it "should return empty suggestions if the search query is nil" do
@@ -19,6 +21,19 @@ describe ScopedSearch::AutoCompleteBuilder do
     ScopedSearch::AutoCompleteBuilder.auto_complete(@definition, "").should == []
   end
 
+  it 'should suggest special values' do
+    field = double('field')
+    [:temporal?, :set?, :key_field, :validator, :virtual?, :relation, :offset, :value_translation, :to_sql].each { |key| field.stub(key) }
+    field.stub(:special_values).and_return %w(foo bar baz)
+    field.stub(:complete_value).and_return(true)
+    @definition.stub(:default_fields_for).and_return([])
+    @definition.stub(:field_by_name).and_return(field)
+    @definition.stub(:fields).and_return [field]
+    ScopedSearch::AutoCompleteBuilder.any_instance.stub(:complete_value_from_db).and_return([])
+    ScopedSearch::AutoCompleteBuilder.auto_complete(@definition, "custom_field =").should eq(['custom_field = foo', 'custom_field = bar', 'custom_field = baz'])
+    ScopedSearch::AutoCompleteBuilder.auto_complete(@definition, "custom_field = f").should eq(['custom_field =  foo'])
+  end
+
   context "with ext_method" do
     before do
       @definition = ScopedSearch::Definition.new(klass)

data/spec/unit/query_builder_spec.rb

@@ -42,6 +42,7 @@ describe ScopedSearch::QueryBuilder do
     field.stub(:only_explicit).and_return(true)
     field.stub(:field).and_return(:test_field)
     field.stub(:validator).and_return(->(_value) { false })
+    field.stub(:special_values).and_return([])
 
     @definition.stub(:field_by_name).and_return(field)
 
@@ -58,6 +59,8 @@ describe ScopedSearch::QueryBuilder do
     field.stub(:set?).and_return(false)
     field.stub(:to_sql).and_return('')
     field.stub(:validator).and_return(->(value) { value =~ /^\d+$/ })
+    field.stub(:value_translation).and_return(nil)
+    field.stub(:special_values).and_return([])
 
     @definition.stub(:field_by_name).and_return(field)
 
@@ -71,12 +74,48 @@ describe ScopedSearch::QueryBuilder do
     field.stub(:only_explicit).and_return(true)
     field.stub(:field).and_return(:test_field)
     field.stub(:validator).and_return(->(_value) { raise ScopedSearch::QueryNotSupported, 'my custom message' })
+    field.stub(:special_values).and_return([])
 
     @definition.stub(:field_by_name).and_return(field)
 
     lambda { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field = test_val') }.should raise_error('my custom message')
   end
 
+  context 'with value_translation' do
+    let(:translator) do
+      ->(value) do
+        if %w(a b c).include?(value)
+          'good'
+        end
+      end
+    end
+    let(:special_values) { %w(a b c) }
+    before do
+      field = double('field')
+      field.stub(:field).and_return(:test_field)
+      field.stub(:key_field).and_return(nil)
+      field.stub(:to_sql).and_return('test_field')
+      [:virtual?, :set?, :temporal?, :relation, :offset].each { |key| field.stub(key).and_return(false) }
+      field.stub(:validator).and_return(->(value) { value == 'x' }) # Nothing except for special_values and x is valid
+      field.stub(:special_values).and_return(special_values)
+      field.stub(:value_translation).and_return(translator)
+      @definition.stub(:field_by_name).and_return(field)
+    end
+
+    it 'should translate the value' do
+      ScopedSearch::QueryBuilder.build_query(@definition, 'test_field = a').should eq(conditions: ['(test_field = ?)', 'good'])
+      ScopedSearch::QueryBuilder.build_query(@definition, 'test_field ^ (a, b, c)').should eq(conditions: ['(test_field IN (?,?,?))', 'good', 'good', 'good'])
+    end
+
+    it 'should validate before translation' do
+      proc { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field = d') }.should raise_error(ScopedSearch::QueryNotSupported, /Value 'd' is not valid for field/)
+    end
+
+    it 'should raise an error if translated value is nil' do
+      proc { ScopedSearch::QueryBuilder.build_query(@definition, 'test_field = x') }.should raise_error(ScopedSearch::QueryNotSupported, /Translation from any value to nil is not allowed/)
+    end
+  end
+
   context "with ext_method" do
     before do
       @definition = ScopedSearch::Definition.new(klass)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scoped_search
 version: !ruby/object:Gem::Version
-  version: 4.1.5
+  version: 4.1.6
 platform: ruby
 authors:
 - Amos Benari
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-19 00:00:00.000000000 Z
+date: 2018-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -120,6 +120,7 @@ files:
 - spec/integration/set_query_spec.rb
 - spec/integration/sti_querying_spec.rb
 - spec/integration/string_querying_spec.rb
+- spec/integration/uuid_query_spec.rb
 - spec/lib/database.rb
 - spec/lib/matchers.rb
 - spec/lib/mocks.rb
@@ -157,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Easily search you ActiveRecord models with a simple query language using
@@ -177,6 +178,7 @@ test_files:
 - spec/integration/set_query_spec.rb
 - spec/integration/sti_querying_spec.rb
 - spec/integration/string_querying_spec.rb
+- spec/integration/uuid_query_spec.rb
 - spec/lib/database.rb
 - spec/lib/matchers.rb
 - spec/lib/mocks.rb