search-scope 0.1.0

data/Manifest

@@ -0,0 +1,6 @@
+CHANGELOG
+init.rb
+lib/search_scope.rb
+Manifest
+Rakefile
+README

data/README

@@ -0,0 +1,102 @@
+export PATH=$PATH:/opt/local/bin:/opt/local/sbin:/opt/local/lib/postgresql83/bin
+
+
+= search_scope
+
+Rails gem for simplify searching a model by defining custom named_scopes.
+
+== Install
+
+gem install search_scope
+
+== Usage
+
+...coming soon
+
+== Tutorial
+
+#this tutorial will show you how to create a rails app and search using search_scope
+
+#create your new app
+rails search_scope_test
+cd search_scope_test
+
+#add models
+./script/generate model post title:string author_id:integer body:text
+./script/generate model author name:string code:string
+rake db:migrate
+
+#add to environment.rb  (below the other config.gem examples)
+config.gem 'search-scope', :version => '0.1.0'
+
+#install the gem (from the command line)
+rake gems:install
+
+#edit the models
+class Author < ActiveRecord::Base
+  has_many :posts
+
+  sort_search_by :name
+  search_scope :name
+  search_scope :code, :search_type => :exact_match
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author
+
+  sort_search_by  :title
+  sort_search_by  :author_name,  :label => 'Author', :order => "authors.name, title", :include => :author
+
+  search_scope :title
+  search_scope :body
+  search_scope :author_name,  lambda { |term| { :conditions => ["authors.name LIKE ?", "%#{term}%"], :include => :author } }
+
+  def description
+    "\"#{title}\" by #{author.name}"
+  end
+end
+
+#add some data (from the command line)
+./script/console
+
+joe = Author.create :name => 'Joe Schmo', :code => 'joe'
+jack = Author.create :name => 'Jack Sprat', :code => 'jack'
+
+Post.create :title => 'Hello World!!', :body => 'Just saying hi.', :author_id => joe.id
+Post.create :title => 'I am NOT Jack!', :body => 'The OTHER guy is Jack, not me.', :author_id => joe.id
+Post.create :title => 'My last name is Schmo, not Blow.', :body => 'Seriously, get it right people.', :author_id => joe.id
+Post.create :title => 'It\'s cold out.', :body => 'Can\'t wait for summer.', :author_id => joe.id
+
+Post.create :title => 'Hello World!!', :body => 'Just saying hi.', :author_id => jack.id
+Post.create :title => 'I\'m in the dog house.', :body => 'I bought my wife a gym membership for Christmas. oops.', :author_id => jack.id
+Post.create :title => 'Steak is delicious.', :body => 'No, seriously, it is. Even Joe likes it.', :author_id => jack.id
+
+
+#do some searching (from script/console)
+Author.count #=> 2
+Post.count #=> 7
+
+Author.search(:name => 'joe').size  # => 1
+Author.search(:name => 'j').size    # => 2
+Author.search(:code => 'j').size  # => 0
+Author.search(:code => 'joe').size  # => 1
+
+
+puts Post.search(:title => 'cold out').collect(&:description).join("\n")  # => "It's cold out." by Joe Schmo
+
+Post.search(:title => 'hello').size  # => 2
+Post.search(:title => 'hello', :author_name => 'joe').size  # => 1
+
+#sorting
+puts Post.search(:title => 'a', :sort_by => :title).collect(&:description).join("\n")
+puts Post.search(:title => 'a', :sort_by => :author_name).collect(&:description).join("\n")
+
+#quick_search
+puts Post.search(:quick_search => 'jack', :sort_by => :title).collect(&:description).join("\n")
+puts Post.search(:quick_search => 'jack', :sort_by => :author_name).collect(&:description).join("\n")
+
+
+
+
+
+

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('search-scope', '0.1.0') do |p|
+  p.description    = "Simplify searching a model by defining custom named_scopes."
+  p.url            = "http://rubyforge.org/projects/search-scope"
+  p.author         = "Ryan Owens"
+  p.email          = "ryan@infoether.com"
+  p.ignore_pattern = ["tmp/*", "script/*", "search_scope_notes.txt"]
+  p.runtime_dependencies = ['activerecord', '>= 2.2.2']
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/init.rb

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

