scoped_search 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43261f39db1d9b12979b0a8ac09d325b89c31335
-  data.tar.gz: 65f7f0cf411208478aee6aa9c7bb11d13036bd88
+  metadata.gz: f8f3158e1d95aa30c3129d1f93fd908c7a52c8d4
+  data.tar.gz: db5a65eeebd58513c499ea3b6bbfb3a8723702d8
 SHA512:
-  metadata.gz: 96ec7c114d8d6cde7413eb1a3247540f181694acbaba09044d6d97a65405a87f44f55101b6c868108e8502254762a8a689290038f63ba743c2f67948f5a288ff
-  data.tar.gz: 26dc0c35c2547547af5759ba31128dce71784f93f70cecdff67c1cf5c108c81504f827a382249f7e076050fc2ede54ea5330bf1b10cf2fe3993de378466f64f6
+  metadata.gz: 34c8500136d8d3baf89313d09a9cfeb817798790ce27d16009745ed6af40dbc9ec47f3c2532dab44945c266cb491973179506b5e0a2950d02db5f64c337716f0
+  data.tar.gz: bf5ea94257096ead71261964695ba7fed482cbca7c5b5acfd5afed3653884312e5fda2d9c8d11262f3c7f7b710c78ce9c75b060b3ba5391bfa182eefd738fcf4

data/.travis.yml

@@ -1,30 +1,32 @@
-
 language: ruby
 cache: bundler
-
 sudo: false
 
+install:
+- bundle install
+before_script:
+- psql -c 'create database scoped_search_test;' -U postgres
+- mysql -e 'create database scoped_search_test;'
+script:
+- bundle exec rake
+
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.1
-  - ruby-head
-  - jruby-19mode
-  - jruby-head
+- "1.9"
+- "2.0"
+- "2.1"
+- "2.2"
+- ruby-head
+- jruby-19mode
+- jruby-head
 
 gemfile:
- - Gemfile.activerecord3
- - Gemfile.activerecord40
- - Gemfile.activerecord41
-
-before_script:
-  - psql -c 'create database scoped_search_test;' -U postgres
-  - mysql -e 'create database scoped_search_test;'
-
-script: bundle exec rake
+- Gemfile.activerecord32
+- Gemfile.activerecord40
+- Gemfile.activerecord41
+- Gemfile.activerecord42
 
 matrix:
-  include:
   allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head
+  - rvm: ruby-head
+  - rvm: jruby-head
+  - rvm: jruby-19mode

data/CHANGELOG.rdoc

@@ -8,7 +8,16 @@ Please add an entry to the "Unreleased changes" section in your pull requests.
 
 *Nothing yet*
 
-=== Version 3.0
+=== Version 3.1.0
+
+- Add support for ActiveRecord 4.2.
+- Bump AtiveRecord requirement to 3.2.
+
+===  Version 3.0.1
+
+- Security fix in parsing dates.
+
+=== Version 3.0.0
 
 - Add support for ActiveRecord 4.1
 - Drop support for Ruby 1.8

data/CONTRIBUTING.rdoc

@@ -6,10 +6,11 @@ Scoped search is an open source project, and hence we are open for contributions
 
 When reporting an issue, make sure to include the following information so we can pinpoint the problem faster:
 
-- What query did you use?
+- What search query did you use?
 - What is the search definition used on your models?
 - What do the tables involved in your search definition look like? Please include the type of the fields.
 - A sample of records. Which one did you expect to be included in the result
+- What was the SQL that scoped_search ended up generating?
 
 Finally, please include the following information about your environment.
 

data/{Gemfile.activerecord3 → Gemfile.activerecord32}

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 gemspec
 
-gem 'activerecord', '~> 3'
+gem 'activerecord', '~> 3.2.0'
 
 platforms :jruby do
   gem 'activerecord-jdbcsqlite3-adapter'

data/Gemfile.activerecord42

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'activerecord', '~> 4.2.0'
+
+platforms :jruby do
+  gem 'activerecord-jdbcsqlite3-adapter'
+  gem 'activerecord-jdbcmysql-adapter'
+  gem 'activerecord-jdbcpostgresql-adapter'
+end
+
+platforms :ruby do
+  gem 'sqlite3'
+  gem 'mysql2', '~> 0.3.11'
+  gem 'pg'
+end

data/lib/scoped_search/auto_complete_builder.rb

@@ -246,7 +246,7 @@ module ScopedSearch
 
       if field.key_klass != field.klass
         key   = field.key_klass.to_s.gsub(/.*::/,'').underscore.to_sym
