wvanbergen-scoped_search 1.2.0 → 2.0.0

data/tasks/database_tests.rake

@@ -1,10 +1,10 @@
 require 'yaml' unless Object::const_defined?('YAML')
 
-namespace :test do
+namespace :spec do
   
-  databases = YAML.load(File.read(File.dirname(__FILE__) + '/../test/database.yml'))  
+  databases = YAML.load(File.read(File.dirname(__FILE__) + '/../spec/database.yml'))  
   
-  desc "Run testsuite on all configured databases in test/database.yml"
+  desc "Run testsuite on all configured databases in spec/database.yml"
   task(:all => databases.keys.map { |db| db.to_sym }) do
     puts "\nFinished testing on all configured databases!"
     puts "(Configure databases by adjusting test/database.yml)"
@@ -13,8 +13,8 @@ namespace :test do
   databases.each do |database, config|
     desc "Run testsuite on #{database} database."
     task database.to_sym do
-      puts "Running testsuite on #{database} database...\n\n"
-      sh "rake test DATABASE=#{database}"
+      puts "Running specs for #{database} database...\n\n"
+      sh "rake spec DATABASE=#{database}"
     end
   end  
 end

data/tasks/github-gem.rake

@@ -97,7 +97,7 @@ module Rake
     protected 
 
     def has_rdoc?
-      @specification.has_rdoc
+      branch_exist?('gh-pages')
     end
 
     def has_specs?
@@ -168,6 +168,11 @@ module Rake
       run_command('git branch').detect { |line| /^\* (.+)/ =~ line }
       raise "You are currently not working in the master branch!" unless branch == $1
     end
+
+    def branch_exist?(branch)
+      run_command('git branch').any? { |line| line.split(' ').last == branch }
+    end
+
     
     def verify_clean_status(on_branch = nil)
       sh "git fetch"
@@ -232,10 +237,10 @@ module Rake
     
     def create_version_tag!
       # commit the gemspec file
-      git_commit_file(gemspec_file, "Released #{@name} version #{@specification.version}") if git_modified?(gemspec_file)
+      git_commit_file(gemspec_file, "Updated #{gemspec_file} for release of version #{@specification.version}") if git_modified?(gemspec_file)
 
       # create tag and push changes
-      git_create_tag("#{@name}-#{@specification.version}", "Tagged #{@name} version #{@specification.version}")
+      git_create_tag("#{@name}-#{@specification.version}", "Tagged version #{@specification.version}")
       git_push('origin', 'master', [:tags])     
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wvanbergen-scoped_search
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-18 00:00:00 -07:00
+date: 2009-08-26 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -32,27 +32,38 @@ files:
 - lib
 - lib/scoped_search
 - lib/scoped_search.rb
-- lib/scoped_search/query_conditions_builder.rb
-- lib/scoped_search/query_language_parser.rb
-- lib/scoped_search/reg_tokens.rb
+- lib/scoped_search/adapters.rb
+- lib/scoped_search/definition.rb
+- lib/scoped_search/query_builder.rb
+- lib/scoped_search/query_language
+- lib/scoped_search/query_language.rb
+- lib/scoped_search/query_language/ast.rb
+- lib/scoped_search/query_language/parser.rb
+- lib/scoped_search/query_language/tokenizer.rb
+- spec
+- spec/database.yml
+- spec/integration
+- spec/integration/api_spec.rb
+- spec/integration/ordinal_querying_spec.rb
+- spec/integration/relation_querying_spec.rb
+- spec/integration/string_querying_spec.rb
+- spec/lib
+- spec/lib/database.rb
+- spec/lib/matchers.rb
+- spec/lib/mocks.rb
+- spec/spec_helper.rb
+- spec/unit
+- spec/unit/ast_spec.rb
+- spec/unit/definition_spec.rb
+- spec/unit/parser_spec.rb
+- spec/unit/query_builder_spec.rb
+- spec/unit/tokenizer_spec.rb
 - tasks
 - tasks/database_tests.rake
-- tasks/documentation.rake
 - tasks/github-gem.rake
