joost-searchlogic 2.1.5.2

data/lib/searchlogic/named_scopes/ordering.rb

@@ -0,0 +1,53 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for orderin by columns.
+    module Ordering
+      def condition?(name) # :nodoc:
+        super || order_condition?(name)
+      end
+      
+      def primary_condition_name(name) # :nodoc
+        if result = super
+          result
+        elsif order_condition?(name)
+          name.to_sym
+        else
+          nil
+        end
+      end
+      
+      def order_condition?(name) # :nodoc:
+        !order_condition_details(name).nil?
+      end
+      
+      private
+        def method_missing(name, *args, &block)
+          if name == :order
+            named_scope name, lambda { |scope_name|
+              return {} if !order_condition?(scope_name)
+              send(scope_name).proxy_options
+            }
+            send(name, *args)
+          elsif details = order_condition_details(name)
+            create_order_conditions(details[:column])
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def order_condition_details(name)
+          if name.to_s =~ /^(ascend|descend)_by_(\w+)$/
+            {:order_as => $1, :column => $2}
+          elsif name.to_s =~ /^order$/
+            {}
+          end
+        end
+        
+        def create_order_conditions(column)
+          named_scope("ascend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} ASC"})
+          named_scope("descend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} DESC"})
+        end
+    end
+  end
+end

data/lib/searchlogic/rails_helpers.rb

@@ -0,0 +1,69 @@
+module Searchlogic
+  module RailsHelpers
+    # Creates a link that alternates between acending and descending. It basically
+    # alternates between calling 2 named scopes: "ascend_by_*" and "descend_by_*"
+    #
+    # By default Searchlogic gives you these named scopes for all of your columns, but
+    # if you wanted to create your own, it will work with those too.
+    #
+    # Examples:
+    #
+    #   order @search, :by => :username
+    #   order @search, :by => :created_at, :as => "Created"
+    #
+    # This helper accepts the following options:
+    #
+    # * <tt>:by</tt> - the name of the named scope. This helper will prepend this value with "ascend_by_" and "descend_by_"
+    # * <tt>:as</tt> - the text used in the link, defaults to whatever is passed to :by
+    # * <tt>:ascend_scope</tt> - what scope to call for ascending the data, defaults to "ascend_by_:by"
+    # * <tt>:descend_scope</tt> - what scope to call for descending the data, defaults to "descend_by_:by"
+    # * <tt>:params_scope</tt> - the name of the params key to scope the order condition by, defaults to :search
+    def order(search, options = {}, html_options = {})
+      options[:params_scope] ||= :search
+      options[:as] ||= options[:by].to_s.humanize
+      options[:ascend_scope] ||= "ascend_by_#{options[:by]}"
+      options[:descend_scope] ||= "descend_by_#{options[:by]}"
+      ascending = search.order.to_s == options[:ascend_scope]
+      new_scope = ascending ? options[:descend_scope] : options[:ascend_scope]
+      selected = [options[:ascend_scope], options[:descend_scope]].include?(search.order.to_s)
+      if selected
+        css_classes = html_options[:class] ? html_options[:class].split(" ") : []
+        if ascending
+          options[:as] = "&#9650;&nbsp;#{options[:as]}"
+          css_classes << "ascending"
+        else
+          options[:as] = "&#9660;&nbsp;#{options[:as]}"
+          css_classes << "descending"
+        end
+        html_options[:class] = css_classes.join(" ")
+      end
+      link_to options[:as], url_for(options[:params_scope] => search.conditions.merge( { :order => new_scope } ) ), html_options
+    end
+
+    # Automatically makes the form method :get if a Searchlogic::Search and sets
+    # the params scope to :search
+    def form_for(*args, &block)
+      if search_obj = args.find { |arg| arg.is_a?(Searchlogic::Search) }
+        options = args.extract_options!
+        options[:html] ||= {}
+        options[:html][:method] ||= :get
+        options[:url] ||= url_for
+        args.unshift(:search) if args.first == search_obj
+        args << options
+      end
+      super
+    end
+    
+    # Automatically adds an "order" hidden field in your form to preserve how the data 
+    # is being ordered.
+    def fields_for(*args, &block)
+      if search_obj = args.find { |arg| arg.is_a?(Searchlogic::Search) }
+        args.unshift(:search) if args.first == search_obj
+        concat(content_tag("div", hidden_field_tag("#{args.first}[order]", search_obj.order)) + "\n")
+        super
+      else
+        super
+      end
+    end
+  end
+end