-        fk    = field.klass.reflections[key].association_foreign_key.to_sym
+        fk    = definition.reflection_by_name(field.klass, key).association_foreign_key.to_sym
         query = query.where(fk => key_klass.id)
       end
 

data/lib/scoped_search/definition.rb

@@ -59,9 +59,7 @@ module ScopedSearch
       # The ActiveRecord-based class that belongs to this field.
       def klass
         @klass ||= if relation
-          related = definition.klass.reflections[relation]
-          raise ScopedSearch::QueryNotSupported, "relation '#{relation}' not one of #{definition.klass.reflections.keys.join(', ')} " if related.nil?
-          related.klass
+          definition.reflection_by_name(definition.klass, relation).klass
         else
           definition.klass
         end
@@ -70,9 +68,9 @@ module ScopedSearch
       # The ActiveRecord-based class that belongs the key field in a key-value pair.
       def key_klass
         @key_klass ||= if key_relation
-          definition.klass.reflections[key_relation].klass
+          definition.reflection_by_name(definition.klass, key_relation).klass
         elsif relation
-          definition.klass.reflections[relation].klass
+          definition.reflection_by_name(definition.klass, relation).klass
         else
           definition.klass
         end
@@ -87,7 +85,7 @@ module ScopedSearch
             if "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}".to_f < 4.1
               raise ActiveRecord::UnknownAttributeError, "#{klass.inspect} doesn't have column #{field.inspect}."
             else
-              raise ActiveRecord::UnknownAttributeError.new( klass, field )
+              raise ActiveRecord::UnknownAttributeError.new(klass, field)
             end
           end
         end
@@ -198,7 +196,7 @@ module ScopedSearch
       return ['= ', '> ', '< ', '<= ', '>= ','!= ', '^ ', '!^ ']  if field.numerical?
       return ['= ', '!= ', '~ ', '!~ ', '^ ', '!^ ']              if field.textual?
       return ['= ', '> ', '< ']                                   if field.temporal?
-      raise ScopedSearch::QueryNotSupported, "could not verify '#{name}' type, this can be a result of a definition error"
+      raise ScopedSearch::QueryNotSupported, "Unsupported type '#{field.type.inspect}')' for field '#{name}'. This can be a result of a search definition problem."
     end
 
     NUMERICAL_REGXP = /^\-?\d+(\.\d+)?$/
@@ -240,40 +238,29 @@ module ScopedSearch
       Field.new(self, options)
     end
 
+    # Returns a reflection for a given klass and name
+    def reflection_by_name(klass, name)
+      return if name.nil?
+      klass.reflections[name.to_sym] || klass.reflections[name.to_s]
+    end
+
     protected
 
     # Registers the search_for named scope within the class that is used for searching.
     def register_named_scope! # :nodoc
       definition = self
-      if @klass.ancestors.include?(ActiveRecord::Base)
-        case ActiveRecord::VERSION::MAJOR
-        when 3
-          @klass.scope(:search_for, lambda { |*args|
-            find_options = ScopedSearch::QueryBuilder.build_query(definition, args[0], args[1])
-            search_scope = @klass.scoped
-            search_scope = search_scope.where(find_options[:conditions]) if find_options[:conditions]
-            search_scope = search_scope.includes(find_options[:include]) if find_options[:include]
-            search_scope = search_scope.joins(find_options[:joins]) if find_options[:joins]
-            search_scope = search_scope.reorder(find_options[:order]) if find_options[:order]
-            search_scope
-          })
-        when 4
-          @klass.scope(:search_for, lambda { |*args|
-            find_options = ScopedSearch::QueryBuilder.build_query(definition, args[0], args[1])
-            search_scope = @klass
-            search_scope = search_scope.where(find_options[:conditions]) if find_options[:conditions]
-            search_scope = search_scope.includes(find_options[:include]) if find_options[:include]
-            search_scope = search_scope.references(find_options[:include]) if find_options[:include]
-            search_scope = search_scope.joins(find_options[:joins]) if find_options[:joins]
-            search_scope = search_scope.reorder(find_options[:order]) if find_options[:order]
-            search_scope
-          })
-        else
-          raise "This ActiveRecord version is currently not supported!"
-        end
-      else
-        raise "Currently, only ActiveRecord 3 or newer is supported!"
-      end
+      @klass.scope(:search_for, proc { |query, options|
+        search_scope = ActiveRecord::VERSION::MAJOR == 3 ? @klass.scoped : @klass
+
+        find_options = ScopedSearch::QueryBuilder.build_query(definition, query || '', options || {})
+        search_scope = search_scope.where(find_options[:conditions])   if find_options[:conditions]
+        search_scope = search_scope.includes(find_options[:include])   if find_options[:include]
+        search_scope = search_scope.joins(find_options[:joins])        if find_options[:joins]
+        search_scope = search_scope.reorder(find_options[:order])      if find_options[:order]
+        search_scope = search_scope.references(find_options[:include]) if find_options[:include] && ActiveRecord::VERSION::MAJOR >= 4
+
+        search_scope
+      })
     end
 
     # Registers the complete_for method within the class that is used for searching.

data/lib/scoped_search/query_builder.rb

@@ -14,17 +14,14 @@ module ScopedSearch
     # This method will parse the query string and build an SQL query using the search
     # query. It will return an empty hash if the search query is empty, in which case
     # the scope call will simply return all records.
-    def self.build_query(definition, *args)
-      query = args[0] ||=''
-      options = args[1] || {}
-
+    def self.build_query(definition, query, options = {})
       query_builder_class = self.class_for(definition)
       if query.kind_of?(ScopedSearch::QueryLanguage::AST::Node)
         return query_builder_class.new(definition, query, options[:profile]).build_find_params(options)
       elsif query.kind_of?(String)
         return query_builder_class.new(definition, ScopedSearch::QueryLanguage::Compiler.parse(query), options[:profile]).build_find_params(options)
       else
-        raise "Unsupported query object: #{query.inspect}!"
+        raise ArgumentError, "Unsupported query object: #{query.inspect}!"
       end
     end
 
@@ -213,26 +210,31 @@ module ScopedSearch
       if [:like, :unlike].include?(operator)
         yield(:parameter, (value !~ /^\%|\*/ && value !~ /\%|\*$/) ? "%#{value}%" : value.tr_s('%*', '%'))
         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 = value.split(',').collect { "?" }.join(",")
         return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} (#{value})"
+
       elsif field.temporal?
         return datetime_test(field, operator, value, &block)
+
       elsif field.set?
         return set_test(field, operator, value, &block)
-      elsif field.definition.klass.reflections[field.relation].try(:macro) == :has_many
+
+      elsif field.relation && definition.reflection_by_name(field.definition.klass, field.relation).macro == :has_many
         value = value.to_i if field.offset
         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)}"
-        if field.definition.klass.reflections[field.relation].options.has_key?(:through)
+        if definition.reflection_by_name(field.definition.klass, field.relation).options.has_key?(:through)
           join = has_many_through_join(field)
           return "#{primary_key} IN (SELECT #{primary_key} FROM #{join} WHERE #{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ? )"
         else
-          foreign_key = connection.quote_column_name(field.reflection_keys(field.definition.klass.reflections[field.relation])[1])
+          foreign_key = connection.quote_column_name(field.reflection_keys(definition.reflection_by_name(field.definition.klass, field.relation))[1])
           return "#{primary_key} IN (SELECT #{foreign_key} FROM #{connection.quote_table_name(field.klass.table_name)} WHERE #{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ? )"
         end
+
       else
         value = value.to_i if field.offset
         yield(:parameter, value)
@@ -242,21 +244,21 @@ module ScopedSearch
 
     def has_many_through_join(field)
       many_class = field.definition.klass
-      through = many_class.reflections[field.relation].options[:through]
+      through = definition.reflection_by_name(many_class, field.relation).options[:through]
       connection = many_class.connection
 
       # table names
       endpoint_table_name = field.klass.table_name
       many_table_name = many_class.table_name
-      middle_table_name = many_class.reflections[through].klass.table_name
+      middle_table_name = definition.reflection_by_name(many_class, through).klass.table_name
 
       # primary and foreign keys + optional condition for the many to middle join
-      pk1, fk1   = field.reflection_keys(many_class.reflections[through])
-      condition1 = field.reflection_conditions(field.klass.reflections[many_table_name.to_sym])
+      pk1, fk1   = field.reflection_keys(definition.reflection_by_name(many_class, through))
+      condition1 = field.reflection_conditions(definition.reflection_by_name(field.klass, many_table_name))
 
       # primary and foreign keys + optional condition for the endpoint to middle join
