fake_arel 0.2 → 0.5

data/lib/fake_arel.rb

@@ -8,7 +8,7 @@ require 'fake_arel/with_scope_replacement'
 require 'fake_arel/rails_3_finders'
 
 module FakeArel
-  VERSION = '0.2'
+  VERSION = '0.5'
   ActiveRecord::Base.send :include, Rails3Finders
   ActiveRecord::Base.send :include, WithScopeReplacement
 end

data/lib/fake_arel/extensions.rb

@@ -6,26 +6,10 @@ module ActiveRecord
 
         scopes[name] = lambda do |parent_scope, *args|
           Scope.new(parent_scope, case options
-            when Hash
+            when Hash, Scope
               options
-            when Scope
-              # unspin the scope and generate a hash
-              local_scope = options.proxy_scope
-              ret = options.proxy_options
-              while local_scope.class == ActiveRecord::NamedScope::Scope
-                ret[:conditions] = merge_conditions(ret[:conditions], local_scope.proxy_options[:conditions])
-                ret[:includes] = merge_includes(ret[:includes], local_scope.proxy_options[:includes]) if ret[:includes] || local_scope.proxy_options[:includes]
-                ret[:joins] = merge_includes(ret[:joins], local_scope.proxy_options[:joins])
-                ret[:order] = merge_includes(ret[:order], local_scope.proxy_options[:order]) if ret[:order] || local_scope.proxy_options[:order]
-                local_scope = local_scope.proxy_scope
-              end
-              ret
             when Proc
-              if self.model_name != parent_scope.model_name
-                options.bind(parent_scope).call(*args)
-              else
-                options.call(*args)
-              end
+              options.call(*args)
           end, &block)
         end
 
@@ -36,92 +20,26 @@ module ActiveRecord
     end
 
     class Scope
-      attr_reader :proxy_scope, :proxy_options, :current_scoped_methods_when_defined
       undef select
-      [].methods.each do |m|
-        unless m =~ /^__/ || (NON_DELEGATE_METHODS + ['select']).include?(m.to_s)
-          delegate m, :to => :proxy_found
-        end
-      end
-
-      delegate :scopes, :with_scope, :scoped_methods, :to => :proxy_scope
 
+      alias initialize_without_arel initialize
       def initialize(proxy_scope, options = {}, &block)
