joost-searchlogic 2.1.5.2

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "searchlogic"
+    gem.summary = "Searchlogic provides common named scopes and object based searching for ActiveRecord."
+    gem.email = "bjohnson@binarylogic.com"
+    gem.homepage = "http://github.com/binarylogic/searchlogic"
+    gem.authors = ["Ben Johnson of Binary Logic"]
+    gem.rubyforge_project = "searchlogic"
+    gem.add_dependency "activerecord", ">= 2.0.0"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+    desc "Release gem to RubyForge"
+    task :release => ["rubyforge:release:gem"]
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 2
+:minor: 1
+:patch: 5

data/init.rb

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

data/lib/searchlogic.rb

@@ -0,0 +1,31 @@
+require "searchlogic/core_ext/proc"
+require "searchlogic/core_ext/object"
+require "searchlogic/active_record_consistency"
+require "searchlogic/named_scopes/conditions"
+require "searchlogic/named_scopes/ordering"
+require "searchlogic/named_scopes/associations"
+require "searchlogic/named_scopes/alias_scope"
+require "searchlogic/search"
+
+Proc.send(:include, Searchlogic::CoreExt::Proc)
+Object.send(:include, Searchlogic::CoreExt::Object)
+ActiveRecord::Base.extend(Searchlogic::NamedScopes::Conditions)
+ActiveRecord::Base.extend(Searchlogic::NamedScopes::Ordering)
+ActiveRecord::Base.extend(Searchlogic::NamedScopes::Associations)
+ActiveRecord::Base.extend(Searchlogic::NamedScopes::AliasScope)
+ActiveRecord::Base.extend(Searchlogic::Search::Implementation)
+
+# Try to use the search method, if it's available. Thinking sphinx and other plugins
+# like to use that method as well.
+if !ActiveRecord::Base.respond_to?(:search)
+  ActiveRecord::Base.class_eval do
+    class << self
+      alias_method :search, :searchlogic
+    end
+  end
+end
+
+if defined?(ActionController)
+  require "searchlogic/rails_helpers"
+  ActionController::Base.helper(Searchlogic::RailsHelpers)
+end

data/lib/searchlogic/active_record_consistency.rb

@@ -0,0 +1,27 @@
+module Searchlogic
+  # Active Record is pretty inconsistent with how their SQL is constructed. This
+  # method attempts to close the gap between the various inconsistencies.
+  module ActiveRecordConsistency
+    def self.included(klass)
+      klass.class_eval do
+        alias_method_chain :merge_joins, :searchlogic
+      end
+    end
+    
+    # In AR multiple joins are sometimes in a single join query, and other time they
+    # are not. The merge_joins method in AR should account for this, but it doesn't.
+    # This fixes that problem.
+    def merge_joins_with_searchlogic(*args)
+      joins = merge_joins_without_searchlogic(*args)
+      joins.collect { |j| j.is_a?(String) ? j.split("  ") : j }.flatten.uniq
+    end
+  end
+end
+
+module ActiveRecord # :nodoc: all
+  class Base
+    class << self
+      include Searchlogic::ActiveRecordConsistency
+    end
+  end
+end

data/lib/searchlogic/core_ext/object.rb

@@ -0,0 +1,39 @@
+module Searchlogic
+  module CoreExt
+    # Contains extensions for the Object class that Searchlogic uses.
+    module Object
+      # Searchlogic needs to know the expected type of the condition value so that it can properly cast
+      # the value in the Searchlogic::Search object. For example:
+      #
+      #   search = User.search(:id_gt => "1")
+      #
+      # You would expect this:
+      #
+      #   search.id_gt => 1
+      #
+      # Not this:
+      #
+      #   search.id_gt => "1"
+      #
+      # Parameter values from forms are ALWAYS strings, so we have to cast them. Just like ActiveRecord
+      # does when you instantiate a new User object.
+      #
+      # The problem is that ruby has no variable types, so Searchlogic needs to know what type you are expecting
+      # for your named scope. So instead of this:
+      #
+      #   named_scope :id_gt, lambda { |value| {:conditions => ["id > ?", value]} }
+      #
+      # You need to do this:
+      #
+      #   named_scope :id_gt, searchlogic_lambda(:integer) { |value| {:conditions => ["id > ?", value]} }
+      #
+      # If you are wanting a string, you don't have to do anything, because Searchlogic assumes you are want a string.
+      # If you want something else, you need to specify it as I did in the above example.
+      def searchlogic_lambda(type = :string, &block)
+        proc = lambda(&block)
+        proc.searchlogic_arg_type = type
+        proc
+      end
+    end
+  end
+end