-      pk2, fk2   = field.reflection_keys(field.klass.reflections[middle_table_name.to_sym])
-      condition2 = field.reflection_conditions(many_class.reflections[field.relation])
+      pk2, fk2   = field.reflection_keys(definition.reflection_by_name(field.klass, middle_table_name))
+      condition2 = field.reflection_conditions(definition.reflection_by_name(many_class, field.relation))
 
       <<-SQL
         #{connection.quote_table_name(many_table_name)}
@@ -307,20 +309,20 @@ module ScopedSearch
       #  +----------+  +---------+ +--------+
       # uniq name for the joins are needed in case that there is more than one condition
       # on different keys in the same query.
-      def construct_join_sql(key_relation, num )
+      def construct_join_sql(key_relation, num)
         join_sql = ""
         connection = klass.connection
         key = key_relation.to_s.singularize.to_sym
 
-        key_table = klass.reflections[key].table_name
+        key_table = definition.reflection_by_name(klass, key).table_name
         value_table = klass.table_name.to_s
 
-        value_table_fk_key, key_table_pk = reflection_keys(klass.reflections[key])
+        value_table_fk_key, key_table_pk = reflection_keys(definition.reflection_by_name(klass, key))
 
-        main_reflection = definition.klass.reflections[relation]
+        main_reflection = definition.reflection_by_name(definition.klass, relation)
         if main_reflection
           main_table = definition.klass.table_name
-          main_table_pk, value_table_fk_main = reflection_keys(definition.klass.reflections[relation])
+          main_table_pk, value_table_fk_main = reflection_keys(definition.reflection_by_name(definition.klass, relation))
 
           join_sql = "\n  INNER JOIN #{connection.quote_table_name(value_table)} #{value_table}_#{num} ON (#{main_table}.#{main_table_pk} = #{value_table}_#{num}.#{value_table_fk_main})"
           value_table = " #{value_table}_#{num}"
@@ -339,12 +341,12 @@ module ScopedSearch
       #  +----------+  +---------+
       # uniq name for the joins are needed in case that there is more than one condition
       # on different keys in the same query.
-      def construct_simple_join_sql( num )
+      def construct_simple_join_sql(num)
         connection = klass.connection
         key_value_table = klass.table_name
 
         main_table = definition.klass.table_name
-        main_table_pk, value_table_fk_main = reflection_keys(definition.klass.reflections[relation])
+        main_table_pk, value_table_fk_main = reflection_keys(definition.reflection_by_name(definition.klass, relation))
 
         join_sql = "\n  INNER JOIN #{connection.quote_table_name(key_value_table)} #{key_value_table}_#{num} ON (#{connection.quote_table_name(main_table)}.#{connection.quote_column_name(main_table_pk)} = #{key_value_table}_#{num}.#{connection.quote_column_name(value_table_fk_main)})"
         return join_sql

data/lib/scoped_search/version.rb

@@ -1,3 +1,3 @@
 module ScopedSearch
-  VERSION = "3.0.1"
+  VERSION = "3.1.0"
 end

data/scoped_search.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = '>= 1.9.3'
-  gem.add_runtime_dependency('activerecord', '>= 3.0.0')
+  gem.add_runtime_dependency('activerecord', '>= 3.2.0')
   gem.add_development_dependency('rspec', '~> 3.0')
   gem.add_development_dependency('rake')
 

data/spec/integration/api_spec.rb

@@ -44,15 +44,8 @@ describe ScopedSearch, "API" do
       @class.should respond_to(:search_for)
     end
 
-    if ActiveRecord::VERSION::MAJOR == 3
-      it "should return a ActiveRecord::Relation instance" do
-        @class.search_for('query').class.should eql(ActiveRecord::Relation)
-      end
-
-    elsif ActiveRecord::VERSION::MAJOR == 4
-      it "should return a ActiveRecord::Relation instance" do
-        @class.search_for('query').class.superclass.should eql(ActiveRecord::Relation)
-      end
+    it "should return a ActiveRecord::Relation instance" do
+      @class.search_for('query').should be_a(ActiveRecord::Relation)
     end
   end
 end

data/spec/integration/key_value_querying_spec.rb

@@ -96,13 +96,8 @@ require "spec_helper"
         end
 
         it "should find all bars with a fact name color and fact value gold of descendant class" do
-          if ActiveRecord::VERSION::MAJOR == 3
-            MyItem.search_for('facts.color = gold').first.name.should eql('barbary')
-          end
+          MyItem.search_for('facts.color = gold').first.name.should eql('barbary')
         end
-
       end