data/lib/searchlogic/search.rb

@@ -0,0 +1,150 @@
+module Searchlogic
+  # A class that acts like a model, creates attr_accessors for named_scopes, and then
+  # chains together everything when an "action" method is called. It basically makes
+  # implementing search forms in your application effortless:
+  #
+  #   search = User.search
+  #   search.username_like = "bjohnson"
+  #   search.all
+  #
+  # Is equivalent to:
+  #
+  #   User.search(:username_like => "bjohnson").all
+  #
+  # Is equivalent to:
+  #
+  #   User.username_like("bjohnson").all
+  class Search
+    # Responsible for adding a "search" method into your models.
+    module Implementation
+      # Additional method, gets aliases as "search" if that method
+      # is available. A lot of other libraries like to use "search"
+      # as well, so if you have a conflict like this, you can use
+      # this method directly.
+      def searchlogic(conditions = {})
+        Search.new(self, scope(:find), conditions)
+      end
+    end
+    
+    # Is an invalid condition is used this error will be raised. Ex:
+    #
+    #   User.search(:unkown => true)
+    #
+    # Where unknown is not a valid named scope for the User model.
+    class UnknownConditionError < StandardError
+      def initialize(condition)
+        msg = "The #{condition} is not a valid condition. You may only use conditions that map to a named scope"
+        super(msg)
+      end
+    end
+    
+    attr_accessor :klass, :current_scope, :conditions
+    undef :id if respond_to?(:id)
+    
+    # Creates a new search object for the given class. Ex:
+    #
+    #   Searchlogic::Search.new(User, {}, {:username_like => "bjohnson"})
+    def initialize(klass, current_scope, conditions = {})
+      self.klass = klass
+      self.current_scope = current_scope
+      self.conditions = conditions if conditions.is_a?(Hash)
+    end
+    
+    def clone
+      self.class.new(klass, current_scope.clone, conditions.clone)
+    end
+    
+    # Returns a hash of the current conditions set.
+    def conditions
+      @conditions ||= {}
+    end
+    
+    # Accepts a hash of conditions.
+    def conditions=(values)
+      values.each do |condition, value|
+        value.delete_if { |v| v.blank? } if value.is_a?(Array)
+        next if value.blank?
+        send("#{condition}=", value)
+      end
+    end
+    
+    # Delete a condition from the search. Since conditions map to named scopes,
+    # if a named scope accepts a parameter there is no way to actually delete
+    # the scope if you do not want it anymore. A nil value might be meaningful
+    # to that scope.
+    def delete(*names)
+      names.each { |name| @conditions.delete(name.to_sym) }
+      self
+    end
+    
+    private
+      def method_missing(name, *args, &block)
+        if name.to_s =~ /(\w+)=$/
+          condition = $1.to_sym
+          scope_name = normalize_scope_name($1)
+          if scope?(scope_name)
+            conditions[condition] = type_cast(args.first, cast_type(scope_name))
+          else
+            raise UnknownConditionError.new(name)
+          end
+        elsif scope?(normalize_scope_name(name))
+          if args.size > 0
+            send("#{name}=", *args)
+            self
+          else
+            conditions[name]
+          end
+        else
+          scope = conditions.inject(klass.scoped(current_scope)) do |scope, condition|
+            scope_name, value = condition
+            scope_name = normalize_scope_name(scope_name)
+            klass.send(scope_name, value) if !klass.respond_to?(scope_name)
+            arity = klass.named_scope_arity(scope_name)
+            
+            if !arity || arity == 0
+              if value == true
+                scope.send(scope_name)
+              else
+                scope
+              end
+            else
+              scope.send(scope_name, value)
+            end
+          end
+          scope.send(name, *args, &block)
+        end
+      end
+      
+      def normalize_scope_name(scope_name)
+        klass.column_names.include?(scope_name.to_s) ? "#{scope_name}_equals".to_sym : scope_name.to_sym
+      end
+      
+      def scope?(scope_name)
+        klass.scopes.key?(scope_name) || klass.condition?(scope_name)
+      end
+      
+      def cast_type(name)
+        klass.send(name, nil) if !klass.respond_to?(name) # We need to set up the named scope if it doesn't exist, so we can get a value for named_ssope_options
+        named_scope_options = klass.named_scope_options(name)
+        arity = klass.named_scope_arity(name)
+        if !arity || arity == 0
+          :boolean
+        else
+          named_scope_options.respond_to?(:searchlogic_arg_type) ? named_scope_options.searchlogic_arg_type : :string
+        end
+      end
+      
+      def type_cast(value, type)
+        case value
+        when Array
+          value.collect { |v| type_cast(v, type) }
+        else
+          # Let's leverage ActiveRecord's type casting, so that casting is consistent
+          # with the other models.
+          column_for_type_cast = ActiveRecord::ConnectionAdapters::Column.new("", nil)
+          column_for_type_cast.instance_variable_set(:@type, type)
+          column_for_type_cast.type_cast(value)
+        end
+      end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require "searchlogic"