data/lib/searchlogic/core_ext/proc.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module CoreExt
+    module Proc # :nodoc:
+      def self.included(klass)
+        klass.class_eval do
+          attr_accessor :searchlogic_arg_type
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/alias_scope.rb

@@ -0,0 +1,63 @@
+module Searchlogic
+  module NamedScopes
+    # Adds the ability to create alias scopes that allow you to alias a named
+    # scope or create a named scope procedure, while at the same time letting
+    # Searchlogic know that this is a safe method.
+    module AliasScope
+      # The searchlogic Search class takes a hash and chains the values together as named scopes.
+      # For security reasons the only hash keys that are allowed must be mapped to named scopes.
+      # You can not pass the name of a class method and expect that to be called. In some instances
+      # you might create a class method that essentially aliases a named scope or represents a
+      # named scope procedure. Ex:
+      #
+      #   User.named_scope :teenager, :conditions => ["age >= ? AND age <= ?", 13, 19]
+      #
+      # This is obviously a very basic example, but there is logic that is duplicated here. For
+      # more complicated named scopes this might make more sense, but to make my point you could
+      # do something like this instead
+      #
+      #   class User
+      #     def teenager
+      #       age_gte(13).age_lte(19)
+      #     end
+      #   end
+      #
+      # As I stated above, you could not use this method with the Searchlogic::Search class because
+      # there is no way to tell that this is actually a named scope. Instead, Searchlogic lets you
+      # do something like this:
+      #
+      #   User.alias_scope :teenager, lambda { age_gte(13).age_lte(19) }
+      #
+      # It fits in better, at the same time Searchlogic will know this is an acceptable named scope.
+      def alias_scope(name, options = nil)
+        alias_scopes[name.to_sym] = options
+        (class << self; self end).instance_eval do
+          define_method name do |*args|
+            case options
+            when Symbol
+              send(options)
+            else
+              options.call(*args)
+            end
+          end
+        end
+      end
+      
+      def alias_scopes # :nodoc:
+        @alias_scopes ||= {}
+      end
+      
+      def alias_scope?(name) # :nodoc:
+        alias_scopes.key?(name.to_sym)
+      end
+      
+      def condition?(name) # :nodoc:
+        super || alias_scope?(name)
+      end
+      
+      def named_scope_options(name) # :nodoc:
+        super || alias_scopes[name.to_sym]
+      end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/associations.rb

