@@ -67,7 +67,6 @@ end # Load all lib files require 'scoped_search/definition' -require 'scoped_search/adapters' require 'scoped_search/query_language' require 'scoped_search/query_builder' lib/scoped_search.rb @@ -106,7 +106,6 @@ module ScopedSearch @fields = {} @unique_fields = [] - setup_adapter! unless klass.connection.nil? register_named_scope! unless klass.respond_to?(:search_for) end @@ -118,7 +117,7 @@ module ScopedSearch column_types = [] column_types += [:string, :text] if [nil, :like, :unlike, :ne, :eq].include?(operator) column_types += [:integer, :double, :float, :decimal] if value =~ NUMERICAL_REGXP - column_types += [:datetime, :date, :timestamp] if ScopedSearch::QueryBuilder.parse_temporal(value) + column_types += [:datetime, :date, :timestamp] if (DateTime.parse(value) rescue nil) default_fields.select { |field| column_types.include?(field.type) } end @@ -142,10 +141,5 @@ module ScopedSearch def register_named_scope! # :nodoc @klass.named_scope(:search_for, lambda { |*args| ScopedSearch::QueryBuilder.build_query(args[1] || self, args[0]) }) end - - # Installs the database adapter based on the current database connection. - def setup_adapter! - ScopedSearch::Adapter.setup(@klass.connection) - end end end lib/scoped_search/definition.rb @@ -15,16 +15,25 @@ module ScopedSearch # query. It will return an ampty hash if the search query is empty, in which case # the scope call will simply return all records. def self.build_query(definition, query) + query_builder_class = self.class_for(definition) if query.kind_of?(ScopedSearch::QueryLanguage::AST::Node) - return self.new(definition, query).build_find_params + return query_builder_class.new(definition, query).build_find_params elsif query.kind_of?(String) - return self.new(definition, ScopedSearch::QueryLanguage::Compiler.parse(query)).build_find_params + return query_builder_class.new(definition, ScopedSearch::QueryLanguage::Compiler.parse(query)).build_find_params elsif query.nil? return { } else raise "Unsupported query object: #{query.inspect}!" end end + + # Loads the QueryBuilder class for the connection of the given definition. + # If no specific adapter is found, the default QueryBuilder class is returned. + def self.class_for(definition) + self.const_get(definition.klass.connection.class.name.split('::').last) + rescue + self + end # Initializes the instance by setting the relevant parameters def initialize(definition, ast) @@ -38,7 +47,7 @@ module ScopedSearch includes = [] # Build SQL WHERE clause using the AST - sql = @ast.to_sql(definition) do |notification, value| + sql = @ast.to_sql(self, definition) do |notification, value| # Handle the notifications encountered during the SQL generation: # Store the parameters, includes, etc so that they can be added to @@ -54,19 +63,19 @@ module ScopedSearch find_attributes = {} find_attributes[:conditions] = [sql] + parameters unless sql.nil? find_attributes[:include] = includes.uniq unless includes.empty? - # p find_attributes # Uncomment for debugging + find_attributes # Uncomment for debugging return find_attributes end # A hash that maps the operators of the query language with the corresponding SQL operator. SQL_OPERATORS = { :eq =>'=', :ne => '<>', :like => 'LIKE', :unlike => 'NOT LIKE', :gt => '>', :lt =>'<', :lte => '<=', :gte => '>=' } - + # Return the SQL operator to use given an operator symbol and field definition. # # By default, it will simply look up the correct SQL operator in the SQL_OPERATORS # hash, but this can be overrided by a database adapter. - def self.sql_operator(operator, field) + def sql_operator(operator, field) SQL_OPERATORS[operator] end @@ -81,7 +90,7 @@ module ScopedSearch # <tt>field</tt>:: The field to test. # <tt>operator</tt>:: The operator used for comparison. # <tt>value</tt>:: The value to compare the field with. - def self.datetime_test(field, operator, value, &block) # :yields: finder_option_type, value + def datetime_test(field, operator, value, &block) # :yields: finder_option_type, value # Parse the value as a date/time and ignore invalid timestamps timestamp = parse_temporal(value) @@ -118,7 +127,7 @@ module ScopedSearch # Yield the timestamp and return the SQL test yield(:parameter, timestamp) - "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?" + "#{field.to_sql(operator, &block)} #{sql_operator(operator, field)} ?" end # Generates a simple SQL test expression, for a field and value using an operator. @@ -129,7 +138,7 @@ module ScopedSearch # <tt>field</tt>:: The field to test. # <tt>operator</tt>:: The operator used for comparison. # <tt>value</tt>:: The value to compare the field with. - def self.sql_test(field, operator, value, &block) # :yields: finder_option_type, value + def sql_test(field, operator, value, &block) # :yields: finder_option_type, value if [:like, :unlike].include?(operator) && value !~ /^\%/ && value !~ /\%$/ yield(:parameter, "%#{value}%") return "#{field.to_sql(operator, &block)} #{self.sql_operator(operator, field)} ?" @@ -142,7 +151,7 @@ module ScopedSearch end # Try to parse a string as a datetime. - def self.parse_temporal(value) + def parse_temporal(value) DateTime.parse(value, true) rescue nil end @@ -156,7 +165,7 @@ module ScopedSearch # This function may yield an :include that should be used in the # ActiveRecord::Base#find call, to make sure that the field is avalable # for the SQL query. - def to_sql(operator = nil, &block) # :yields: finder_option_type, value + def to_sql(builder, operator = nil, &block) # :yields: finder_option_type, value yield(:include, relation) if relation definition.klass.connection.quote_table_name(klass.table_name) + "." + definition.klass.connection.quote_column_name(field) @@ -168,10 +177,10 @@ module ScopedSearch # Defines the to_sql method for AST LeadNodes module LeafNode - def to_sql(definition, &block) + def to_sql(builder, definition, &block) # Search keywords found without context, just search on all the default fields fragments = definition.default_fields_for(value).map do |field| - ScopedSearch::QueryBuilder.sql_test(field, field.default_operator, value, &block) + builder.sql_test(field, field.default_operator, value, &block) end "(#{fragments.join(' OR ')})" end @@ -181,52 +190,53 @@ module ScopedSearch module OperatorNode # Returns a NOT(...) SQL fragment that negates the current AST node's children - def to_not_sql(definition, &block) - "(NOT(#{rhs.to_sql(definition, &block)}) OR #{rhs.to_sql(definition, &block)} IS NULL)" + def to_not_sql(builder, definition, &block) + "(NOT(#{rhs.to_sql(builder, definition, &block)}) OR #{rhs.to_sql(builder, definition, &block)} IS NULL)" end # Returns an IS (NOT) NULL SQL fragment - def to_null_sql(definition, &block) + def to_null_sql(builder, definition, &block) field = definition.fields[rhs.value.to_sym] raise ScopedSearch::QueryNotSupported, "Field '#{rhs.value}' not recognized for searching!" unless field case operator - when :null then "#{field.to_sql(&block)} IS NULL" - when :notnull then "#{field.to_sql(&block)} IS NOT NULL" + when :null then "#{field.to_sql(builder, &block)} IS NULL" + when :notnull then "#{field.to_sql(builder, &block)} IS NOT NULL" end end # No explicit field name given, run the operator on all default fields - def to_default_fields_sql(definition, &block) + def to_default_fields_sql(builder, definition, &block) raise ScopedSearch::QueryNotSupported, "Value not a leaf node" unless rhs.kind_of?(ScopedSearch::QueryLanguage::AST::LeafNode) # Search keywords found without context, just search on all the default fields fragments = definition.default_fields_for(rhs.value, operator).map { |field| - ScopedSearch::QueryBuilder.sql_test(field, operator, rhs.value, &block) }.compact + builder.sql_test(field, operator, rhs.value, &block) }.compact + fragments.empty? ? nil : "(#{fragments.join(' OR ')})" end # Explicit field name given, run the operator on the specified field only - def to_single_field_sql(definition, &block) + def to_single_field_sql(builder, definition, &block) raise ScopedSearch::QueryNotSupported, "Field name not a leaf node" unless lhs.kind_of?(ScopedSearch::QueryLanguage::AST::LeafNode) raise ScopedSearch::QueryNotSupported, "Value not a leaf node" unless rhs.kind_of?(ScopedSearch::QueryLanguage::AST::LeafNode) # Search only on the given field. field = definition.fields[lhs.value.to_sym] raise ScopedSearch::QueryNotSupported, "Field '#{lhs.value}' not recognized for searching!" unless field - ScopedSearch::QueryBuilder.sql_test(field, operator, rhs.value, &block) + builder.sql_test(field, operator, rhs.value, &block) end # Convert this AST node to an SQL fragment. - def to_sql(definition, &block) + def to_sql(builder, definition, &block) if operator == :not && children.length == 1 - to_not_sql(definition, &block) + to_not_sql(builder, definition, &block) elsif [:null, :notnull].include?(operator) - to_null_sql(definition, &block) + to_null_sql(builder, definition, &block) elsif children.length == 1 - to_default_fields_sql(definition, &block) + to_default_fields_sql(builder, definition, &block) elsif children.length == 2 - to_single_field_sql(definition, &block) + to_single_field_sql(builder, definition, &block) else raise ScopedSearch::QueryNotSupported, "Don't know how to handle this operator node: #{operator.inspect} with #{children.inspect}!" end @@ -235,12 +245,34 @@ module ScopedSearch # Defines the to_sql method for AST AND/OR operators module LogicalOperatorNode - def to_sql(definition, &block) - fragments = children.map { |c| c.to_sql(definition, &block) }.compact + def to_sql(builder, definition, &block) + fragments = children.map { |c| c.to_sql(builder, definition, &block) }.compact fragments.empty? ? nil : "(#{fragments.join(" #{operator.to_s.upcase} ")})" end end end + + class MysqlAdapter < ScopedSearch::QueryBuilder + + def sql_operator(operator, field) + if [:ne, :eq].include?(operator) && field.textual? + "#{SQL_OPERATORS[operator]} BINARY" + else + super(operator, field) + end + end + end + + class PostgreSQLAdapter < ScopedSearch::QueryBuilder + + def sql_operator(operator, field) + case operator + when :like then 'ILIKE' + when :unlike then 'NOT ILIKE' + else super(operator, field) + end + end + end end # Include the modu;es into the corresponding classes lib/scoped_search/query_builder.rb @@ -1,3 +1,11 @@ +# rake spec will try to run the integration specs on all the following +# database connections to test the different adapters. +# +# The syntax of this file is similar to the database.yml file in a +# Rails application. You can change these parameters to your setup, +# or comment them out if you have no such database connections available +# to you. + sqlite3: adapter: "sqlite3" database: ":memory:" @@ -8,10 +16,10 @@ mysql: user: "root" password: database: "scoped_search_test" - + postgresql: adapter: "postgresql" host: "localhost" - username: "sstest" - password: "sstest" + username: "scoped_search" + password: "scoped_search" database: "scoped_search_test" spec/database.yml @@ -1,153 +1,158 @@ require "#{File.dirname(__FILE__)}/../spec_helper" -describe ScopedSearch do +# 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::Spec::Database.test_databases.each do |db| + + describe ScopedSearch, "using a #{db} database" do - before(:all) do - ScopedSearch::Spec::Database.establish_connection + before(:all) do + ScopedSearch::Spec::Database.establish_named_connection(db) - @class = ScopedSearch::Spec::Database.create_model(:int => :integer, :timestamp => :datetime, :date => :date, :unindexed => :integer) do |klass| - klass.scoped_search :on => [:int, :timestamp] - klass.scoped_search :on => :date, :only_explicit => true + @class = ScopedSearch::Spec::Database.create_model(:int => :integer, :timestamp => :datetime, :date => :date, :unindexed => :integer) do |klass| + klass.scoped_search :on => [:int, :timestamp] + klass.scoped_search :on => :date, :only_explicit => true + end end - end - after(:all) do - ScopedSearch::Spec::Database.drop_model(@class) - ScopedSearch::Spec::Database.close_connection - end + after(:all) do + ScopedSearch::Spec::Database.drop_model(@class) + ScopedSearch::Spec::Database.close_connection + end - context 'quering numerical fields' do + context 'quering numerical fields' do - before(:all) do - @record = @class.create!(:int => 9) - end + before(:all) do + @record = @class.create!(:int => 9) + end - after(:all) do - @record.destroy - end + after(:all) do + @record.destroy + end - it "should find the record with an exact integer match" do - @class.search_for('9').should have(1).item - end + it "should find the record with an exact integer match" do + @class.search_for('9').should have(1).item + end - it "should find the record with an exact integer match with an explicit operator" do - @class.search_for('= 9').should have(1).item - end + it "should find the record with an exact integer match with an explicit operator" do + @class.search_for('= 9').should have(1).item + end - it "should find the record with an exact integer match with an explicit field name" do - @class.search_for('int = 9').should have(1).item - end + it "should find the record with an exact integer match with an explicit field name" do + @class.search_for('int = 9').should have(1).item + end - it "should find the record with an exact integer match with an explicit field name" do - @class.search_for('int > 8').should have(1).item - end + it "should find the record with an exact integer match with an explicit field name" do + @class.search_for('int > 8').should have(1).item + end - it "should find the record with a grater than operator and explicit field" do - @class.search_for('int > 9').should have(0).item - end + it "should find the record with a grater than operator and explicit field" do + @class.search_for('int > 9').should have(0).item + end - it "should find the record with an >= operator with an implicit field name" do - @class.search_for('>= 9').should have(1).item - end + it "should find the record with an >= operator with an implicit field name" do + @class.search_for('>= 9').should have(1).item + end - it "should not return the record if only one predicate is true and AND is used (by default)" do - @class.search_for('int <= 8, int > 8').should have(0).item - end + it "should not return the record if only one predicate is true and AND is used (by default)" do + @class.search_for('int <= 8, int > 8').should have(0).item + end - it "should return the record in only one predicate is true and OR is used as operator" do - @class.search_for('int <= 8 || int > 8').should have(1).item + it "should return the record in only one predicate is true and OR is used as operator" do + @class.search_for('int <= 8 || int > 8').should have(1).item + end end - end - context 'querying unindexed fields' do + context 'querying unindexed fields' do - before(:all) do - @record = @class.create!(:int => 9, :unindexed => 10) - end + before(:all) do + @record = @class.create!(:int => 9, :unindexed => 10) + end - after(:all) do - @record.destroy - end + after(:all) do + @record.destroy + end - it "should raise an error when explicitly searching in the non-indexed column" do - lambda { @class.search_for('unindexed = 10') }.should raise_error(ScopedSearch::Exception) - end + it "should raise an error when explicitly searching in the non-indexed column" do + lambda { @class.search_for('unindexed = 10') }.should raise_error(ScopedSearch::Exception) + end - it "should not return records for which the query matches unindex records" do - @class.search_for('= 10').should have(0).item + it "should not return records for which the query matches unindex records" do + @class.search_for('= 10').should have(0).item + end end - end - context 'querying date and time fields' do + context 'querying date and time fields' do - before(:all) do - @record = @class.create!(:timestamp => Time.parse('2009-01-02 14:51:44'), :date => Date.parse('2009-01-02')) - @nil_record = @class.create!(:timestamp => nil, :date => nil) - end + before(:all) do + @record = @class.create!(:timestamp => Time.parse('2009-01-02 14:51:44'), :date => Date.parse('2009-01-02')) + @nil_record = @class.create!(:timestamp => nil, :date => nil) + end - after(:all) do - @record.destroy - @nil_record.destroy - end + after(:all) do + @record.destroy + @nil_record.destroy + end - it "should accept YYYY-MM-DD as date format" do - @class.search_for('date = 2009-01-02').should have(1).item - end + it "should accept YYYY-MM-DD as date format" do + @class.search_for('date = 2009-01-02').should have(1).item + end - it "should accept YY-MM-DD as date format" do - @class.search_for('date = 09-01-02').should have(1).item - end + it "should accept YY-MM-DD as date format" do + @class.search_for('date = 09-01-02').should have(1).item + end - it "should accept MM/DD/YY as date format" do - @class.search_for('date = 01/02/09').should have(1).item - end + it "should accept MM/DD/YY as date format" do + @class.search_for('date = 01/02/09').should have(1).item + end - it "should accept YYYY/MM/DD as date format" do - @class.search_for('date = 2009/01/02').should have(1).item - end + it "should accept YYYY/MM/DD as date format" do + @class.search_for('date = 2009/01/02').should have(1).item + end - it "should accept MM/DD/YYYY as date format" do - @class.search_for('date = 01/02/2009').should have(1).item - end + it "should accept MM/DD/YYYY as date format" do + @class.search_for('date = 01/02/2009').should have(1).item + end - it "should ignore an invalid date and thus return all records" do - @class.search_for('>= 2009-14-57').should have(2).items - end + it "should ignore an invalid date and thus return all records" do + @class.search_for('>= 2009-14-57').should have(2).items + end - it "should find the records with a timestamp set some point on the provided date" do - @class.search_for('>= 2009-01-02').should have(1).item - end + it "should find the records with a timestamp set some point on the provided date" do + @class.search_for('>= 2009-01-02').should have(1).item + end - it "should support full timestamps" do - @class.search_for('> "2009-01-02 02:02:02"').should have(1).item - end + it "should support full timestamps" do + @class.search_for('> "2009-01-02 02:02:02"').should have(1).item + end - it "should find no record with a timestamp in the past" do - @class.search_for('< 2009-01-02').should have(0).item - end + it "should find no record with a timestamp in the past" do + @class.search_for('< 2009-01-02').should have(0).item + end - it "should find all timestamps on a date if no time is given using the = operator" do - @class.search_for('= 2009-01-02').should have(1).item - end + it "should find all timestamps on a date if no time is given using the = operator" do + @class.search_for('= 2009-01-02').should have(1).item + end - it "should find all timestamps on a date if no time is when no operator is given" do - @class.search_for('2009-01-02').should have(1).item - end + it "should find all timestamps on a date if no time is when no operator is given" do + @class.search_for('2009-01-02').should have(1).item + end - it "should find all timestamps not on a date if no time is given using the != operator" do - @class.search_for('!= 2009-01-02').should have(0).item - end + it "should find all timestamps not on a date if no time is given using the != operator" do + @class.search_for('!= 2009-01-02').should have(0).item + end - it "should find the records when the date part of a timestamp matches a date" do - @class.search_for('>= 2009-01-02').should have(1).item - end + it "should find the records when the date part of a timestamp matches a date" do + @class.search_for('>= 2009-01-02').should have(1).item + end - it "should find the record with the timestamp today or in the past" do - @class.search_for('<= 2009-01-02').should have(1).item - end + it "should find the record with the timestamp today or in the past" do + @class.search_for('<= 2009-01-02').should have(1).item + end - it "should find no record with a timestamp later than today" do - @class.search_for('> 2009-01-02').should have(0).item + it "should find no record with a timestamp later than today" do + @class.search_for('> 2009-01-02').should have(0).item + end end end end spec/integration/ordinal_querying_spec.rb @@ -1,258 +1,262 @@ require "#{File.dirname(__FILE__)}/../spec_helper" -describe ScopedSearch do +# 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::Spec::Database.test_databases.each do |db| - before(:all) do - ScopedSearch::Spec::Database.establish_connection - end + describe ScopedSearch, "using a #{db} database" do - after(:all) do - ScopedSearch::Spec::Database.close_connection - end + before(:all) do + ScopedSearch::Spec::Database.establish_named_connection(db) + end - context 'querying a :belongs_to relation' do + after(:all) do + ScopedSearch::Spec::Database.close_connection + end - before(:all) do + context 'querying a :belongs_to relation' do + + before(:all) do + + # The related class + ActiveRecord::Migration.create_table(:bars) { |t| t.string :related } + class Bar < ActiveRecord::Base; has_many :foos; end - # The related class - ActiveRecord::Migration.create_table(:bars) { |t| t.string :related } - class Bar < ActiveRecord::Base; has_many :foos; end + # The class on which to call search_for + Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass| + klass.belongs_to :bar + klass.scoped_search :in => :bar, :on => :related + end - # The class on which to call search_for - Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass| - klass.belongs_to :bar - klass.scoped_search :in => :bar, :on => :related + @bar_record = Bar.create!(:related => 'bar') + + Foo.create!(:foo => 'foo', :bar => @bar_record) + Foo.create!(:foo => 'foo too', :bar => @bar_record) + Foo.create!(:foo => 'foo three', :bar => Bar.create!(:related => 'another bar')) + Foo.create!(:foo => 'foo four') end - @bar_record = Bar.create!(:related => 'bar') + after(:all) do + ScopedSearch::Spec::Database.drop_model(Bar) + ScopedSearch::Spec::Database.drop_model(Foo) + Object.send :remove_const, :Foo + Object.send :remove_const, :Bar + end - Foo.create!(:foo => 'foo', :bar => @bar_record) - Foo.create!(:foo => 'foo too', :bar => @bar_record) - Foo.create!(:foo => 'foo three', :bar => Bar.create!(:related => 'another bar')) - Foo.create!(:foo => 'foo four') - end + it "should find all records with a related bar record containing bar" do + Foo.search_for('bar').should have(3).items + end - after(:all) do - ScopedSearch::Spec::Database.drop_model(Bar) - ScopedSearch::Spec::Database.drop_model(Foo) - Object.send :remove_const, :Foo - Object.send :remove_const, :Bar - end + it "should find all records with a related bar record having an exact value of bar" do + Foo.search_for('= bar').should have(2).items + end - it "should find all records with a related bar record containing bar" do - Foo.search_for('bar').should have(3).items - end + it "should find all records with a related bar record having an exact value of bar with an explicit field" do + Foo.search_for('related = bar').should have(2).items + end - it "should find all records with a related bar record having an exact value of bar" do - Foo.search_for('= bar').should have(2).items + it "should find records for which the bar relation is not set using null?" do + Foo.search_for('null? related').should have(1).items + end end - it "should find all records with a related bar record having an exact value of bar with an explicit field" do - Foo.search_for('related = bar').should have(2).items - end + context 'querying a :has_many relation' do - it "should find records for which the bar relation is not set using null?" do - Foo.search_for('null? related').should have(1).items - end - end + before(:all) do - context 'querying a :has_many relation' do + # The related class + ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id } + class Bar < ActiveRecord::Base; belongs_to :foo; end - before(:all) do + # The class on which to call search_for + Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass| + klass.has_many :bars + klass.scoped_search :in => :bars, :on => :related + end - # The related class - ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id } - class Bar < ActiveRecord::Base; belongs_to :foo; end + @foo_1 = Foo.create!(:foo => 'foo') + @foo_2 = Foo.create!(:foo => 'foo too') + @foo_3 = Foo.create!(:foo => 'foo three') - # The class on which to call search_for - Foo = ScopedSearch::Spec::Database.create_model(:foo => :string, :bar_id => :integer) do |klass| - klass.has_many :bars - klass.scoped_search :in => :bars, :on => :related + Bar.create!(:related => 'bar', :foo => @foo_1) + Bar.create!(:related => 'another bar', :foo => @foo_1) + Bar.create!(:related => 'other bar', :foo => @foo_2) end - @foo_1 = Foo.create!(:foo => 'foo') - @foo_2 = Foo.create!(:foo => 'foo too') - @foo_3 = Foo.create!(:foo => 'foo three') + after(:all) do + ScopedSearch::Spec::Database.drop_model(Bar) + ScopedSearch::Spec::Database.drop_model(Foo) + Object.send :remove_const, :Foo + Object.send :remove_const, :Bar + end - Bar.create!(:related => 'bar', :foo => @foo_1) - Bar.create!(:related => 'another bar', :foo => @foo_1) - Bar.create!(:related => 'other bar', :foo => @foo_2) - end + it "should find all records with at least one bar record containing 'bar'" do + Foo.search_for('bar').should have(2).items + end - after(:all) do - ScopedSearch::Spec::Database.drop_model(Bar) - ScopedSearch::Spec::Database.drop_model(Foo) - Object.send :remove_const, :Foo - Object.send :remove_const, :Bar - end + it "should find the only record with at least one bar record having the exact value 'bar'" do + Foo.search_for('= bar').should have(1).item + end - it "should find all records with at least one bar record containing 'bar'" do - Foo.search_for('bar').should have(2).items - end + it "should find all records for which at least one related bar record exists" do + Foo.search_for('set? related').should have(2).items + end - it "should find the only record with at least one bar record having the exact value 'bar'" do - Foo.search_for('= bar').should have(1).item - end + it "should find all records for which none related bar records exist" do + Foo.search_for('null? related').should have(1).items + end - it "should find all records for which at least one related bar record exists" do - Foo.search_for('set? related').should have(2).items end - it "should find all records for which none related bar records exist" do - Foo.search_for('null? related').should have(1).items - end + context 'querying a :has_one relation' do - end + before(:all) do - context 'querying a :has_one relation' do + # The related class + ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id } + class Bar < ActiveRecord::Base; belongs_to :foo; end - before(:all) do + # The class on which to call search_for + Foo = ScopedSearch::Spec::Database.create_model(:foo => :string) do |klass| + klass.has_one :bar + klass.scoped_search :in => :bar, :on => :related + end + + @foo_1 = Foo.create!(:foo => 'foo') + @foo_2 = Foo.create!(:foo => 'foo too') + @foo_3 = Foo.create!(:foo => 'foo three') - # The related class - ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id } - class Bar < ActiveRecord::Base; belongs_to :foo; end + Bar.create!(:related => 'bar', :foo => @foo_1) + Bar.create!(:related => 'other bar', :foo => @foo_2) + end - # The class on which to call search_for - Foo = ScopedSearch::Spec::Database.create_model(:foo => :string) do |klass| - klass.has_one :bar - klass.scoped_search :in => :bar, :on => :related + after(:all) do + ScopedSearch::Spec::Database.drop_model(Bar) + ScopedSearch::Spec::Database.drop_model(Foo) + Object.send :remove_const, :Foo + Object.send :remove_const, :Bar end - @foo_1 = Foo.create!(:foo => 'foo') - @foo_2 = Foo.create!(:foo => 'foo too') - @foo_3 = Foo.create!(:foo => 'foo three') + it "should find all records with a bar record containing 'bar" do + Foo.search_for('bar').should have(2).items + end - Bar.create!(:related => 'bar', :foo => @foo_1) - Bar.create!(:related => 'other bar', :foo => @foo_2) - end + it "should find the only record with the bar record has the exact value 'bar" do + Foo.search_for('= bar').should have(1).item + end - after(:all) do - ScopedSearch::Spec::Database.drop_model(Bar) - ScopedSearch::Spec::Database.drop_model(Foo) - Object.send :remove_const, :Foo - Object.send :remove_const, :Bar - end + it "should find all records for which the related bar record exists" do + Foo.search_for('set? related').should have(2).items + end - it "should find all records with a bar record containing 'bar" do - Foo.search_for('bar').should have(2).items + it "should find all records for which the related bar record does not exist" do + Foo.search_for('null? related').should have(1).items + end end - it "should find the only record with the bar record has the exact value 'bar" do - Foo.search_for('= bar').should have(1).item - end + context 'querying a :has_and_belongs_to_many relation' do - it "should find all records for which the related bar record exists" do - Foo.search_for('set? related').should have(2).items - end + before(:all) do - it "should find all records for which the related bar record does not exist" do - Foo.search_for('null? related').should have(1).items - end - end + # Create some tables + ActiveRecord::Migration.create_table(:bars) { |t| t.string :related } + ActiveRecord::Migration.create_table(:bars_foos, :id => false) { |t| t.integer :foo_id; t.integer :bar_id } + ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo } - context 'querying a :has_and_belongs_to_many relation' do + # The related class + class Bar < ActiveRecord::Base; end - before(:all) do + # The class on which to call search_for + class Foo < ActiveRecord::Base + has_and_belongs_to_many :bars + scoped_search :in => :bars, :on => :related + end - # Create some tables - ActiveRecord::Migration.create_table(:bars) { |t| t.string :related } - ActiveRecord::Migration.create_table(:bars_foos, :id => false) { |t| t.integer :foo_id; t.integer :bar_id } - ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo } + @foo_1 = Foo.create!(:foo => 'foo') + @foo_2 = Foo.create!(:foo => 'foo too') + @foo_3 = Foo.create!(:foo => 'foo three') - # The related class - class Bar < ActiveRecord::Base; end + @bar_1 = Bar.create!(:related => 'bar') + @bar_2 = Bar.create!(:related => 'other bar') + @bar_3 = Bar.create!(:related => 'last bar') - # The class on which to call search_for - class Foo < ActiveRecord::Base - has_and_belongs_to_many :bars - scoped_search :in => :bars, :on => :related + @foo_1.bars << @bar_1 << @bar_2 + @foo_2.bars << @bar_2 << @bar_3 end - @foo_1 = Foo.create!(:foo => 'foo') - @foo_2 = Foo.create!(:foo => 'foo too') - @foo_3 = Foo.create!(:foo => 'foo three') + after(:all) do + ActiveRecord::Migration.drop_table(:bars_foos) + ActiveRecord::Migration.drop_table(:bars) + ActiveRecord::Migration.drop_table(:foos) + Object.send :remove_const, :Foo + Object.send :remove_const, :Bar + end - @bar_1 = Bar.create!(:related => 'bar') - @bar_2 = Bar.create!(:related => 'other bar') - @bar_3 = Bar.create!(:related => 'last bar') + it "should find all records with at least one associated bar record containing 'bar'" do + Foo.search_for('bar').should have(2).items + end - @foo_1.bars << @bar_1 << @bar_2 - @foo_2.bars << @bar_2 << @bar_3 - end + it "should find record which is related to @bar_1" do + Foo.search_for('= bar').should have(1).items + end - after(:all) do - ActiveRecord::Migration.drop_table(:bars_foos) - ActiveRecord::Migration.drop_table(:bars) - ActiveRecord::Migration.drop_table(:foos) - Object.send :remove_const, :Foo - Object.send :remove_const, :Bar - end + it "should find the only record related to @bar_3" do + Foo.search_for('last').should have(1).items + end - it "should find all records with at least one associated bar record containing 'bar'" do - Foo.search_for('bar').should have(2).items + it "should find all records that are related to @bar_2" do + Foo.search_for('other').should have(2).items + end end - it "should find record which is related to @bar_1" do - Foo.search_for('= bar').should have(1).items - end + context 'querying a :has_many => :through relation' do - it "should find the only record related to @bar_3" do - Foo.search_for('last').should have(1).items - end + before(:all) do - it "should find all records that are related to @bar_2" do - Foo.search_for('other').should have(2).items - end - end + # Create some tables + ActiveRecord::Migration.create_table(:bars) { |t| t.integer :foo_id; t.integer :baz_id } + ActiveRecord::Migration.create_table(:bazs) { |t| t.string :related } + ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo } - context 'querying a :has_many => :through relation' do + # The related classes + class Bar < ActiveRecord::Base; belongs_to :baz; belongs_to :foo; end + class Baz < ActiveRecord::Base; has_many :bars; end - before(:all) do + # The class on which to call search_for + class Foo < ActiveRecord::Base + has_many :bars + has_many :bazs, :through => :bars - # Create some tables - ActiveRecord::Migration.create_table(:bars) { |t| t.integer :foo_id; t.integer :baz_id } - ActiveRecord::Migration.create_table(:bazs) { |t| t.string :related } - ActiveRecord::Migration.create_table(:foos) { |t| t.string :foo } + scoped_search :in => :bazs, :on => :related + end - # The related classes - class Bar < ActiveRecord::Base; belongs_to :baz; belongs_to :foo; end - class Baz < ActiveRecord::Base; has_many :bars; end + @foo_1 = Foo.create!(:foo => 'foo') + @foo_2 = Foo.create!(:foo => 'foo too') + @foo_3 = Foo.create!(:foo => 'foo three') - # The class on which to call search_for - class Foo < ActiveRecord::Base - has_many :bars - has_many :bazs, :through => :bars + @baz_1 = Baz.create(:related => 'baz') + @baz_2 = Baz.create(:related => 'baz too!') - scoped_search :in => :bazs, :on => :related + @bar_1 = Bar.create!(:foo => @foo_1, :baz => @baz_1) + @bar_2 = Bar.create!(:foo => @foo_1) + @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_1) + @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_2) + @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_2) + @bar_4 = Bar.create!(:foo => @foo_3) end - @foo_1 = Foo.create!(:foo => 'foo') - @foo_2 = Foo.create!(:foo => 'foo too') - @foo_3 = Foo.create!(:foo => 'foo three') - - @baz_1 = Baz.create(:related => 'baz') - @baz_2 = Baz.create(:related => 'baz too!') - - @bar_1 = Bar.create!(:foo => @foo_1, :baz => @baz_1) - @bar_2 = Bar.create!(:foo => @foo_1) - @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_1) - @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_2) - @bar_3 = Bar.create!(:foo => @foo_2, :baz => @baz_2) - @bar_4 = Bar.create!(:foo => @foo_3) - end - - after(:all) do - ActiveRecord::Migration.drop_table(:bazs) - ActiveRecord::Migration.drop_table(:bars) - ActiveRecord::Migration.drop_table(:foos) - Object.send :remove_const, :Foo - Object.send :remove_const, :Bar - Object.send :remove_const, :Baz - end + after(:all) do + ActiveRecord::Migration.drop_table(:bazs) + ActiveRecord::Migration.drop_table(:bars) + ActiveRecord::Migration.drop_table(:foos) + Object.send :remove_const, :Foo + Object.send :remove_const, :Bar + Object.send :remove_const, :Baz + end - it "should find the two records that are related to a baz record" do - Foo.search_for('baz').should have(2).items + it "should find the two records that are related to a baz record" do + Foo.search_for('baz').should have(2).items + end end end - end spec/integration/relation_querying_spec.rb @@ -1,187 +1,192 @@ require "#{File.dirname(__FILE__)}/../spec_helper" -describe ScopedSearch, :search_for do - - before(:all) do - ScopedSearch::Spec::Database.establish_connection - @class = ScopedSearch::Spec::Database.create_model(:string => :string, :another => :string, :explicit => :string) do |klass| - klass.scoped_search :on => :string - klass.scoped_search :on => :another, :default_operator => :eq, :alias => :alias - klass.scoped_search :on => :explicit, :only_explicit => true - end +# 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::Spec::Database.test_databases.each do |db| - @class.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz') - @class.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz') - @class.create!(:string => 'baz', :another => 'temp 3', :explicit => nil) - end + describe ScopedSearch, "using a #{db} database" do - after(:all) do - ScopedSearch::Spec::Database.drop_model(@class) - ScopedSearch::Spec::Database.close_connection - end + before(:all) do + ScopedSearch::Spec::Database.establish_named_connection(db) + + @class = ScopedSearch::Spec::Database.create_model(:string => :string, :another => :string, :explicit => :string) do |klass| + klass.scoped_search :on => :string + klass.scoped_search :on => :another, :default_operator => :eq, :alias => :alias + klass.scoped_search :on => :explicit, :only_explicit => true + end - context 'in an implicit string field' do - it "should find the record with an exact string match" do - @class.search_for('foo').should have(1).item + @class.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz') + @class.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz') + @class.create!(:string => 'baz', :another => 'temp 3', :explicit => nil) end - it "should find the opther two records using NOT with an exact string match" do - @class.search_for('-foo').should have(2).item + after(:all) do + ScopedSearch::Spec::Database.drop_model(@class) + ScopedSearch::Spec::Database.close_connection end - it "should find the record with an exact string match and an explicit field operator" do - @class.search_for('string = foo').should have(1).item - end + context 'in an implicit string field' do + it "should find the record with an exact string match" do + @class.search_for('foo').should have(1).item + end - it "should find the record with an exact string match and an explicit field operator" do - @class.search_for('another = foo').should have(0).items - end + it "should find the opther two records using NOT with an exact string match" do + @class.search_for('-foo').should have(2).item + end - it "should find the record with an partial string match" do - @class.search_for('fo').should have(1).item - end + it "should find the record with an exact string match and an explicit field operator" do + @class.search_for('string = foo').should have(1).item + end - it "should find the other two records using NOT with an partial string match" do - @class.search_for('-fo').should have(2).item - end + it "should find the record with an exact string match and an explicit field operator" do + @class.search_for('another = foo').should have(0).items + end - it "should not find the record with an explicit equals operator and a partial match" do - @class.search_for('= fo').should have(0).items - end + it "should find the record with an partial string match" do + @class.search_for('fo').should have(1).item + end - it "should find the record with an explicit LIKE operator and a partial match" do - @class.search_for('~ fo').should have(1).items - end + it "should find the other two records using NOT with an partial string match" do + @class.search_for('-fo').should have(2).item + end - it "should find the all other record with an explicit NOT LIKE operator and a partial match" do - @class.search_for('string !~ fo').should have(@class.count - 1).items - end + it "should not find the record with an explicit equals operator and a partial match" do + @class.search_for('= fo').should have(0).items + end - it "should not find a record with a non-match" do - @class.search_for('nonsense').should have(0).items - end + it "should find the record with an explicit LIKE operator and a partial match" do + @class.search_for('~ fo').should have(1).items + end - it "should find two records if it partially matches them" do - @class.search_for('ba').should have(2).item - end + it "should find the all other record with an explicit NOT LIKE operator and a partial match" do + @class.search_for('string !~ fo').should have(@class.count - 1).items + end - it "should find no records starting with an a" do - @class.search_for('a%').should have(0).item - end + it "should not find a record with a non-match" do + @class.search_for('nonsense').should have(0).items + end - it "should find one records ending with an oo" do - @class.search_for('%oo').should have(1).item - end + it "should find two records if it partially matches them" do + @class.search_for('ba').should have(2).item + end - it "should find records without case sensitivity when using the LIKE operator" do - @class.search_for('string ~ FOO').should have(1).item - end + it "should find no records starting with an a" do + @class.search_for('a%').should have(0).item + end - it "should not find records without case sensitivity when using the = operator" do - @class.search_for('string = FOO').should have(0).items - end + it "should find one records ending with an oo" do + @class.search_for('%oo').should have(1).item + end - it "should find records without case sensitivity when using the != operator" do - @class.search_for('string != FOO').should have(3).items - end + it "should find records without case sensitivity when using the LIKE operator" do + @class.search_for('string ~ FOO').should have(1).item + end - it "should find records without case sensitivity when using the NOT LIKE operator" do - @class.search_for('string !~ FOO').should have(2).items - end + it "should not find records without case sensitivity when using the = operator" do + @class.search_for('string = FOO').should have(0).items + end - it "should find the record if one of the query words match using OR" do - @class.search_for('foo OR nonsense').should have(1).item - end + it "should find records without case sensitivity when using the != operator" do + @class.search_for('string != FOO').should have(3).items + end - it "should find no records in one of the AND conditions isn't met" do - @class.search_for('foo AND nonsense').should have(0).item - end + it "should find records without case sensitivity when using the NOT LIKE operator" do + @class.search_for('string !~ FOO').should have(2).items + end - it "should find two records every single OR conditions matches one single record" do - @class.search_for('foo OR baz').should have(2).item - end + it "should find the record if one of the query words match using OR" do + @class.search_for('foo OR nonsense').should have(1).item + end - it "should find two records every single AND conditions matches one single record" do - @class.search_for('foo AND baz').should have(0).item - end - end + it "should find no records in one of the AND conditions isn't met" do + @class.search_for('foo AND nonsense').should have(0).item + end - context 'in a field with a different default operator' do - it "should find an exact match" do - @class.search_for('"temp 1"').should have(1).item - end + it "should find two records every single OR conditions matches one single record" do + @class.search_for('foo OR baz').should have(2).item + end - it "should find the orther records using NOT and an exact match" do - @class.search_for('-"temp 1"').should have(2).item + it "should find two records every single AND conditions matches one single record" do + @class.search_for('foo AND baz').should have(0).item + end end - it "should find an explicit match" do - @class.search_for('another = "temp 1"').should have(1).item - end + context 'in a field with a different default operator' do + it "should find an exact match" do + @class.search_for('"temp 1"').should have(1).item + end - it "should not find a partial match" do - @class.search_for('temp').should have(0).item - end + it "should find the orther records using NOT and an exact match" do + @class.search_for('-"temp 1"').should have(2).item + end - it "should find all records using a NOT with a partial match on all records" do - @class.search_for('-temp"').should have(3).item - end + it "should find an explicit match" do + @class.search_for('another = "temp 1"').should have(1).item + end - it "should find a partial match when the like operator is given" do - @class.search_for('~ temp').should have(3).item - end + it "should not find a partial match" do + @class.search_for('temp').should have(0).item + end + + it "should find all records using a NOT with a partial match on all records" do + @class.search_for('-temp"').should have(3).item + end - it "should find a partial match when the like operator and the field name is given" do - @class.search_for('another ~ temp').should have(3).item + it "should find a partial match when the like operator is given" do + @class.search_for('~ temp').should have(3).item + end + + it "should find a partial match when the like operator and the field name is given" do + @class.search_for('another ~ temp').should have(3).item + end end - end - context 'using an aliased field' do - it "should find an explicit match using its alias" do - @class.search_for('alias = "temp 1"').should have(1).item + context 'using an aliased field' do + it "should find an explicit match using its alias" do + @class.search_for('alias = "temp 1"').should have(1).item + end end - end - context 'in an explicit string field' do + context 'in an explicit string field' do - it "should not find the records if the explicit field is not given in the query" do - @class.search_for('= baz').should have(1).item - end + it "should not find the records if the explicit field is not given in the query" do + @class.search_for('= baz').should have(1).item + end - it "should find all records when searching on the explicit field" do - @class.search_for('explicit = baz').should have(2).items - end + it "should find all records when searching on the explicit field" do + @class.search_for('explicit = baz').should have(2).items + end - it "should find no records if the value in the explicit field is not an exact match" do - @class.search_for('explicit = ba').should have(0).item - end + it "should find no records if the value in the explicit field is not an exact match" do + @class.search_for('explicit = ba').should have(0).item + end - it "should find all records when searching on the explicit field" do - @class.search_for('explicit ~ ba').should have(2).items - end + it "should find all records when searching on the explicit field" do + @class.search_for('explicit ~ ba').should have(2).items + end - it "should only find the record with string = foo and explicit = baz" do - @class.search_for('foo, explicit = baz').should have(1).item + it "should only find the record with string = foo and explicit = baz" do + @class.search_for('foo, explicit = baz').should have(1).item + end end - end - context 'using null? and set? queries' do + context 'using null? and set? queries' do - it "should return all records if the string field is being checked with set?" do - @class.search_for('set? string').should have(3).items - end + it "should return all records if the string field is being checked with set?" do + @class.search_for('set? string').should have(3).items + end - it "should return no records if the string field is being checked with null?" do - @class.search_for('null? string').should have(0).items - end + it "should return no records if the string field is being checked with null?" do + @class.search_for('null? string').should have(0).items + end - it "should return all records with a value if the string field is being checked with set?" do - @class.search_for('set? explicit').should have(2).items - end + it "should return all records with a value if the string field is being checked with set?" do + @class.search_for('set? explicit').should have(2).items + end - it "should return all records without a value if the string field is being checked with null?" do - @class.search_for('null? explicit').should have(1).items + it "should return all records without a value if the string field is being checked with null?" do + @class.search_for('null? explicit').should have(1).items + end end - end end spec/integration/string_querying_spec.rb @@ -10,6 +10,11 @@ module ScopedSearch::Spec::Database end end + def self.test_databases + @database_connections ||= YAML.load(File.read("#{File.dirname(__FILE__)}/../database.yml")) + @database_connections.keys + end + def self.establish_named_connection(name) @database_connections ||= YAML.load(File.read("#{File.dirname(__FILE__)}/../database.yml")) raise "#{name} database not configured" if @database_connections[name.to_s].nil? spec/lib/database.rb @@ -1,12 +1,10 @@ -$:.reject! { |e| e.include? 'TextMate' } -$: << File.join(File.dirname(__FILE__), '..', 'lib') +$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) require 'rubygems' require 'spec' require 'active_record' require 'scoped_search' -require 'scoped_search/query_language' module ScopedSearch::Spec; end spec/spec_helper.rb @@ -4,6 +4,7 @@ describe ScopedSearch::QueryBuilder do before(:each) do @definition = mock('ScopedSearch::Definition') + @definition.stub!(:klass).and_return(Class.new(ActiveRecord::Base)) end it "should return empty conditions if the search query is nil" do @@ -15,7 +16,7 @@ describe ScopedSearch::QueryBuilder do end it "should return empty conditions if the query is whitespace only" do - ScopedSearch::QueryBuilder.build_query(@definition, "\t ").should == { } + ScopedSearch::QueryBuilder.build_query(@definition, "\t ").should == { } end end spec/unit/query_builder_spec.rb lib/scoped_search/adapters.rb tasks/database_tests.rake 63d403df3ae3d34931f3889b4b94c50c61992584 Willem van Bergen willem@vanbergen.org http://github.com/wvanbergen/scoped_search/commit/07bbb16b75ee854d06fae3f39ae338223f84b0f4 07bbb16b75ee854d06fae3f39ae338223f84b0f4 2009-10-01T21:35:11-07:00 2009-10-01T21:35:11-07:00 Switched from using module inclusion to adapter classes to tailor scoped search's query builder towards the different DBMSs. Fixed the test suite to run the integration specs on all the databases defined in the spec/database.yml configuration file. 4eebfa058f40ffa233afa7ec9c7a1557f74d3a1e Willem van Bergen willem@vanbergen.org