searchlogic 1.6.6 → 2.1.0

data/Rakefile

@@ -1,20 +1,56 @@
-ENV['RDOCOPT'] = "-S -f html -T hanna"
-
-require "rubygems"
-require "hoe"
-require File.dirname(__FILE__) << "/lib/searchlogic/version"
-
-Hoe.new("Searchlogic", Searchlogic::Version::STRING) do |p|
-  p.name = "searchlogic"
-  p.author = "Ben Johnson of Binary Logic"
-  p.email  = 'bjohnson@binarylogic.com'
-  p.summary = "Object based ActiveRecord searching, ordering, pagination, and more!"
-  p.description = "Object based ActiveRecord searching, ordering, pagination, and more!"
-  p.url = "http://github.com/binarylogic/searchlogic"
-  p.history_file = "CHANGELOG.rdoc"
-  p.readme_file = "README.rdoc"
-  p.extra_rdoc_files = ["CHANGELOG.rdoc", "README.rdoc"]
-  p.remote_rdoc_dir = ''
-  p.test_globs = ["test/*/test_*.rb", "test/*_test.rb", "test/*/*_test.rb"]
-  p.extra_deps = %w(activesupport activerecord)
-end
+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"
+  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
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "search #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+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: 0

data/init.rb

@@ -1 +1 @@
-require File.dirname(__FILE__) << "/lib/searchlogic"
+require "searchlogic"

data/lib/searchlogic.rb

@@ -1,100 +1,20 @@
-$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-require "active_support"
-require "active_record"
-require "active_record/version"
-
-["mysql", "postgresql", "sqlite"].each do |adapter_name|
-  begin
-    require "active_record/connection_adapters/#{adapter_name}_adapter"
-    require "searchlogic/active_record/connection_adapters/#{adapter_name}_adapter"
-  rescue Exception
-  end
-end
-
-# Core Ext
-require "searchlogic/core_ext/hash"
+require "searchlogic/core_ext/proc"
 require "searchlogic/core_ext/object"
-
-# Shared
-require "searchlogic/shared/utilities"
-require "searchlogic/shared/virtual_classes"
-
-# Base classes
-require "searchlogic/version"
-require "searchlogic/config/helpers"
-require "searchlogic/config/search"
-require "searchlogic/config"
-
-# ActiveRecord
-require "searchlogic/active_record/base"
-require "searchlogic/active_record/associations"
-
-# Search
-require "searchlogic/search/ordering"
-require "searchlogic/search/pagination"
-require "searchlogic/search/conditions"
-require "searchlogic/search/searching"
-require "searchlogic/search/base"
-require "searchlogic/search/protection"
-
-# Conditions
-require "searchlogic/conditions/any_or_all"
-require "searchlogic/conditions/groups"
-require "searchlogic/conditions/magic_methods"
-require "searchlogic/conditions/multiparameter_attributes"
-require "searchlogic/conditions/protection"
-require "searchlogic/conditions/base"
-
-# Condition
-require "searchlogic/condition/base"
-require "searchlogic/condition/nested_set"
-SEARCHLOGIC_CONDITIONS = [:begins_with, :blank, :child_of, :descendant_of, :ends_with, :equals, :greater_than, :greater_than_or_equal_to, :inclusive_descendant_of, :like, :nil, :not_begin_with,
-  :not_blank, :not_end_with, :not_equal, :not_have_keywords, :not_like, :not_nil, :keywords, :less_than, :less_than_or_equal_to, :sibling_of]
-SEARCHLOGIC_CONDITIONS.each { |condition| require "searchlogic/condition/#{condition}" }
-
-# Modifiers
-require "searchlogic/modifiers/base"
-SEARCHLOGIC_MODIFIERS = [:absolute, :acos, :asin, :atan, :avg, :ceil, :char_length, :cos, :cot, :count, :day_of_month, :day_of_week, :day_of_year, :degrees, :exp, :floor, :hex, :hour, :log, :log10,
-  :log2, :lower, :ltrim, :md5, :microseconds, :milliseconds, :minute, :month, :octal, :radians, :round, :rtrim, :second, :sign, :sin, :square_root, :sum, :tan, :trim, :upper, :week, :year]
-SEARCHLOGIC_MODIFIERS.each { |modifier| require "searchlogic/modifiers/#{modifier}" }
-
-# Helpers
-require "searchlogic/helpers/utilities"
-require "searchlogic/helpers/form"
-require "searchlogic/helpers/control_types/link"
-require "searchlogic/helpers/control_types/links"
-require "searchlogic/helpers/control_types/select"
-require "searchlogic/helpers/control_types/remote_link"
-require "searchlogic/helpers/control_types/remote_links"
-require "searchlogic/helpers/control_types/remote_select"
-
-# Lets do it!
-module Searchlogic
-  module Search
-    class Base
-      include Conditions
-      include Ordering
-      include Protection
-      include Pagination
-      include Searching
-    end
-  end
-  
-  module Conditions
-    class Base
-      include AnyOrAll
-      include Groups
-      include MagicMethods
-      include MultiparameterAttributes
-      include Protection
-    end
-    
-    SEARCHLOGIC_CONDITIONS.each { |condition| Base.register_condition("Searchlogic::Condition::#{condition.to_s.camelize}".constantize) }
-    SEARCHLOGIC_MODIFIERS.each { |modifier| Base.register_modifier("Searchlogic::Modifiers::#{modifier.to_s.camelize}".constantize) }
-  end
-  
-  # The namespace I put all cached search classes.
-  module Cache
-  end
+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)
+
+if defined?(ActionController)
+  require "searchlogic/rails_helpers"
+  ActionController::Base.helper(Searchlogic::RailsHelpers)
 end

data/lib/searchlogic/core_ext/object.rb

@@ -1,19 +1,39 @@
 module Searchlogic
   module CoreExt
+    # Contains extensions for the Object class that Searchlogic uses.
     module Object
-      # Get object's meta (ghost, eigenclass, singleton) class
-      def metaclass
-        class << self
-          self
-        end
-      end
-
-      # If class_eval is called on an object, add those methods to its metaclass
-      def class_eval(*args, &block)
-        metaclass.class_eval(*args, &block)
+      # 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
-
-Object.send(:include, Searchlogic::CoreExt::Object)
+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,126 @@
+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
+      
+      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}
+          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]}
+            #add_left_outer_joins(options, association)
+            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