searchlogic 2.4.25 → 2.4.26

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 2
 :minor: 4
-:patch: 25
+:patch: 26
 :build: 

data/lib/searchlogic.rb

@@ -9,6 +9,15 @@ 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/base"
+require "searchlogic/search/conditions"
+require "searchlogic/search/date_parts"
+require "searchlogic/search/implementation"
+require "searchlogic/search/method_missing"
+require "searchlogic/search/ordering"
+require "searchlogic/search/scopes"
+require "searchlogic/search/to_yaml"
+require "searchlogic/search/unknown_condition_error"
 require "searchlogic/search"
 
 Proc.send(:include, Searchlogic::CoreExt::Proc)

data/lib/searchlogic/search.rb

@@ -15,245 +15,12 @@ module Searchlogic
   #
   #   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, 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
-      @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
-    
-    def compact_conditions
-      conditions.select { |k,v| !v.blank? }
-    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)
-        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 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
-    
-    def respond_to?(*args)
-      super || scope?(normalize_scope_name(args.first))
-    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
+    include Base
+    include Conditions
+    include DateParts
+    include MethodMissing
+    include Scopes
+    include Ordering
+    include ToYaml
   end
 end

data/lib/searchlogic/search/base.rb

@@ -0,0 +1,26 @@
+module Searchlogic
+  class Search
+    module Base
+      def self.included(klass)
+        klass.class_eval do
+          attr_accessor :klass, :current_scope
+          undef :id if respond_to?(:id)
+        end
+      end
+      
+      # 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
+    end
+  end
+end

data/lib/searchlogic/search/conditions.rb

@@ -0,0 +1,58 @@
+module Searchlogic
+  class Search
+    module Conditions
+      # Returns a hash of the current conditions set.
+      def conditions
+        mass_conditions.clone.merge(@conditions)
+      end
+
+      def compact_conditions
+        conditions.select { |k,v| !v.blank? }
+      end
+
+      # Accepts a hash of conditions.
+      def conditions=(values)
+        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)
+          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 do |name|
+          @conditions.delete(name.to_sym)
+          mass_conditions.delete(name)
+        end
+        self
+      end
+      
+      private
+        # 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 write_condition(name, value)
+          @conditions[name] = value
+        end
+
+        def read_condition(name)
+          @conditions[name]
+        end
+
+        def mass_conditions
+          @mass_conditions ||= {}
+        end
+        
+        def ignore_value?(value)
+          (value.is_a?(String) && value.blank?) || (value.is_a?(Array) && value.empty?)
+        end
+    end
+  end
+end

data/lib/searchlogic/search/date_parts.rb

@@ -0,0 +1,23 @@
+module Searchlogic
+  class Search
+    module DateParts
+      def conditions=(values)
+        values.clone.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
+        super
+      end
+    end
+  end
+end

data/lib/searchlogic/search/implementation.rb

@@ -0,0 +1,14 @@
+module Searchlogic
+  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, scope(:find), conditions)
+      end
+    end
+  end
+end

data/lib/searchlogic/search/method_missing.rb

@@ -0,0 +1,123 @@
+module Searchlogic
+  class Search
+    module MethodMissing
+      def respond_to?(*args)
+        super || scope?(normalize_scope_name(args.first))
+      rescue Searchlogic::NamedScopes::OrConditions::UnknownConditionError
+        false
+      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
+
+        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 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
+    end
+  end
+end

data/lib/searchlogic/search/ordering.rb

@@ -0,0 +1,10 @@
+module Searchlogic
+  class Search
+    module Ordering
+      # Returns the column we are currently ordering by
+      def ordering_by
+        order && order.to_s.gsub(/^(ascend|descend)_by_/, '')
+      end
+    end
+  end
+end

data/lib/searchlogic/search/scopes.rb

@@ -0,0 +1,19 @@
+module Searchlogic
+  class Search
+    module Scopes
+      private
+        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
+    end
+  end
+end

data/lib/searchlogic/search/to_yaml.rb

@@ -0,0 +1,38 @@
+module Searchlogic
+  class Search
+    module ToYaml
+      def self.included(klass)
+        klass.class_eval do
+          yaml_as "tag:ruby.yaml.org,2002:class"
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+      
+      module ClassMethods
+        def yaml_new(klass, tag, val)
+          raise "ass"
+        end
+      end
+      
+      module InstanceMethods
+        def to_yaml( opts = {} )
+          YAML::quick_emit( self, opts ) do |out|
+            out.map("tag:ruby.yaml.org,2002:object:Searchlogic::Search") do |map|
+              map.add('class_name', klass.name)
+              map.add('current_scope', current_scope)
+              map.add('conditions', conditions)
+            end
+          end
+        end
+        
+        def yaml_initialize(taguri, attributes = {})
+          self.klass = attributes["class_name"].constantize
+          self.current_scope = attributes["current_scope"]
+          @conditions ||= {}
+          self.conditions = attributes["conditions"]
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/search/unknown_condition_error.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  class Search
+    # 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
+  end
+end