-        options ||= {}
-        options = options.proxy_options if options.class == ActiveRecord::NamedScope::Scope
-        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
-        extend Module.new(&block) if block_given?
-        unless Scope === proxy_scope
-          @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods)
-        end
-        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
-      end
-
-      def reload
-        load_found; self
-      end
-
-      def first(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.first(*args)
-        else
-          find(:first, *args)
-        end
-      end
-
-      def last(*args)
-        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
-          proxy_found.last(*args)
-        else
-          find(:last, *args)
-        end
-      end
-
-      def size
-        @found ? @found.length : count
-      end
-
-      def empty?
-        @found ? @found.empty? : count.zero?
-      end
-
-      def respond_to?(method, include_private = false)
-        super || @proxy_scope.respond_to?(method, include_private)
-      end
-
-      def any?
-        if block_given?
-          proxy_found.any? { |*block_args| yield(*block_args) }
-        else
-          !empty?
-        end
-      end
-
-      protected
-      def proxy_found
-        @found || load_found
-      end
-
-      private
-      def method_missing(method, *args, &block)
-        if scopes.include?(method)
-          scopes[method].call(self, *args)
-        else
-          with_scope({:find => proxy_options, :create => proxy_options[:conditions].is_a?(Hash) ?  proxy_options[:conditions] : {}}, :reverse_merge) do
-            method = :new if method == :build
-            if current_scoped_methods_when_defined && !scoped_methods.include?(current_scoped_methods_when_defined)
-              with_scope current_scoped_methods_when_defined do
-                proxy_scope.send(method, *args, &block)
-              end
-            else
-              proxy_scope.send(method, *args, &block)
-            end
-          end
-        end
-      end
-
-      def load_found
-        @found = find(:all)
+        options = options.unspin if options.class == ActiveRecord::NamedScope::Scope
+        initialize_without_arel(proxy_scope, options, &block)
+      end
+
+      def unspin
+        # unspin the scope and generate a hash
+        local_scope = proxy_scope
+        ret = proxy_options
+        while local_scope.class == ActiveRecord::NamedScope::Scope
+          ret[:conditions] = merge_conditions(ret[:conditions], local_scope.proxy_options[:conditions])
+          ret[:includes] = merge_includes(ret[:includes], local_scope.proxy_options[:includes]) if ret[:includes] || local_scope.proxy_options[:includes]
+          ret[:joins] = merge_includes(ret[:joins], local_scope.proxy_options[:joins])
+          ret[:order] = [local_scope.proxy_options[:order], ret[:order]].select{|o| !o.blank?}.join(',') if ret[:order] || local_scope.proxy_options[:order]
+          local_scope = local_scope.proxy_scope
+        end
+        ret
       end
     end
 

data/lib/fake_arel/rails_3_finders.rb

@@ -7,8 +7,8 @@ module Rails3Finders
       named_scope :offset, lambda {|offset| {:offset => offset}}
       named_scope :limit, lambda {|limit| {:limit => limit}}
       named_scope :includes, lambda { |*includes| { :include => includes }}
-      named_scope :select, lambda {|*select| {:select => select }}
-      named_scope :order, lambda {|order| {:order => order }}
+      named_scope :select, lambda {|*select| {:select => select.join(',') }}
+      named_scope :order, lambda {|*order| {:order => order.join(',') }}
       named_scope :joins, lambda {|*join| {:joins => join }}
       named_scope :from, lambda {|*from| {:from => from }}
       named_scope :having, lambda {|*having| {:having => having }}

data/lib/fake_arel/with_scope_replacement.rb

@@ -5,7 +5,7 @@ module WithScopeReplacement
         def to_sql
           construct_finder_sql self.current_scoped_methods[:find]
         end
-
+        
         def with_scope(method_scoping = {}, action = :merge, &block)
           method_scoping = {:find => method_scoping.proxy_options} if method_scoping.class == ActiveRecord::NamedScope::Scope
           method_scoping = method_scoping.method_scoping if method_scoping.respond_to?(:method_scoping)
@@ -41,6 +41,10 @@ module WithScopeReplacement
                         hash[method][key] = merge_includes(hash[method][key], params[key]).uniq
                       elsif key == :joins && merge
                         hash[method][key] = merge_joins(params[key], hash[method][key])
+                      # see https://rails.lighthouseapp.com/projects/8994/tickets/2810-with_scope-should-accept-and-use-order-option
+                      # it works now in reverse order to comply with ActiveRecord 3
+                      elsif key == :order && merge && !default_scoping.any?{ |s| s[method].keys.include?(key) }
+                        hash[method][key] = [hash[method][key], params[key]].select{|o| !o.blank?}.join(', ')
                       else
                         hash[method][key] = hash[method][key] || params[key]
                       end
@@ -66,12 +70,6 @@ module WithScopeReplacement
             self.scoped_methods.pop
           end
         end
-
-        # Works like with_scope, but discards any nested properties.
-        def with_exclusive_scope(method_scoping = {}, &block)
-          with_scope(method_scoping, :overwrite, &block)
-        end
-
       end
     end
   end

data/spec/fake_arel_spec.rb

@@ -67,10 +67,35 @@ describe "chained nested named scopes" do
     Reply.topic_4_id_asc.all.should == Reply.find(:all, :conditions => {:topic_id => 4}, :order=>'id asc')
     Reply.topic_4_id_desc.all.should == Reply.find(:all, :conditions => {:topic_id => 4}, :order=>'id desc')
   end
+
+  it "should properly chain scope in definitions by lambda" do
+    Reply.recent_topic_id(4).all.should == Reply.find_all_by_id(5)
+  end
+    
+  it "should properly chain order scope in definitions by lambda" do
+    Reply.topic__id_asc(4).all.should == Reply.find(:all, :conditions => {:topic_id => 4}, :order=>'id asc')
+    Reply.order('id desc').topic_id(4).all.should == Reply.find(:all, :conditions => {:topic_id => 4}, :order=>'id desc')
+    Reply.topic__id_desc(4).all.should == Reply.find(:all, :conditions => {:topic_id => 4}, :order=>'id desc')
+  end
+  
+  it "should chain order scopes" do
+    # see https://rails.lighthouseapp.com/projects/8994/tickets/2810-with_scope-should-accept-and-use-order-option
+    # it works now in reverse order to comply with ActiveRecord 3
+    Reply.order('topic_id asc').order('created_at desc').all.should == Reply.find(:all, :order=>'topic_id asc, created_at desc')
+    Reply.order('topic_id asc').id_desc.all.should == Reply.find(:all, :order=>'topic_id asc, id desc')
+    Reply.topic_id_asc.id_desc.all.should == Reply.find(:all, :order=>'topic_id asc, id desc')
+    Reply.topic_id_asc_id_desc.all.should == Reply.find(:all, :order=>'topic_id asc, id desc')
+    Reply.lam_topic_id_asc_id_desc.all.should == Reply.find(:all, :order=>'topic_id asc, id desc')
+    Reply.with_scope(:find=>{:order=>'topic_id asc'}) do
+      Reply.with_scope(:find=>{:order=>'created_at desc'}) do
+        Reply.all
+      end
+    end.should == Reply.find(:all, :order=>'created_at desc, topic_id asc')
+  end
 end
 
 describe "keep scoped functionality" do
   it "should respond to scoped" do
-    Reply.scoped.class.should == ActiveRecord::NamedScope::Scope
+    Reply.scoped({}).class.should == ActiveRecord::NamedScope::Scope
   end
 end

data/spec/fixtures/reply.rb

@@ -19,6 +19,13 @@ class Reply < ActiveRecord::Base
   named_scope :id_desc, order('id desc')
   named_scope :topic_4_id_asc, id_asc.where(:topic_id => 4)
   named_scope :topic_4_id_desc, id_desc.where(:topic_id => 4)
+  named_scope :topic_id, lambda{|topic_id| where(:topic_id => topic_id)}
+  named_scope :recent_topic_id, lambda{|topic_id| recent.where(:topic_id => topic_id)}
+  named_scope :topic__id_asc, lambda{|topic_id| id_asc.where(:topic_id => topic_id)}
+  named_scope :topic__id_desc, lambda{|topic_id| id_desc.where(:topic_id => topic_id)}
+  named_scope :topic_id_asc, order('topic_id asc')
+  named_scope :topic_id_asc_id_desc, order('topic_id asc').id_desc
+  named_scope :lam_topic_id_asc_id_desc, lambda{ topic_id_asc.id_desc }
   
   validates_presence_of :content
 

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: fake_arel
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 1
   prerelease: false
   segments: 
   - 0
-  - 2
-  version: "0.2"
+  - 5
+  version: "0.5"
 platform: ruby
 authors: 
 - Grant Ammons
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-13 00:00:00 -04:00
+date: 2010-08-17 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency