rd_searchlogic 3.0.0.rc

data/lib/searchlogic/named_scopes/ordering.rb

@@ -0,0 +1,74 @@
+module Searchlogic
+  module NamedScopes
+    # Handles dynamically creating named scopes for ordering by columns. Example:
+    #
+    #   User.ascend_by_id
+    #   User.descend_by_username
+    #
+    # See the README for a more detailed explanation.
+    module Ordering
+      def condition?(name) # :nodoc:
+        super || ordering_condition?(name)
+      end
+
+      def self.included(base)
+        #this overrides the 'new' method in any class including Ordering -- then when called, new overrides the 'order' method
+        #overriding is not a simple matter in Ruby because includes put the modules below the class in the superclass sequence
+        #this keeps the code cleaner by avoiding alias_method_chain (monkey patching)
+        (class << base; self; end).send(:include, ClassOverrideMethods)
+      end
+
+      module ClassOverrideMethods
+        def new(*args)
+          _inst = super
+          #this overrides the 'order' method
+          (class << _inst; self; end).send(:include, Searchlogic::NamedScopes::Ordering::InstanceOverrideMethods)
+          _inst
+        end
+      end
+      module InstanceOverrideMethods
+        def order(*args)
+          if condition?(args[0])
+            send(args[0])
+          else
+            super
+          end
+        end
+      end
+      
+      private
+        def ordering_condition?(name) # :nodoc:
+          !ordering_condition_details(name).nil?
+        end
+        
+        def method_missing(name, *args, &block)
+          if name == :order
+            scope name, lambda { |scope_name|
+              return {} if !condition?(scope_name)
+              send(scope_name).proxy_options
+            }
+            send(name, *args)
+          end
+          if details = ordering_condition_details(name)
+            create_ordering_conditions(details[:column])
+            send(name, *args)
+          else
+            super
+          end
+        end
+        
+        def ordering_condition_details(name)
+          if name.to_s =~ /^(ascend|descend)_by_(#{column_names.join("|")})$/
+            {:order_as => $1, :column => $2}
+          elsif name.to_s =~ /^order$/
+            {}
+          end
+        end
+        
+        def create_ordering_conditions(column)
+          scope("ascend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} ASC"})
+          scope("descend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} DESC"})
+        end
+    end
+  end
+end

data/lib/searchlogic/rails_helpers.rb

@@ -0,0 +1,79 @@
+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</tt> - hash with additional params which will be added to generated url
+    # * <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
+      if !options[:as]
+        id = options[:by].to_s.downcase == "id"
+        options[:as] = id ? options[:by].to_s.upcase : options[:by].to_s.humanize
+      end
+      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] = raw("&#9650;&nbsp;#{options[:as]}")
+          css_classes << "ascending"
+        else
+          options[:as] = raw("&#9660;&nbsp;#{options[:as]}")
+          css_classes << "descending"
+        end
+        html_options[:class] = css_classes.join(" ")
+      end
+      url_options = {
+        options[:params_scope] => search.conditions.merge( { :order => new_scope } )
+      }.deep_merge(options[:params] || {})
+
+      options[:as] = raw(options[:as]) if defined?(RailsXss)
+
+      link_to options[:as], url_for(url_options), 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)))
+        super
+      else
+        super
+      end
+    end
+  end
+end

data/lib/searchlogic/search.rb

@@ -0,0 +1,259 @@
+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 aliased 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, self, conditions) #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
+    
+    def do_search
+      @current_scope
+    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
+      @conditions ||= {}
+      self.conditions = conditions if conditions.is_a?(Hash)
+    end
+    
+    def clone
+      self.class.new(klass, current_scope && current_scope.clone, conditions.clone)
+    end
+    
+    # Returns a hash of the current conditions set.
+    def conditions
+      mass_conditions.clone.merge(@conditions)
+    end
+    
+    # Accepts a hash of conditions.
+    def conditions=(values)
+      values.each do |condition, value|
+        # if a condition name ends with "(1i)", assume it's date / datetime
+        if condition =~ /(.*)\(1i\)$/
+          date_scope_name = $1
+          date_parts = (1..6).to_a.map do |idx|
+            values.delete("#{ date_scope_name }(#{ idx }i)")
+          end.reject{|s| s.blank? }.map{|s| s.to_i }
+
+          # did we get enough info to build a time?
+          if date_parts.length >= 3
+            values[date_scope_name] = Time.zone.local(*date_parts)
+          end
+        end
+      end
+
+      values.each do |condition, value|
+        mass_conditions[condition.to_sym] = value
+        value.delete_if { |v| ignore_value?(v) } if value.is_a?(Array)
+        next if ignore_value?(value)
+        # value = Time.zone.parse(value) if value =~ /[\d\/.-]{10}/
+        @current_scope = @current_scope.send(condition, value)
+        send("#{condition}=", value)
+        @conditions[condition.to_sym] = 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 do |name|
+        @conditions.delete(name.to_sym)
+        mass_conditions.delete(name)
+      end
+      self
+    end
+    
+    # Returns the column we are currently ordering by
+    def ordering_by
+      order && order.to_s.gsub(/^(ascend|descend)_by_/, '')
+    end
+    
+    private
+      def method_missing(name, *args, &block)
+        condition_name = condition_name(name)
+        scope_name = scope_name(condition_name)
+
+        
+        if setter?(name)
+          if scope?(scope_name)
+            if args.size == 1
+              write_condition(
+                condition_name,
+                type_cast(
+                  args.first,
+                  cast_type(scope_name),
+                  scope_options(scope_name).respond_to?(:searchlogic_options) ? scope_options(scope_name).searchlogic_options : {}
+                )
+              )
+            else
+              write_condition(condition_name, args)
+            end
+          else
+            raise UnknownConditionError.new(condition_name)
+          end
+        elsif scope?(scope_name) && args.size <= 1
+          if args.size == 0
+            read_condition(condition_name)
+          else
+            send("#{condition_name}=", *args)
+            self
+          end
+        else
+          scope = conditions_array.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
+            elsif arity == -1
+              scope.send(scope_name, *(value.is_a?(Array) ? value : [value]))
+            else
+              scope.send(scope_name, value)
+            end
+          end
+          scope.send(name, *args, &block)
+        end
+      end
+      
+      # This is here as a hook to allow people to modify the order in which the conditions are called, for whatever reason.
+      def conditions_array
+        @conditions.to_a
+      end
+      
+      def normalize_scope_name(scope_name)
+        case
+        when klass.scopes.key?(scope_name.to_sym) then scope_name.to_sym
+        when klass.column_names.include?(scope_name.to_s) then "#{scope_name}_equals".to_sym
+        else scope_name.to_sym
+        end
+      end
+      
+      def setter?(name)
+        !(name.to_s =~ /=$/).nil?
+      end
+      
+      def condition_name(name)
+        condition = name.to_s.match(/(\w+)=?$/)
+        condition ? condition[1].to_sym : nil
+      end
+      
+      def write_condition(name, value)
+        @conditions[name] = value
+      end
+      
+      def read_condition(name)
+        @conditions[name]
+      end
+      
+      def mass_conditions
+        @mass_conditions ||= {}
+      end
+      
+      def scope_name(condition_name)
+        condition_name && normalize_scope_name(condition_name)
+      end
+      
+      def scope?(scope_name)
+        klass.scopes.key?(scope_name) || klass.condition?(scope_name)
+      end
+      
+      def scope_options(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_scope_options
+        klass.named_scope_options(name)
+      end
+      
+      def cast_type(name)
+        named_scope_options = scope_options(name)
+        arity = klass.named_scope_arity(name)
+        if !arity || arity == 0
+          :boolean
+        else
+          named_scope_options.respond_to?(:searchlogic_options) ? named_scope_options.searchlogic_options[:type] : :string
+        end
+      end
+      
+      def type_cast(value, type, options = {})
+        case value
+        when Array
+          value.collect { |v| type_cast(v, type) }
+        when Range
+          Range.new(type_cast(value.first, type), type_cast(value.last, 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)
+          casted_value = column_for_type_cast.type_cast(value)
+          
+          if Time.zone && casted_value.is_a?(Time)
+            if value.is_a?(String)
+              if options[:skip_conversion]
+                casted_value.utc
+              else
+                (casted_value + (Time.zone.utc_offset * -1)).in_time_zone
+              end
+            else
+              if options[:skip_conversion]
+                casted_value.utc
+              else
+                casted_value.in_time_zone
+              end
+            end
+          else
+            casted_value
+          end
+        end
+      end
+      
+      def ignore_value?(value)
+        (value.is_a?(String) && value.blank?) || (value.is_a?(Array) && value.empty?)
+      end
+  end
+end

data/lib/searchlogic.rb

@@ -0,0 +1,89 @@
+require "searchlogic/core_ext/proc"
+require "searchlogic/core_ext/object"
+require "searchlogic/active_record/association_proxy"
+require "searchlogic/active_record/consistency"
+require "searchlogic/active_record/named_scope_tools"
+require "searchlogic/named_scopes/conditions"
+require "searchlogic/named_scopes/ordering"
+require "searchlogic/named_scopes/association_conditions"
+require "searchlogic/named_scopes/association_ordering"
+require "searchlogic/named_scopes/alias_scope"
+require "searchlogic/named_scopes/or_conditions"
+require "searchlogic/search"
+
+ActiveRecord::Relation.send(:include, Searchlogic::CoreExt::Proc)
+Proc.send(:include, Searchlogic::CoreExt::Proc)
+Object.send(:include, Searchlogic::CoreExt::Object)
+
+module ActiveRecord # :nodoc: all
+  module Associations
+    class AssociationProxy
+      include Searchlogic::ActiveRecord::AssociationProxy
+    end
+  end
+
+# FIX: removed this to get tests running
+#  class Base
+#    class << self; include Searchlogic::ActiveRecord::Consistency; end
+#  end
+end
+
+m = Searchlogic::NamedScopes
+[
+  Searchlogic::ActiveRecord::NamedScopeTools,
+  m::Conditions,
+  m::AssociationConditions,
+  m::AssociationOrdering,
+  m::Ordering,
+#  m::AliasScope
+#  m::OrConditions
+].each do |_module|
+  ActiveRecord::Base.extend(_module)
+  ActiveRecord::Relation.send(:include, _module)
+end
+#ActiveRecord::Base.extend(Searchlogic::ActiveRecord::NamedScopeTools)
+#ActiveRecord::Base.extend(Searchlogic::NamedScopes::Conditions)
+
+#ActiveRecord::Base.extend(Searchlogic::NamedScopes::AssociationConditions)
+#ActiveRecord::Base.extend(Searchlogic::NamedScopes::AssociationOrdering)
+#ActiveRecord::Base.extend(Searchlogic::NamedScopes::Ordering)
+#ActiveRecord::Base.extend(Searchlogic::NamedScopes::AliasScope)
+#ActiveRecord::Base.extend(Searchlogic::NamedScopes::OrConditions)
+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 { class << self; alias_method :search, :searchlogic; end }
+end
+
+if defined?(ActionController)
+  require "searchlogic/rails_helpers"
+  ActionController::Base.helper(Searchlogic::RailsHelpers)
+end
+
+#FIX: for bug in active_record 3.0.0.beta3 -- left over from Rails 2.3.x, and wasn't removed from attribute_condition method in ActiveRecord::Base
+module ActiveRecord
+  module NamedScope
+    class Scope; end
+  end
+end
+
+#FIX: proxy_options is used extensively throughout SL testing to determine that no conditions, ordering, etc. were set
+#module ActiveRecord
+#  class Relation
+#    def proxy_options
+#      [:where_clauses, :order_clauses].inject({}) do |hash, method|
+#        clauses = send(method)
+#        unless clauses.empty?
+#          case method
+#          when :where_clauses then hash[:conditions] = clauses
+#          when :order_clauses then hash[:order] = clauses
+#          end
+#        end
+#        hash
+#      end
+#    end
+#  end
+#end

data/rails/init.rb

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

data/spec/searchlogic/active_record/association_proxy_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe "Searchlogic::ActiveRecord::AssociationProxy" do
+  it "should call location conditions" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    company.users.send(:username_like, "bjohnson").should == [user]
+  end
+  
+  it "should call ordering conditions" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    company.users.send(:ascend_by_username).should == [user]
+  end
+  
+  it "should call 'or' conditions" do
+    company = Company.create
+    user = company.users.create(:username => "bjohnson")
+    company.users.send(:username_or_some_type_id_like, "bjohnson").should == [user]
+  end
+    
+end
+

data/spec/searchlogic/active_record/consistency_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::ActiveRecord::Consistency do
+  it "should merge joins with consistent conditions" do
+    user_group = UserGroup.create
+    user_group.users.user_groups_name_like("name").user_groups_id_gt(10).scope(:find)[:joins].should == [
+      "INNER JOIN \"user_groups_users\" ON \"user_groups_users\".user_id = \"users\".id",
+      "INNER JOIN \"user_groups\" ON \"user_groups\".id = \"user_groups_users\".user_group_id"
+    ]
+  end
+  
+  it "should respect parenthesis when reordering conditions" do
+    joins = [
+      "INNER JOIN \"table\" ON (\"b\".user_id = \"a\".id)",
+      "INNER JOIN \"table\" ON (\"b\".id = \"a\".user_group_id)"
+    ]
+    ActiveRecord::Base.send(:merge_joins, joins).should == [
+      "INNER JOIN \"table\" ON \"a\".id = \"b\".user_id",
+      "INNER JOIN \"table\" ON \"a\".user_group_id = \"b\".id"
+    ]
+  end
+  
+  it "shuold not convert joins to strings when delegating via associations" do
+    User.alias_scope :has_id_gt, lambda { User.id_gt(10).has_name.orders_id_gt(10) }
+    User.alias_scope :has_name, lambda { User.orders_created_at_after(Time.now).name_equals("ben").username_equals("ben") }
+    Company.users_has_id_gt.proxy_options[:joins].should == {:users=>[:orders]}
+  end
+end

data/spec/searchlogic/core_ext/object_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::CoreExt::Object do
+  it "should accept and pass the argument to the searchlogic_options" do
+    proc = searchlogic_lambda(:integer, :test => :value) {}
+    proc.searchlogic_options[:type].should == :integer
+    proc.searchlogic_options[:test].should == :value
+  end
+end

data/spec/searchlogic/core_ext/proc_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::CoreExt::Proc do
+  it "should have a searchlogic_options accessor" do
+    p = Proc.new {}
+    p.searchlogic_options[:type] = :integer
+  end
+end

data/spec/searchlogic/named_scopes/alias_scope_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Searchlogic::NamedScopes::AliasScope do
+  before(:each) do
+    User.alias_scope :username_has, lambda { |value| User.username_like(value) }
+  end
+  
+  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
+  
+  it "should inherit alias scopes from superclasses" do
+    Class.new(User).alias_scope?("username_has").should be_true
+  end
+end