data/lib/search_scope.rb

@@ -0,0 +1,159 @@
+module SearchScope
+
+  class SortScope
+    attr_reader :name, :label, :order, :include_model
+    def initialize(name, label, order, include_model)
+      @name, @label, @order, @include_model = name, label, order, include_model
+    end
+  end
+
+  def sort_search_by(name, options={})
+    options[:label] ||= name.to_s.titleize
+    options[:order] ||= name.to_s
+    raise "you must supply a Symbol for a name to new_sortable_by (#{name.inspect})" unless name.is_a? Symbol
+    return if sort_choices_hash.keys.include? name.to_s
+    #TODO put this back and get rid of the return above once I figure out how to reset the class vars when the class is reloaded
+    # raise "there is already a sortable defined for the name (#{name.inspect}" if sort_choices_hash.keys.include? name.to_s
+    sort_choices_hash[name] = SortScope.new(name, options[:label], options[:order], options[:include])
+    sort_choices << sort_choices_hash[name]
+  end
+  
+  def search_scope(name, options = {}, &block)
+    puts "***search_scope: #{name.inspect} - #{options.inspect}"
+    #default the search to a LIKE search if nothing is given
+    if options.blank?
+      options = lambda { |term| { :conditions => ["#{table_name}.#{name} LIKE ?", "%#{term}%"] } }
+    elsif options.is_a?(Hash) && options[:search_type]
+      case options[:search_type]
+      when :exact_match
+        options = lambda { |term| { :conditions => ["#{table_name}.#{name} = ?", term] } }
+      else
+        raise "unknown search_type for search_scope: (#{name} - #{options[:search_type]})"
+      end
+    end
+    search_scope_keys << name unless search_scope_keys.include? name
+    if options.is_a? Proc
+      quick_search_scopes << name if options.arity == 1
+    end
+    named_scope("search_#{name}".intern, options, &block)
+  end
+
+  def search_scope_keys
+    @search_scope_keys ||= []
+  end
+  
+  def sort_choices
+    @sort_choices ||= []
+  end
+
+  def sort_choices_hash
+    @sort_choices_hash ||= HashWithIndifferentAccess.new
+  end
+  
+  #for now, we'll say that by definition, if a search_scope defines a lambda with one term, then it is a quick_search_scope
+  def quick_search_scopes
+    @quick_search_scopes ||= []
+  end
+
+  def sort_search_by_options(sort_by)
+    choices_hash = sort_choices_hash[sort_by]
+    return {} unless choices_hash
+    hash = { 
+      :order    => choices_hash.order, 
+      :include  => choices_hash.include_model,
+    }
+    hash
+  end
+
+  def search_scopes(options={})
+    scopes = []
+    search_scope_keys.each do |key|
+      
+      #if the scope key isn't in the params, don't include it
+      next unless options[key]
+      # add the scope once for each term passed in (space delimited). this allows a search for 'star wars' to return only items where both terms match
+      terms = options[key].split.compact
+      terms.each do |term|
+        scopes << [key, term]
+      end
+    end
+    # scopes << [:sort_search_scope, options[:sort_by]] if options[:sort_by]
+    scopes
+  end
+  
+  def get_search_scope_from_object(object, scope, *args)
+    scope_name = "search_#{scope}".intern 
+    scope = object.send(scope_name, *args)
+  end
+  
+  #this gets all of the options from the quick_search named scopes and builds a quick_search from them
+  #the quick_search is one that matches any of the named scopes, not all of them.
+  #TODO look into better ways of doing this, and figure out the proper name.
+  def quick_search_scope_options(quick_search_terms)
+    conditions = []
+    includes = []
+    aggregate_scope = self
+    
+    quick_search_scopes.each do |scope|
+      term_conditions = []
+      terms = quick_search_terms.split.compact
+      terms.each_with_index do |term,index|
+        # quick_search_scope = self.send(scope, term)
+        quick_search_scope = get_search_scope_from_object(self, scope, term)
+        query_options = quick_search_scope.proxy_options
+        term_conditions << self.sanitize_sql_for_conditions(query_options[:conditions])
+        #only do this once, the first time
+        if query_options[:include] && index == 0
+          includes << query_options[:include] unless includes.include? query_options[:include]
+        end
+        extra_options = query_options.keys - [:conditions, :include]
+        raise "search_scope with quick_search does not support the #{extra_options.first.inspect} option at this time (#{scope.inspect})" if extra_options.first
+      end
+      conditions << term_conditions.collect{|c|"(#{c})"}.join(' OR ')     #ORing makes sure any of the terms exist somewhere in any of the fields. I think this is what we actually need, plus "relevance" (does that mean sphinx?)
+      # conditions << term_conditions.collect{|c|"(#{c})"}.join(' AND ')  #ANDing this will make it so that all the terms MUST appear in one field, eg author first and last name
+    end
+    conditions_sql = conditions.collect{|c|"(#{c})"}.join(' OR ')
+    {:conditions => conditions_sql, :include => includes}
+  end
+  
+  #this searches by chaining all of the named_scopes (search_scopes) that were included in the params
+  def search(params={})
+    paginate = params.delete :paginate
+    aggregate_scope = self
+    search_scopes(params).each do |scope|
+      if scope.is_a? Symbol
+        # aggregate_scope = aggregate_scope.send(scope)
+        aggregate_scope = get_search_scope_from_object(aggregate_scope, scope)
+      elsif scope.is_a? Array
+        # aggregate_scope = aggregate_scope.send(*scope)
+        aggregate_scope = get_search_scope_from_object(aggregate_scope, *scope)
+      else
+        raise "unsupported type for search scope: #{scope.inspect}"
+      end
+    end
+    unless params[:quick_search].blank?
+      aggregate_scope = aggregate_scope.scoped quick_search_scope_options(params[:quick_search])
+    end
+    if params[:sort_by]
+      aggregate_scope = aggregate_scope.scoped sort_search_by_options(params[:sort_by])
+    end
+    if paginate
+      aggregate_scope.paginate(:all, :page => params[:page])
+    else
+      aggregate_scope.find(:all)
+    end
+  end
+
+  #this is for use with will_paginate
+  def paginate_search(params={})
+    params[:paginate] = true
+    search params
+  end
+
+end
+
+#include into Rails when the gem is loaded
+class ActiveRecord::Base
+  extend SearchScope
+end
+