data/searchlogic.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{searchlogic}
-  s.version = "2.4.25"
+  s.version = "2.4.26"
 
   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{2010-09-03}
+  s.date = %q{2010-09-10}
   s.description = %q{Searchlogic makes using ActiveRecord named scopes easier and less repetitive.}
   s.email = %q{bjohnson@binarylogic.com}
   s.extra_rdoc_files = [
@@ -37,6 +37,15 @@ Gem::Specification.new do |s|
      "lib/searchlogic/named_scopes/ordering.rb",
      "lib/searchlogic/rails_helpers.rb",
      "lib/searchlogic/search.rb",
+     "lib/searchlogic/search/base.rb",
+     "lib/searchlogic/search/conditions.rb",
+     "lib/searchlogic/search/date_parts.rb",
+     "lib/searchlogic/search/implementation.rb",
+     "lib/searchlogic/search/method_missing.rb",
+     "lib/searchlogic/search/ordering.rb",
+     "lib/searchlogic/search/scopes.rb",
+     "lib/searchlogic/search/to_yaml.rb",
+     "lib/searchlogic/search/unknown_condition_error.rb",
      "rails/init.rb",
      "searchlogic.gemspec",
      "spec/searchlogic/active_record/association_proxy_spec.rb",

data/spec/searchlogic/search_spec.rb

@@ -424,15 +424,18 @@ describe Searchlogic::Search do
   context "#respond_to?" do
     it "should respond to created_at_lte" do
       s = User.search
-      s.created_at_lte
       s.respond_to?(:created_at_lte).should == true
     end
     
     it "should respond to created_at" do
       s = User.search
-      s.created_at_lte
       s.respond_to?(:created_at).should == true
     end
+    
+    it "should not respond to created_at_or_whatever" do
+      s = User.search
+      s.respond_to?(:created_at_or_whatever)
+    end
   end
   
   context "delegation" do
@@ -478,4 +481,17 @@ describe Searchlogic::Search do
       search.paged(0, 0).count.should == 0
     end
   end
+  
+  context "yaml" do
+    it "should load yaml" do
+      time = Time.now
+      search = User.search(:name_like => "Ben", :created_at_after => time)
+      search.current_scope = {:conditions => "1=1"}
+      yaml = search.to_yaml
+      loaded_search = YAML.load(yaml)
+      loaded_search.current_scope.should == {:conditions => "1=1"}
+      loaded_search.name_like.should == "Ben"
+      loaded_search.created_at_after.should == time
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,10 +1,10 @@
 require 'spec'
 require 'rubygems'
-#require 'ruby-debug'
+require 'ruby-debug'
 require 'active_record'
 
 ENV['TZ'] = 'UTC'
-#Time.zone = 'Eastern Time (US & Canada)'
+Time.zone = 'Eastern Time (US & Canada)'
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 ActiveRecord::Base.configurations = true

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: searchlogic
 version: !ruby/object:Gem::Version 
-  hash: 45
   prerelease: false
   segments: 
   - 2
   - 4
-  - 25
-  version: 2.4.25
+  - 26
+  version: 2.4.26
 platform: ruby
 authors: 
 - Ben Johnson of Binary Logic
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-03 00:00:00 -04:00
+date: 2010-09-10 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
         segments: 
         - 2
         - 0
@@ -64,6 +62,15 @@ files:
 - lib/searchlogic/named_scopes/ordering.rb
 - lib/searchlogic/rails_helpers.rb
 - lib/searchlogic/search.rb
+- lib/searchlogic/search/base.rb
+- lib/searchlogic/search/conditions.rb
+- lib/searchlogic/search/date_parts.rb
+- lib/searchlogic/search/implementation.rb
+- lib/searchlogic/search/method_missing.rb
+- lib/searchlogic/search/ordering.rb
+- lib/searchlogic/search/scopes.rb
+- lib/searchlogic/search/to_yaml.rb
+- lib/searchlogic/search/unknown_condition_error.rb
 - rails/init.rb
 - searchlogic.gemspec
 - spec/searchlogic/active_record/association_proxy_spec.rb
@@ -92,7 +99,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -101,7 +107,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"