data/searchlogic.gemspec

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{searchlogic}
+  s.version = "2.1.5.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ben Johnson of Binary Logic"]
+  s.date = %q{2009-07-12}
+  s.email = %q{bjohnson@binarylogic.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG.rdoc",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "lib/searchlogic.rb",
+     "lib/searchlogic/active_record_consistency.rb",
+     "lib/searchlogic/core_ext/object.rb",
+     "lib/searchlogic/core_ext/proc.rb",
+     "lib/searchlogic/named_scopes/alias_scope.rb",
+     "lib/searchlogic/named_scopes/associations.rb",
+     "lib/searchlogic/named_scopes/conditions.rb",
+     "lib/searchlogic/named_scopes/ordering.rb",
+     "lib/searchlogic/rails_helpers.rb",
+     "lib/searchlogic/search.rb",
+     "rails/init.rb",
+     "searchlogic.gemspec",
+     "spec/core_ext/object_spec.rb",
+     "spec/core_ext/proc_spec.rb",
+     "spec/named_scopes/alias_scope_spec.rb",
+     "spec/named_scopes/associations_spec.rb",
+     "spec/named_scopes/conditions_spec.rb",
+     "spec/named_scopes/ordering_spec.rb",
+     "spec/search_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/binarylogic/searchlogic}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{searchlogic}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Searchlogic provides common named scopes and object based searching for ActiveRecord.}
+  s.test_files = [
+    "spec/core_ext/object_spec.rb",
+     "spec/core_ext/proc_spec.rb",
+     "spec/named_scopes/alias_scope_spec.rb",
+     "spec/named_scopes/associations_spec.rb",
+     "spec/named_scopes/conditions_spec.rb",
+     "spec/named_scopes/ordering_spec.rb",
+     "spec/search_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.0.0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.0.0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.0.0"])
+  end
+end

data/spec/core_ext/object_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "Object" do
+  it "should accept and pass the argument to the searchlogic_arg_type" do
+    searchlogic_lambda(:integer) {}.searchlogic_arg_type.should == :integer
+  end
+end

data/spec/core_ext/proc_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "Proc" do
+  it "should have a searchlogic_arg_type accessor" do
+    p = Proc.new {}
+    p.searchlogic_arg_type = :integer
+    p.searchlogic_arg_type.should == :integer
+  end
+end

data/spec/named_scopes/alias_scope_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "AliasScope" do
+  it "should allow alias scopes" do
+    User.create(:username => "bjohnson")
+    User.create(:username => "thunt")
+    User.username_has("bjohnson").all.should == User.find_all_by_username("bjohnson")
+  end
+  
+  it "should allow alias scopes from the search object" do
+    search = User.search
+    search.username_has = "bjohnson"
+    search.username_has.should == "bjohnson"
+  end
+end