data/search-scope.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{search-scope}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ryan Owens"]
+  s.date = %q{2009-01-06}
+  s.description = %q{Simplify searching a model by defining custom named_scopes.}
+  s.email = %q{ryan@infoether.com}
+  s.extra_rdoc_files = ["CHANGELOG", "lib/search_scope.rb", "README"]
+  s.files = ["CHANGELOG", "init.rb", "lib/search_scope.rb", "Manifest", "Rakefile", "README", "search-scope.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://rubyforge.org/projects/search-scope}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Search-scope", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{search-scope}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Simplify searching a model by defining custom named_scopes.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+      s.add_runtime_dependency(%q<>=>, ["= 2.2.2"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<>=>, ["= 2.2.2"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<>=>, ["= 2.2.2"])
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: search-scope
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ryan Owens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-06 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ">="
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+    version: 
+description: Simplify searching a model by defining custom named_scopes.
+email: ryan@infoether.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- lib/search_scope.rb
+- README
+files: 
+- CHANGELOG
+- init.rb
+- lib/search_scope.rb
+- Manifest
+- Rakefile
+- README
+- search-scope.gemspec
+has_rdoc: true
+homepage: http://rubyforge.org/projects/search-scope
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Search-scope
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: search-scope
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Simplify searching a model by defining custom named_scopes.
+test_files: []
+