@@ -0,0 +1,131 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for associations.
+    module Associations
+      def condition?(name) # :nodoc:
+        super || association_condition?(name) || association_alias_condition?(name)
+      end
+      
+      def primary_condition_name(name) # :nodoc:
+        if result = super
+          result
+        elsif association_condition?(name)
+          name.to_sym
+        elsif details = association_alias_condition_details(name)
+          "#{details[:association]}_#{details[:column]}_#{primary_condition(details[:condition])}".to_sym
+        else
+          nil
+        end
+      end
+      
+      # Is the name of the method a valid name for an association condition?
+      def association_condition?(name)
+        !association_condition_details(name).nil?
+      end
+      
+      # Is the ane of the method a valie name for an association alias condition?
+      # An alias being "gt" for "greater_than", etc.
+      def association_alias_condition?(name)
+        !association_alias_condition_details(name).nil?
+      end
+      
+      # A convenience method for creating inner join sql to that your inner joins
+      # are consistent with how Active Record creates them.
+      def inner_joins(association_name)
+        ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, association_name, nil).join_associations.collect { |assoc| assoc.association_join }
+      end
+      
+      private
+        def method_missing(name, *args, &block)
+          if details = association_condition_details(name)
+            create_association_condition(details[:association], details[:column], details[:condition], args)
+            send(name, *args)
+          elsif details = association_alias_condition_details(name)
+            create_association_alias_condition(details[:association], details[:column], details[:condition], args)
+            send(name, *args)
+          elsif details = association_ordering_condition_details(name)
+            create_association_ordering_condition(details[:association], details[:order_as], details[:column], args)
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def association_condition_details(name)
+          associations = reflect_on_all_associations.collect { |assoc| assoc.name }
+          if name.to_s =~ /^(#{associations.join("|")})_(\w+)_(#{Conditions::PRIMARY_CONDITIONS.join("|")})$/
+            {:association => $1, :column => $2, :condition => $3}
+          end
+        end
+        
+        def create_association_condition(association_name, column, condition, args)
+          named_scope("#{association_name}_#{column}_#{condition}", association_condition_options(association_name, "#{column}_#{condition}", args))
+        end
+        
+        def association_alias_condition_details(name)
+          associations = reflect_on_all_associations.collect { |assoc| assoc.name }
+          if name.to_s =~ /^(#{associations.join("|")})_(\w+)_(#{Conditions::ALIAS_CONDITIONS.join("|")})$/
+            {:association => $1, :column => $2, :condition => $3}
+          end
+        end
+        
+        def create_association_alias_condition(association, column, condition, args)
+          primary_condition = primary_condition(condition)
+          alias_name = "#{association}_#{column}_#{condition}"
+          primary_name = "#{association}_#{column}_#{primary_condition}"
+          send(primary_name, *args) # go back to method_missing and make sure we create the method
+          (class << self; self; end).class_eval { alias_method alias_name, primary_name }
+        end
+        
+        def association_ordering_condition_details(name)
+          associations = reflect_on_all_associations.collect { |assoc| assoc.name }
+          if name.to_s =~ /^(ascend|descend)_by_(#{associations.join("|")})_(\w+)$/
+            {:order_as => $1, :association => $2, :column => $3} unless column_names.include?("#{$2}_#{$3}")
+          end
+        end
+        
+        def create_association_ordering_condition(association_name, order_as, column, args)
+          named_scope("#{order_as}_by_#{association_name}_#{column}", association_condition_options(association_name, "#{order_as}_by_#{column}", args))
+        end
+        
+        def association_condition_options(association_name, association_condition, args)
+          association = reflect_on_association(association_name.to_sym)
+          scope = association.klass.send(association_condition, *args)
+          scope_options = association.klass.named_scope_options(association_condition)
+          arity = association.klass.named_scope_arity(association_condition)
+          
+          if !arity || arity == 0
+            # The underlying condition doesn't require any parameters, so let's just create a simple
+            # named scope that is based on a hash.
+            options = scope.proxy_options
+            options[:joins] = options[:joins].blank? ? association.name : {association.name => options[:joins]}
+            options
+          else
+            # The underlying condition requires parameters, let's match the parameters it requires
+            # and pass those onto the named scope. We can't use proxy_options because that returns the
+            # result after a value has been passed.
+            proc_args = []
+            if arity > 0
+              arity.times { |i| proc_args << "arg#{i}"}
+            else
+              positive_arity = arity * -1
+              positive_arity.times do |i|
+                if i == (positive_arity - 1)
+                  proc_args << "*arg#{i}"
+                else
+                  proc_args << "arg#{i}"
+                end
+              end
+            end
+            eval <<-"end_eval"
+              searchlogic_lambda(:#{scope_options.searchlogic_arg_type}) { |#{proc_args.join(",")}|
+                options = association.klass.named_scope_options(association_condition).call(#{proc_args.join(",")})
+                options[:joins] = options[:joins].blank? ? association.name : {association.name => options[:joins]}
+                options
+              }
+            end_eval
+          end
+        end
+    end
+  end
+end

data/lib/searchlogic/named_scopes/conditions.rb

@@ -0,0 +1,215 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for columns.
+    module Conditions
+      COMPARISON_CONDITIONS = {
+        :equals => [:is, :eq],
+        :does_not_equal => [:not_equal_to, :is_not, :not, :ne],
+        :less_than => [:lt, :before],
+        :less_than_or_equal_to => [:lte],
+        :greater_than => [:gt, :after],
+        :greater_than_or_equal_to => [:gte],
+      }
+      
+      WILDCARD_CONDITIONS = {
+        :like => [:contains, :includes],
+        :begins_with => [:bw],
+        :ends_with => [:ew],
+      }
+      
+      BOOLEAN_CONDITIONS = {
+        :null => [:nil],
+        :empty => []
+      }
+      
+      CONDITIONS = {}
+      
+      COMPARISON_CONDITIONS.merge(WILDCARD_CONDITIONS).each do |condition, aliases|
+        CONDITIONS[condition] = aliases
+        CONDITIONS["#{condition}_any".to_sym] = aliases.collect { |a| "#{a}_any".to_sym }
+        CONDITIONS["#{condition}_all".to_sym] = aliases.collect { |a| "#{a}_all".to_sym }
+      end
+      
+      BOOLEAN_CONDITIONS.each { |condition, aliases| CONDITIONS[condition] = aliases }
+      
+      PRIMARY_CONDITIONS = CONDITIONS.keys
+      ALIAS_CONDITIONS = CONDITIONS.values.flatten
+      
+      # Retrieves the options passed when creating the respective named scope. Ex:
+      #
+      #   named_scope :whatever, :conditions => {:column => value}
+      #
+      # This method will return:
+      #
+      #   :conditions => {:column => value}
+      #
+      # ActiveRecord hides this internally, so we have to try and pull it out with this
+      # method.
+      def named_scope_options(name)
+        key = scopes.key?(name.to_sym) ? name.to_sym : primary_condition_name(name)
+        
+        if key
+          eval("options", scopes[key])
+        else
+          nil
+        end
+      end
+      
+      # The arity for a named scope's proc is important, because we use the arity
+      # to determine if the condition should be ignored when calling the search method.
+      # If the condition is false and the arity is 0, then we skip it all together. Ex:
+      #
+      #   User.named_scope :age_is_4, :conditions => {:age => 4}
+      #   User.search(:age_is_4 => false) == User.all
+      #   User.search(:age_is_4 => true) == User.all(:conditions => {:age => 4})
+      #
+      # We also use it when trying to "copy" the underlying named scope for association
+      # conditions.
+      def named_scope_arity(name)
+        options = named_scope_options(name)
+        options.respond_to?(:arity) ? options.arity : nil
+      end
+      
+      # Returns the primary condition for the given alias. Ex:
+      #
+      #   primary_condition(:gt) => :greater_than
+      def primary_condition(alias_condition)
+        CONDITIONS.find { |k, v| k == alias_condition.to_sym || v.include?(alias_condition.to_sym) }.first
+      end
+      
+      # Returns the primary name for any condition on a column. You can pass it
+      # a primary condition, alias condition, etc, and it will return the proper
+      # primary condition name. This helps simply logic throughout Searchlogic. Ex:
+      #
+      #   primary_condition_name(:id_gt) => :id_greater_than
+      #   primary_condition_name(:id_greater_than) => :id_greater_than
+      def primary_condition_name(name)
+        if primary_condition?(name)
+          name.to_sym
+        elsif details = alias_condition_details(name)
+          "#{details[:column]}_#{primary_condition(details[:condition])}".to_sym
+        else
+          nil
+        end
+      end
+      
+      # Is the name of the method a valid condition that can be dynamically created?
+      def condition?(name)
+        primary_condition?(name) || alias_condition?(name)
+      end
+      
+      # Is the name of the method a valid condition that can be dynamically created,
+      # AND is it a primary condition (not an alias). "greater_than" not "gt".
+      def primary_condition?(name)
+        !primary_condition_details(name).nil?
+      end
+      
+      # Is the name of the method a valid condition that can be dynamically created,
+      # AND is it an alias condition. "gt" not "greater_than".
+      def alias_condition?(name)
+        !alias_condition_details(name).nil?
+      end
+      
+      private
+        def method_missing(name, *args, &block)
+          if details = primary_condition_details(name)
+            create_primary_condition(details[:column], details[:condition])
+            send(name, *args)
+          elsif details = alias_condition_details(name)
+            create_alias_condition(details[:column], details[:condition], args)
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def primary_condition_details(name)
+          if name.to_s =~ /^(#{column_names.join("|")})_(#{PRIMARY_CONDITIONS.join("|")})$/
+            {:column => $1, :condition => $2}
+          end
+        end
+        
+        def create_primary_condition(column, condition)
+          column_type = columns_hash[column.to_s].type
+          scope_options = case condition.to_s
+          when /^equals/
+            scope_options(condition, column_type, "#{table_name}.#{column} = ?")
+          when /^does_not_equal/
+            scope_options(condition, column_type, "#{table_name}.#{column} != ?")
+          when /^less_than_or_equal_to/
+            scope_options(condition, column_type, "#{table_name}.#{column} <= ?")
+          when /^less_than/
+            scope_options(condition, column_type, "#{table_name}.#{column} < ?")
+          when /^greater_than_or_equal_to/
+            scope_options(condition, column_type, "#{table_name}.#{column} >= ?")
+          when /^greater_than/
+            scope_options(condition, column_type, "#{table_name}.#{column} > ?")
+          when /^like/
+            scope_options(condition, column_type, "#{table_name}.#{column} LIKE ?", :like)
+          when /^begins_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} LIKE ?", :begins_with)
+          when /^ends_with/
+            scope_options(condition, column_type, "#{table_name}.#{column} LIKE ?", :ends_with)
+          when "null"
+            {:conditions => "#{table_name}.#{column} IS NULL"}
+          when "empty"
+            {:conditions => "#{table_name}.#{column} = ''"}
+          end
+          
+          named_scope("#{column}_#{condition}".to_sym, scope_options)
+        end
+        
+        # This method helps cut down on defining scope options for conditions that allow *_any or *_all conditions.
+        # Kepp in mind that the lambdas get cached in a method, so you want to keep the contents of the lambdas as
+        # fast as possible, which is why I didn't do the case statement inside of the lambda.
+        def scope_options(condition, column_type, sql, value_modifier = nil)
+          case condition.to_s
+          when /_(any|all)$/
+            searchlogic_lambda(column_type) { |*values|
+              return {} if values.empty?
+              values = values.flatten
+              
+              values_to_sub = nil
+              if value_modifier.nil?
+                values_to_sub = values
+              else
+                values_to_sub = values.collect { |value| value_with_modifier(value, value_modifier) }
+              end
+              
+              join = $1 == "any" ? " OR " : " AND "
+              {:conditions => [values.collect { |value| sql }.join(join), *values_to_sub]}
+            }
+          else
+            searchlogic_lambda(column_type) { |value| {:conditions => [sql, value_with_modifier(value, value_modifier)]} }
+          end
+        end
+        
+        def value_with_modifier(value, modifier)
+          case modifier
+          when :like
+            "%#{value}%"
+          when :begins_with
+            "#{value}%"
+          when :ends_with
+            "%#{value}"
+          else
+            value
+          end
+        end
+        
+        def alias_condition_details(name)
+          if name.to_s =~ /^(#{column_names.join("|")})_(#{ALIAS_CONDITIONS.join("|")})$/
+            {:column => $1, :condition => $2}
+          end
+        end
+        
+        def create_alias_condition(column, condition, args)
+          primary_condition = primary_condition(condition)
+          alias_name = "#{column}_#{condition}"
+          primary_name = "#{column}_#{primary_condition}"
+          send(primary_name, *args) # go back to method_missing and make sure we create the method
+          (class << self; self; end).class_eval { alias_method alias_name, primary_name }
+        end
+    end
+  end
+end