data/spec/named_scopes/associations_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "Associations" do
+  it "should create a named scope" do
+    Company.users_username_like("bjohnson").proxy_options.should == User.username_like("bjohnson").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should create a deep named scope" do
+    Company.users_orders_total_greater_than(10).proxy_options.should == Order.total_greater_than(10).proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should not allowed named scopes on non existent association columns" do
+    lambda { User.users_whatever_like("bjohnson") }.should raise_error(NoMethodError)
+  end
+  
+  it "should not allowed named scopes on non existent deep association columns" do
+    lambda { User.users_orders_whatever_like("bjohnson") }.should raise_error(NoMethodError)
+  end
+  
+  it "should allow named scopes to be called multiple times and reflect the value passed" do
+    Company.users_username_like("bjohnson").proxy_options.should == User.username_like("bjohnson").proxy_options.merge(:joins => :users)
+    Company.users_username_like("thunt").proxy_options.should == User.username_like("thunt").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should allow deep named scopes to be called multiple times and reflect the value passed" do
+    Company.users_orders_total_greater_than(10).proxy_options.should == Order.total_greater_than(10).proxy_options.merge(:joins => {:users => :orders})
+    Company.users_orders_total_greater_than(20).proxy_options.should == Order.total_greater_than(20).proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should have an arity of 1 if the underlying scope has an arity of 1" do
+    Company.users_orders_total_greater_than(10)
+    Company.named_scope_arity("users_orders_total_greater_than").should == Order.named_scope_arity("total_greater_than")
+  end
+  
+  it "should have an arity of nil if the underlying scope has an arity of nil" do
+    Company.users_orders_total_null
+    Company.named_scope_arity("users_orders_total_null").should == Order.named_scope_arity("total_null")
+  end
+  
+  it "should have an arity of -1 if the underlying scope has an arity of -1" do
+    Company.users_id_equals_any
+    Company.named_scope_arity("users_id_equals_any").should == User.named_scope_arity("id_equals_any")
+  end
+  
+  it "should allow aliases" do
+    Company.users_username_contains("bjohnson").proxy_options.should == User.username_contains("bjohnson").proxy_options.merge(:joins => :users)
+  end
+  
+  it "should allow deep aliases" do
+    Company.users_orders_total_gt(10).proxy_options.should == Order.total_gt(10).proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should allow ascending" do
+    Company.ascend_by_users_username.proxy_options.should == User.ascend_by_username.proxy_options.merge(:joins => :users)
+  end
+  
+  it "should allow descending" do
+    Company.descend_by_users_username.proxy_options.should == User.descend_by_username.proxy_options.merge(:joins => :users)
+  end
+  
+  it "should allow deep ascending" do
+    Company.ascend_by_users_orders_total.proxy_options.should == Order.ascend_by_total.proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should allow deep descending" do
+    Company.descend_by_users_orders_total.proxy_options.should == Order.descend_by_total.proxy_options.merge(:joins => {:users => :orders})
+  end
+  
+  it "should include optional associations" do
+    pending # this is a problem with using inner joins and left outer joins
+    Company.create
+    company = Company.create
+    user = company.users.create
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.ascend_by_users_orders_total.all.should == Company.all
+  end
+  
+  it "should not create the same join twice" do
+    company = Company.create
+    user = company.users.create
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_orders_total_gt(10).users_orders_taxes_lt(5).ascend_by_users_orders_total.all.should == Company.all
+  end
+  
+  it "should not create the same join twice when traveling through the duplicate join" do
+    Company.users_username_like("bjohnson").users_orders_total_gt(100).all.should == Company.all
+  end
+  
+  it "should not create the same join twice when traveling through the duplicate join 2" do
+    Company.users_orders_total_gt(100).users_orders_line_items_price_gt(20).all.should == Company.all
+  end
+  
+  it "should allow the use of :include when a join was created" do
+    company = Company.create
+    user = company.users.create
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_orders_total_gt(10).users_orders_taxes_lt(5).ascend_by_users_orders_total.all(:include => :users).should == Company.all
+  end
+  
+  it "should allow the use of deep :include when a join was created" do
+    company = Company.create
+    user = company.users.create
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_orders_total_gt(10).users_orders_taxes_lt(5).ascend_by_users_orders_total.all(:include => {:users => :orders}).should == Company.all
+  end
+  
+  it "should allow the use of :include when traveling through the duplicate join" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_username_like("bjohnson").users_orders_taxes_lt(5).ascend_by_users_orders_total.all(:include => :users).should == Company.all
+  end
+  
+  it "should allow the use of deep :include when traveling through the duplicate join" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    order = user.orders.create(:total => 20, :taxes => 3)
+    Company.users_orders_taxes_lt(50).ascend_by_users_orders_total.all(:include => {:users => :orders}).should == Company.all
+  end
+end