jnewland-scoped_search 0.7.1

data/CHANGELOG

@@ -0,0 +1,12 @@
+scoped_search 0.3.0
+===================
+- Detection of column types so they can be handled properly
+- Date based queries supported on date and time fields
+
+scoped_search 0.2.0
+===================
+- OR keyword supported in query language
+
+scoped_search 0.1.0
+===================
+- Initial version

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Willem van Bergen
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,76 @@
+h1. "scoped_search":http://github.com/wvanbergen/scoped_search/tree/master
+
+This simple plugin will make it easy to search your ActiveRecord models. Searching is performed using a query string, which should be passed to the named_scope <tt>search_for</tt> that uses SQL %LIKE% conditions for searching (ILIKE for Postgres). You can specify what fields should be used for searching.
+
+* "scoped_search installation":#INSTALLATION
+* "scoped_search usage":#USAGE
+* "scoped_search license":#LICENSE
+
+<a id="INSTALLATION"/> </a>
+h2. Installing scoped_search
+
+<pre><code>
+gem install wvanbergen-scoped_search
+
+</code></pre>
+
+<a id="USAGE"/> </a>
+h2. Usage
+
+First, you have to specify in what columns should be searched:
+
+<pre><code>
+class User < ActiveRecord::Base
+  searchable_on :first_name, :last_name
+end
+
+</code></pre>
+
+Now, the *search_for* scope is available for queries. You should pass a query string to the scope. 
+This can be empty or nil, in which case all no search conditions are set (and all records will be returned).
+
+<pre><code>
+User.search_for(params[:q]).each { |project| ... }
+
+</code></pre>
+
+You can also search on associate models.  This works with *belongs_to*, *has_one*, *has_many*, 
+*has_many :through*, and *HABTM*.  For example if a User *has_many* Notes (title, content, created_at, updated_at)
+
+<pre><code>
+class User < ActiveRecord::Base
+  has_many: notes
+  searchable_on :first_name, :last_name, :notes_title, :notes_content
+end
+
+</code></pre>
+
+The search query language is simple. It supports these constructs:
+* words: some search keywords
+* phrases: "a single search phrase"
+* negation: "look for this" -"but do not look for this phrase and this" -word
+* OR words/phrases: word/phrase OR word/phrase.  Example: "Hello World" OR "Hello Moon"
+* dates: mm/dd/yyyy, dd/mm/yyyy, yyyy/mm/dd, yyyy-mm-dd
+* date ranges: > date, >= date, < date, <= date, date TO date.  Examples: > mm/dd/yyyy, < yyyy-mm-dd
+
+This functionality is build on named_scope. The searchable_on statement creates 
+a named_scope *search_for*. Because of this, you can actually chain the call with
+other scopes. For example, this can be very useful if you only want to search in 
+projects that are accessible by a given user.
+
+<pre><code>
+class Project < ActiveRecord::Base
+  searchable_on :name, :description
+  named_scope :accessible_by, lambda { |user| ... }
+end
+  
+# using chained named_scopes and will_paginate
+Project.accessible_by(current_user).search_for(params[:q]).paginate(:page => params[:page], :include => :tasks)
+
+</code></pre>
+
+<a id="LICENSE"/> </a>
+h2. License
+
+This plugin is released under the MIT license. Please contact (willem AT vanbergen DOT org) if you have any suggestions or remarks. 
+

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rubygems'
+
+load 'test/tasks.rake'
+ 
+desc 'Default: run unit tests.'
+task :default => :test
+
+namespace :gem do
+
+  desc "Sets the version and date of the scoped_search gem. Requires the VERSION environment variable."
+  task :version => [:manifest] do
+    
+    require 'date'
+    
+    new_version = ENV['VERSION']
+    raise "VERSION is required" unless /\d+(\.\d+)*/ =~ new_version
+    
+    spec_file = Dir['*.gemspec'].first
+    
+    spec = File.read(spec_file)
+    spec.gsub!(/^(\s*s\.version\s*=\s*)('|")(.+)('|")(\s*)$/) { "#{$1}'#{new_version}'#{$5}" }
+    spec.gsub!(/^(\s*s\.date\s*=\s*)('|")(.+)('|")(\s*)$/) { "#{$1}'#{Date.today.strftime('%Y-%m-%d')}'#{$5}" }    
+    File.open(spec_file, 'w') { |f| f << spec }
+  end
+  
+  task :tag => [:version] do
+    
+    new_version = ENV['VERSION']
+    raise "VERSION is required" unless /\d+(\.\d+)*/ =~ new_version
+        
+    sh "git add scoped_search.gemspec .manifest"
+    sh "git commit -m \"Set gem version to #{new_version}\""
+    sh "git push origin"    
+    sh "git tag -a \"scoped_search-#{new_version}\" -m \"Tagged version #{new_version}\""
+    sh "git push --tags"
+  end
+
+  desc "Builds a ruby gem for scoped_search"
+  task :build => [:manifest] do
+    system %[gem build scoped_search.gemspec]
+  end
+
+  desc %{Update ".manifest" with the latest list of project filenames. Respect\
+  .gitignore by excluding everything that git ignores. Update `files` and\
+  `test_files` arrays in "*.gemspec" file if it's present.}
+  task :manifest do
+    list = Dir['**/*'].sort
+    spec_file = Dir['*.gemspec'].first
+    list -= [spec_file] if spec_file
+  
+    File.read('.gitignore').each_line do |glob|
+      glob = glob.chomp.sub(/^\//, '')
+      list -= Dir[glob]
+      list -= Dir["#{glob}/**/*"] if File.directory?(glob) and !File.symlink?(glob)
+      puts "excluding #{glob}"
+    end
+ 
+    if spec_file
+      spec = File.read spec_file
+      spec.gsub! /^(\s* s.(test_)?files \s* = \s* )( \[ [^\]]* \] | %w\( [^)]* \) )/mx do
+        assignment = $1
+        bunch = $2 ? list.grep(/^test.*_test\.rb$/) : list
+        '%s%%w(%s)' % [assignment, bunch.join(' ')]
+      end
+      
+      File.open(spec_file,   'w') {|f| f << spec }
+    end
+    File.open('.manifest', 'w') {|f| f << list.join("\n") }
+  end
+end

data/TODO

@@ -0,0 +1,15 @@
+TODO items for named_scope
+==========================
+Contact willem AT vanbergen DOT org if you want to help out
+
+0.8.0
+
+
+0.9.0
+
+
+1.0.0
+- Extensive testing
+
+Documentation & testing:
+- Add rdoc en comments to code

data/init.rb

@@ -0,0 +1 @@
+require 'scoped_search'

data/lib/scoped_search.rb

@@ -0,0 +1,78 @@
+module ScopedSearch
+  
+  module ClassMethods
+  
+    def self.extended(base)
+      require 'scoped_search/reg_tokens'
+      require 'scoped_search/query_language_parser'
+      require 'scoped_search/query_conditions_builder'
+    end
+  
+    # Creates a named scope in the class it was called upon
+    def searchable_on(*fields)      
+      if fields.first.class.to_s == 'Hash'
+        if fields.first.has_key?(:only)
+          fields = fields.first[:only]
+        elsif fields.first.has_key?(:except)
+          fields = self.column_names.collect { |column| 
+                     fields.first[:except].include?(column.to_sym) ? nil : column.to_sym }.compact
+        end
+      end
+
+      assoc_models = self.reflections.collect { |m| m[0] }
+      assoc_fields = fields - self.column_names.collect { |column| column.to_sym }
+      fields -= assoc_fields
+
+      assoc_groupings = {}
+      assoc_models.each do |assoc_model|
+        assoc_groupings[assoc_model] = []
+      	assoc_fields.each do |assoc_field|
+      	  unless assoc_field.to_s.match(/^#{assoc_model.to_s}_/).nil?
+            assoc_groupings[assoc_model] << assoc_field.to_s.sub(/^#{assoc_model.to_s}_/, '').to_sym 
+          end
+        end
+      end
+      
+      assoc_groupings = assoc_groupings.delete_if {|group, field_group| field_group.empty?}
+
+      self.cattr_accessor :scoped_search_fields, :scoped_search_assoc_groupings
+      self.scoped_search_fields = fields
+      self.scoped_search_assoc_groupings = assoc_groupings
+      self.named_scope :search_for, lambda { |keywords| self.build_scoped_search_conditions(keywords) }
+    end
+  
+    # Build a hash that is used for the named_scope search_for.
+    # This function will split the search_string into keywords, and search for all the keywords
+    # in the fields that were provided to searchable_on
+    def build_scoped_search_conditions(search_string)    
+      if search_string.nil? || search_string.strip.blank?
+        return {:conditions => nil}
+      else        
+        query_fields = {}
+        self.scoped_search_fields.each do |field| 
+          field_name = connection.quote_table_name(table_name) + "." + connection.quote_column_name(field)
+          query_fields[field_name] = self.columns_hash[field.to_s].type
+        end
+        
+        assoc_models_to_include = []
+        self.scoped_search_assoc_groupings.each do |group|
+          assoc_models_to_include << group[0]
+          group[1].each do |group_field|
+            field_name = connection.quote_table_name(group[0].to_s.pluralize) + "." + connection.quote_column_name(group_field)
+            query_fields[field_name] = self.reflections[group[0]].klass.columns_hash[group_field.to_s].type
+          end
+        end
+        
+        search_conditions = QueryLanguageParser.parse(search_string) 
+        conditions = QueryConditionsBuilder.build_query(search_conditions, query_fields) 
+        
+        retVal = {:conditions => conditions}
+        retVal[:include] = assoc_models_to_include unless assoc_models_to_include.empty?
+
+        return retVal
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, ScopedSearch::ClassMethods)

data/lib/scoped_search/query_conditions_builder.rb

@@ -0,0 +1,189 @@
+module ScopedSearch
+  
+  class QueryConditionsBuilder
+    ## ActiveRecord::Base.connection.adapter_name
+
+    # Build the query
+    def self.build_query(search_conditions, query_fields)
+      self.new.build(search_conditions, query_fields)
+    end
+
+    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
+    # 
+    # Hash query_options : A hash of fields and field types.
+    #
+    # Exampe: 
+    # 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 urlParams does not contain a :controller key.      
+    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
+                        #when :integer: integer_conditions(keyword_name, search_condition.first)
+          
+                        when :like: like_condition(keyword_name, search_condition.first)
+                        when :not: not_like_condition(keyword_name, search_condition.first)
+            
+                        when :or: or_condition(keyword_name, search_condition.first)
+      
+                        when :less_than_date: less_than_date(keyword_name, search_condition.first)      
+                        when :less_than_or_equal_to_date: less_than_or_equal_to_date(keyword_name, search_condition.first)   
+                        when :as_of_date: as_of_date(keyword_name, search_condition.first)      
+                        when :greater_than_date: greater_than_date(keyword_name, search_condition.first) 
+                        when :greater_than_or_equal_to_date: greater_than_or_equal_to_date(keyword_name, search_condition.first)   
+                        
+                        when :between_dates: between_dates(keyword_name, search_condition.first)                                                        
+                      end          
+      end
+
+      [conditions.compact.join(' AND '), @query_params] 
+    end    
+    
+    
+    private 
+    
+    # def integer_condition(keyword_name, value)
+    # end    
+    
+    def 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} #{@sql_like} :#{keyword_name.to_s}"
+        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
+      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
+      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.
+      keyword_name_b = "#{keyword_name}b".to_sym
+      @query_params[keyword_name_b] = "%#{value}%"
+      @query_fields.each do |field, field_type|  #|key,value| 
+        if field_type == :string or field_type == :text
+          retVal << "#{field} #{@sql_like} :#{keyword_name_b.to_s}"
+        end
+      end
+
+      "(#{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