-- test
-- test/database.yml
-- test/integration
-- test/integration/api_test.rb
-- test/lib
-- test/lib/test_models.rb
-- test/lib/test_schema.rb
-- test/test_helper.rb
-- test/unit
-- test/unit/query_conditions_builder_test.rb
-- test/unit/query_language_test.rb
-- test/unit/search_for_test.rb
 has_rdoc: true
 homepage: http://wiki.github.com/wvanbergen/scoped_search
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --title
@@ -78,12 +89,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: A Rails plugin to search your models using a named_scope
 test_files: 
-- test/integration/api_test.rb
-- test/unit/query_conditions_builder_test.rb
-- test/unit/query_language_test.rb
-- test/unit/search_for_test.rb
+- spec/integration/api_spec.rb
+- spec/integration/ordinal_querying_spec.rb
+- spec/integration/relation_querying_spec.rb
+- spec/integration/string_querying_spec.rb
+- spec/unit/ast_spec.rb
+- spec/unit/definition_spec.rb
+- spec/unit/parser_spec.rb
+- spec/unit/query_builder_spec.rb
+- spec/unit/tokenizer_spec.rb

data/lib/scoped_search/query_conditions_builder.rb

@@ -1,209 +0,0 @@
-module ScopedSearch
-  
-  class QueryConditionsBuilder
-
-    # Builds the query string by calling the build method on a new instances of QueryConditionsBuilder.
-    def self.build_query(search_conditions, query_fields)
-      self.new.build(search_conditions, query_fields)
-    end
-
-    # Initializes the default class variables.
-    def initialize
-      @query_fields = nil 
-      @query_params = {}
-      
-      @sql_like = 'LIKE'
-      
-      if ActiveRecord::Base.connected? and ActiveRecord::Base.connection.adapter_name.downcase == 'postgresql'
-        @sql_like = 'ILIKE'
-      end
-    end 
-
-
-    # Build the query based on the search conditions and the fields to query.
-    # 
-    # Hash query_options : A hash of fields and field types.
-    #
-    # Example: 
-    #
-    #   search_conditions = [["Wes", :like], ["Hays", :not], ["Hello World", :like], ["Goodnight Moon", :not], 
-    #                       ["Bob OR Wes", :or], ["Happy cow OR Sad Frog", :or], ["Man made OR Dogs", :or], 
-    #                       ["Cows OR Frog Toys", :or], ['9/28/1980, :datetime]]
-    #   query_fields = {:first_name => :string, :created_at => :datetime}
-    #
-    # Exceptons : 
-    #   1) If search_conditions is not an array
-    #   2) If query_fields is not a Hash    
-    def build(search_conditions, query_fields) 
-      raise 'search_conditions must be a hash' unless search_conditions.class.to_s == 'Array'
-      raise 'query_fields must be a hash' unless query_fields.class.to_s == 'Hash'
-      @query_fields = query_fields
-
-      conditions = []
- 
-      search_conditions.each_with_index do |search_condition, index|
-        keyword_name = "keyword_#{index}".to_sym
-        conditions << case search_condition.last
-                        # :like also handles integers
-                        when :like then like_condition(keyword_name, search_condition.first)
-                        when :not then not_like_condition(keyword_name, search_condition.first)
-            
-                        when :or then or_condition(keyword_name, search_condition.first)
-      
-                        when :less_than_date then less_than_date(keyword_name, search_condition.first)      
-                        when :less_than_or_equal_to_date then less_than_or_equal_to_date(keyword_name, search_condition.first)   
-                        when :as_of_date then as_of_date(keyword_name, search_condition.first)      
-                        when :greater_than_date then greater_than_date(keyword_name, search_condition.first) 
-                        when :greater_than_or_equal_to_date then greater_than_or_equal_to_date(keyword_name, search_condition.first)   
-                        
-                        when :between_dates then between_dates(keyword_name, search_condition.first)                                                        
-                      end          
-      end
-
-      [conditions.compact.join(' AND '), @query_params] 
-    end    
-    
-    
-    private 
-    
-    def like_condition(keyword_name, value)      
-      retVal = []
-      @query_fields.each do |field, field_type|  #|key,value| 
-        if field_type == :string or field_type == :text
-          @query_params[keyword_name] = "%#{value}%"
-          retVal << "#{field} #{@sql_like} :#{keyword_name.to_s}"
-        end
-        if value.strip =~ /^[0-9]+$/ and (field_type == :int or field_type == :integer)
-          qkey = "#{keyword_name}_#{value.strip}"
-          @query_params[qkey.to_sym] = value.strip.to_i
-          retVal << "#{field} = :#{qkey}"
-        end
-      end
-      "(#{retVal.join(' OR ')})"
-    end
-    
-    def not_like_condition(keyword_name, value)
-      @query_params[keyword_name] = "%#{value}%"
-      retVal = []
-      @query_fields.each do |field, field_type|  #|key,value| 
-        if field_type == :string or field_type == :text
-          retVal << "(#{field} NOT #{@sql_like} :#{keyword_name.to_s} OR #{field} IS NULL)"
-        end
-      end
-      "(#{retVal.join(' AND ')})"
-    end
-    
-    def or_condition(keyword_name, value)
-      retVal = []
-      word1, word2 = value.split(' OR ')
-      keyword_name_a = "#{keyword_name.to_s}a".to_sym
-      keyword_name_b = "#{keyword_name.to_s}b".to_sym
-      @query_params[keyword_name_a] = "%#{word1}%"
-      @query_params[keyword_name_b] = "%#{word2}%"      
-      @query_fields.each do |field, field_type|  #|key,value|       
-        if field_type == :string or field_type == :text
-          retVal << "(#{field} #{@sql_like} :#{keyword_name_a.to_s} OR #{field} #{@sql_like} :#{keyword_name_b.to_s})"
-        end
-        if (word1.strip =~ /^[0-9]+$/ and word2.strip =~ /^[0-9]+$/) and (field_type == :int or field_type == :integer)
-          qkeya = "#{keyword_name}_a_#{word1.strip}"
-          qkeyb = "#{keyword_name}_b_#{word2.strip}"
-          @query_params[qkeya] = word1.strip.to_i
-          @query_params[qkeyb] = word2.strip.to_i
-          retVal << "(#{field} = :#{qkeya} OR #{field} = :#{qkeyb})"   
-        elsif (word1.strip =~ /^[0-9]+$/ or word2.strip =~ /^[0-9]+$/) and (field_type == :int or field_type == :integer)
-          num_word = word1.strip =~ /^[0-9]+$/ ? word1.strip.to_i : word2.strip.to_i
-          qkey = "#{keyword_name}_#{num_word}"
-          @query_params[qkey.to_sym] = num_word
-          retVal << "(#{field} = :#{qkey})"
-        end             
-      end 
-      "(#{retVal.join(' OR ')})"     
-    end
-    
-    def less_than_date(keyword_name, value)
-      helper_date_operation('<', keyword_name, value)     
-    end
-    
-    def less_than_or_equal_to_date(keyword_name, value)
-      helper_date_operation('<=', keyword_name, value)     
-    end    
-    
-    def as_of_date(keyword_name, value)
-      retVal = []
-      begin
-        dt = Date.parse(value) # This will throw an exception if it is not valid
-        @query_params[keyword_name] = dt.to_s
-        @query_fields.each do |field, field_type|  #|key,value| 
-          if field_type == :date or field_type == :datetime or field_type == :timestamp
-            retVal << "#{field} = :#{keyword_name.to_s}"
-          end
-        end
-      rescue
-        # do not search on any date columns since the date is invalid
-        retVal = [] # Reset just in case
-      end
-      
-      # Search the text fields for the date as well as it could be in text.
-      # Also still search on the text columns for an invalid date as it could
-      # have a different meaning.
-      found_text_fields_to_search = false
-      keyword_name_b = "#{keyword_name}b".to_sym      
-      @query_fields.each do |field, field_type|  #|key,value| 
-        if field_type == :string or field_type == :text
-          found_text_fields_to_search = true
-          retVal << "#{field} #{@sql_like} :#{keyword_name_b.to_s}"
-        end
-      end
-      if found_text_fields_to_search
-        @query_params[keyword_name_b] = "%#{value}%"
-      end
-
-      retVal.empty? ? '' : "(#{retVal.join(' OR ')})"      
-    end
-    
-    def greater_than_date(keyword_name, value)
-      helper_date_operation('>', keyword_name, value)
-    end
-    
-    def greater_than_or_equal_to_date(keyword_name, value)
-      helper_date_operation('>=', keyword_name, value)
-    end    
-    
-    def between_dates(keyword_name, value)
-      date1, date2 = value.split(' TO ')      
-      dt1 = Date.parse(date1) # This will throw an exception if it is not valid
-      dt2 = Date.parse(date2) # This will throw an exception if it is not valid
-      keyword_name_a = "#{keyword_name.to_s}a".to_sym
-      keyword_name_b = "#{keyword_name.to_s}b".to_sym 
-      @query_params[keyword_name_a] = dt1.to_s
-      @query_params[keyword_name_b] = dt2.to_s           
-
-      retVal = []
-      @query_fields.each do |field, field_type|  #|key,value| 
-        if field_type == :date or field_type == :datetime or field_type == :timestamp
-          retVal << "(#{field} BETWEEN :#{keyword_name_a.to_s} AND :#{keyword_name_b.to_s})"
-        end
-      end
-      "(#{retVal.join(' OR ')})"  
-    rescue
-      # The date is not valid so just ignore it
-      return nil      
-    end  
-    
-
-    def helper_date_operation(operator, keyword_name, value)
-      dt = Date.parse(value) # This will throw an exception if it is not valid
-      @query_params[keyword_name] = dt.to_s
-      retVal = []
-      @query_fields.each do |field, field_type|  #|key,value| 
-        if field_type == :date or field_type == :datetime or field_type == :timestamp
-          retVal << "#{field} #{operator} :#{keyword_name.to_s}"
-        end
-      end
-      "(#{retVal.join(' OR ')})"  
-    rescue
-      # The date is not valid so just ignore it
-      return nil      
-    end
-  end
-end