-
     end
   end
-

data/spec/integration/relation_querying_spec.rb

@@ -222,9 +222,9 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
       end
 
       after do
-        ActiveRecord::Migration.drop_table(:dars_joos)
-        ActiveRecord::Migration.drop_table(:dars)
-        ActiveRecord::Migration.drop_table(:joos)
+        ScopedSearch::RSpec::Database.drop_model(Joo)
+        ScopedSearch::RSpec::Database.drop_model(Dar)
+        ActiveRecord::Migration.drop_table(:dars_joos) if ActiveRecord::Migration.table_exists?(:dars_joos)
       end
 
       it "should find all records with at least one associated bar record containing 'bar'" do
@@ -336,15 +336,12 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         ActiveRecord::Migration.drop_table(:zoos)
       end
 
-      # This table schema is not supported in activerecord 2, skip the tests
-      if ActiveRecord::VERSION::MAJOR > 2
-        it "should find the three records that are related to a baz record" do
-          Zoo.search_for('baz').length.should == 3
-        end
+      it "should find the three records that are related to a baz record" do
+        Zoo.search_for('baz').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
-        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
       end
     end
 

data/spec/lib/database.rb

@@ -20,7 +20,7 @@ module ScopedSearch::RSpec::Database
 
     @database_connections ||= YAML.load(File.read(file))
   end
-  
+
   def self.test_databases
     database_names = test_databases_configuration.keys.sort
     if ENV['EXCLUDE_DATABASE'].present?
@@ -59,6 +59,10 @@ module ScopedSearch::RSpec::Database
   end
 
   def self.drop_model(klass)
+    klass.constants.grep(/\AHABTM_/).each do |habtm_class|
+      ActiveRecord::Migration.drop_table(klass.const_get(habtm_class).table_name)
+      klass.send(:remove_const, habtm_class)
+    end
     ActiveRecord::Migration.drop_table(klass.table_name)
   end
-end
+end

data/spec/unit/definition_spec.rb

@@ -25,33 +25,15 @@ describe ScopedSearch::Definition do
   end
 
   describe '#initialize' do
+    it "should create the named scope when" do
+      @klass.should_receive(:scope).with(:search_for, instance_of(Proc))
+      ScopedSearch::Definition.new(@klass)
+    end
 
-    if ActiveRecord::VERSION::MAJOR == 2
-      
-      it "should create the named scope when" do
-        @klass.should_receive(:named_scope).with(:search_for, instance_of(Proc))
-        ScopedSearch::Definition.new(@klass)
-      end
-
-      it "should not create the named scope if it already exists" do
-        @klass.stub(:search_for)
-        @klass.should_not_receive(:named_scope)
-        ScopedSearch::Definition.new(@klass)
-      end
-      
-    elsif ActiveRecord::VERSION::MAJOR == 3
-      
-      it "should create the named scope when" do
-        @klass.should_receive(:scope).with(:search_for, instance_of(Proc))
-        ScopedSearch::Definition.new(@klass)
-      end
-
-      it "should not create the named scope if it already exists" do
-        @klass.stub(:search_for)
-        @klass.should_not_receive(:scope)
-        ScopedSearch::Definition.new(@klass)
-      end
-      
+    it "should not create the named scope if it already exists" do
+      @klass.stub(:search_for)
+      @klass.should_not_receive(:scope)
+      ScopedSearch::Definition.new(@klass)
     end
   end
 end

data/spec/unit/query_builder_spec.rb

@@ -10,8 +10,8 @@ describe ScopedSearch::QueryBuilder do
     @definition.stub(:profile=).and_return(true)
   end
 
-  it "should return empty conditions if the search query is nil" do
-    ScopedSearch::QueryBuilder.build_query(@definition, nil).should == { }
+  it "should raise an ArgumentError if the query is not set" do
+    lambda { ScopedSearch::QueryBuilder.build_query(@definition, nil) }.should raise_error(ArgumentError)
   end
 
   it "should return empty conditions if the query is blank" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scoped_search
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Amos Benari
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-24 00:00:00.000000000 Z
+date: 2015-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -82,9 +82,10 @@ files:
 - CHANGELOG.rdoc
 - CONTRIBUTING.rdoc
 - Gemfile
-- Gemfile.activerecord3
+- Gemfile.activerecord32
 - Gemfile.activerecord40
 - Gemfile.activerecord41
+- Gemfile.activerecord42
 - LICENSE
 - README.rdoc
 - Rakefile