data/lib/scoped_search/query_language_parser.rb

@@ -1,117 +0,0 @@
-module ScopedSearch
-  
-  # Used to parse and build the conditions tree for the search.
-  class QueryLanguageParser
-    
-    # Parses the query string by calling the parse_query method on a new instances of QueryLanguageParser.
-    #
-    # query:: The query string to parse.  If nil the all values will be returned (default is nil)
-    #         If the query string is longer then 300 characters then it will be truncated to a 
-    #         length of 300.
-    def self.parse(query)
-      self.new.parse_query(query)
-    end    
-    
-    # Parse the query string.
-    #
-    # query:: The query string to parse.  If nil the all values will be returned (default is nil)
-    #         If the query string is longer then 300 characters then it will be truncated to a 
-    #         length of 300.
-    def parse_query(query = nil)
-      # truncate query string at 300 characters
-      query = query[0...300] if query.length > 300
-      return build_conditions_tree(tokenize(query))
-    end
-    
-    protected
-  
-    # Build the conditions tree based on the tokens found.
-    #
-    # tokens:: An array of tokens.
-    def build_conditions_tree(tokens)
-      conditions_tree = []
-    
-      negate = false
-      tokens.each do |item|
-        case item
-          when :not
-            negate = true
-          else
-            if /^.+[ ]OR[ ].+$/ =~ item
-              conditions_tree << [item, :or]
-            elsif /^#{RegTokens::BetweenDateFormatMMDDYYYY}$/ =~ item or
-                  /^#{RegTokens::BetweenDateFormatYYYYMMDD}$/ =~ item or
-                  /^#{RegTokens::BetweenDatabaseFormat}$/ =~ item
-              conditions_tree << [item, :between_dates]              
-            elsif /^#{RegTokens::GreaterThanOrEqualToDateFormatMMDDYYYY}$/ =~ item or
-                  /^#{RegTokens::GreaterThanOrEqualToDateFormatYYYYMMDD}$/ =~ item or
-                  /^#{RegTokens::GreaterThanOrEqualToDatabaseFormat}$/ =~ item
-              conditions_tree << [item, :greater_than_or_equal_to_date] 
-            elsif /^#{RegTokens::LessThanOrEqualToDateFormatMMDDYYYY}$/ =~ item or
-                  /^#{RegTokens::LessThanOrEqualToDateFormatYYYYMMDD}$/ =~ item or
-                  /^#{RegTokens::LessThanOrEqualToDatabaseFormat}$/ =~ item
-              conditions_tree << [item, :less_than_or_equal_to_date]              
-            elsif /^#{RegTokens::GreaterThanDateFormatMMDDYYYY}$/ =~ item or
-                  /^#{RegTokens::GreaterThanDateFormatYYYYMMDD}$/ =~ item or
-                  /^#{RegTokens::GreaterThanDatabaseFormat}$/ =~ item
-              conditions_tree << [item, :greater_than_date] 
-            elsif /^#{RegTokens::LessThanDateFormatMMDDYYYY}$/ =~ item or
-                  /^#{RegTokens::LessThanDateFormatYYYYMMDD}$/ =~ item or
-                  /^#{RegTokens::LessThanDatabaseFormat}$/ =~ item
-              conditions_tree << [item, :less_than_date]                           
-            elsif /^#{RegTokens::DateFormatMMDDYYYY}$/ =~ item or
-                  /^#{RegTokens::DateFormatYYYYMMDD}$/ =~ item or
-                  /^#{RegTokens::DatabaseFormat}$/ =~ item
-              conditions_tree << [item, :as_of_date]
-            else
-              conditions_tree << (negate ? [item, :not] : [item, :like])
-              negate = false
-            end
-        end
-      end
-
-      return conditions_tree
-    end
-    
-    # Tokenize the query based on the different RegTokens.
-    def tokenize(query)
-      pattern = [RegTokens::BetweenDateFormatMMDDYYYY,
-                 RegTokens::BetweenDateFormatYYYYMMDD,
-                 RegTokens::BetweenDatabaseFormat,
-                 RegTokens::GreaterThanOrEqualToDateFormatMMDDYYYY,
-                 RegTokens::GreaterThanOrEqualToDateFormatYYYYMMDD,
-                 RegTokens::GreaterThanOrEqualToDatabaseFormat,
-                 RegTokens::LessThanOrEqualToDateFormatMMDDYYYY,
-                 RegTokens::LessThanOrEqualToDateFormatYYYYMMDD,
-                 RegTokens::LessThanOrEqualToDatabaseFormat,
-                 RegTokens::GreaterThanDateFormatMMDDYYYY,
-                 RegTokens::GreaterThanDateFormatYYYYMMDD,
-                 RegTokens::GreaterThanDatabaseFormat,
-                 RegTokens::LessThanDateFormatMMDDYYYY,
-                 RegTokens::LessThanDateFormatYYYYMMDD,
-                 RegTokens::LessThanDatabaseFormat,
-                 RegTokens::DateFormatMMDDYYYY,
-                 RegTokens::DateFormatYYYYMMDD,
-                 RegTokens::DatabaseFormat,           
-                 RegTokens::WordOrWord,
-                 RegTokens::WordOrString,
-                 RegTokens::StringOrWord,
-                 RegTokens::StringOrString,
-                 RegTokens::PossiblyNegatedWord,
-                 RegTokens::PossiblyNegatedString]               
-      pattern = Regexp.new(pattern.join('|'))
-      
-      tokens = []
-      matches = query.scan(pattern).flatten.compact
-      matches.each { |match|
-        tokens << :not if match.index('-') == 0
-        # Remove any escaped quotes
-        # Remove any dashes preceded by a space or at the beginning of a token
-        # Remove any additional spaces - more that one.
-        cleaned_token = match.gsub(/"/,'').gsub(/^-| -/,'').gsub(/[ ]{2,}/, ' ')
-        tokens << cleaned_token if cleaned_token.length > 0
-      }
-      return tokens
-    end
-  end
-end