activerecord-deprecated_finders 0.0.1

data/lib/active_record/deprecated_finders/relation.rb

@@ -0,0 +1,176 @@
+require 'active_record/relation'
+require 'active_support/core_ext/module/aliasing'
+
+module ActiveRecord
+  class Relation
+    module DeprecatedMethods
+      VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :extend,
+                             :order, :select, :readonly, :group, :having, :from, :lock ]
+
+      # The silence_deprecation arg is for internal use, where we have already output a
+      # deprecation further up the call stack.
+      def apply_finder_options(options, silence_deprecation = false)
+        ActiveSupport::Deprecation.warn("#apply_finder_options is deprecated") unless silence_deprecation
+
+        relation = clone
+        return relation unless options
+
+        options.assert_valid_keys(VALID_FIND_OPTIONS)
+        finders = options.dup
+        finders.delete_if { |key, value| value.nil? && key != :limit }
+
+        ((VALID_FIND_OPTIONS - [:conditions, :include, :extend]) & finders.keys).each do |finder|
+          relation = relation.send(finder, finders[finder])
+        end
+
+        relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
+        relation = relation.includes(finders[:include]) if options.has_key?(:include)
+        relation = relation.extending(finders[:extend]) if options.has_key?(:extend)
+
+        relation
+      end
+
+      def update_all_with_deprecated_options(updates, conditions = nil, options = {})
+        scope = self
+
+        if conditions
+          scope = where(conditions)
+
+          ActiveSupport::Deprecation.warn(
+            "Relation#update_all with conditions is deprecated. Please use " \
+            "Item.where(color: 'red').update_all(...) rather than " \
+            "Item.update_all(..., color: 'red')."
+          )
+        end
+
+        if options.present?
+          scope = scope.apply_finder_options(options.slice(:limit, :order), true)
+
+          ActiveSupport::Deprecation.warn(
+            "Relation#update_all with :limit / :order options is deprecated. " \
+            "Please use e.g. Post.limit(1).order(:foo).update_all instead."
+          )
+        end
+
+        scope.update_all_without_deprecated_options(updates)
+      end
+
+      def find_in_batches(options = {}, &block)
+        if (finder_options = options.except(:start, :batch_size)).present?
+          ActiveSupport::Deprecation.warn(
+            "Relation#find_in_batches with finder options is deprecated. Please build " \
+            "a scope and then call find_in_batches on it instead."
+          )
+
+          raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
+          raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit].present?
+
+          apply_finder_options(finder_options, true).
+            find_in_batches(options.slice(:start, :batch_size), &block)
+        else
+          super
+        end
+      end
+
+      def calculate(operation, column_name, options = {})
+        if options.except(:distinct).present?
+          ActiveSupport::Deprecation.warn(
+            "Relation#calculate with finder options is deprecated. Please build " \
+            "a scope and then call find_in_batches on it instead."
+          )
+
+          apply_finder_options(options.except(:distinct), true)
+            .calculate(operation, column_name, :distinct => options[:distinct])
+        else
+          super
+        end
+      end
+
+      def find(*args)
+        options = args.extract_options!
+
+        if options.present?
+          scope = apply_finder_options(options, true)
+
+          case finder = args.first
+          when :first, :last, :all
+            ActiveSupport::Deprecation.warn(
+              "Calling #find(#{finder.inspect}) is deprecated. Please call " \
+              "##{finder} directly instead. You have also used finder options. " \
+              "These are also deprecated. Please build a scope instead of using " \
+              "finder options."
+            )
+
+            scope.send(finder)
+          else
+            ActiveSupport::Deprecation.warn(
+              "Passing options to #find is deprecated. Please build a scope " \
+              "and then call #find on it."
+            )
+
+            scope.find(*args)
+          end
+        else
+          case finder = args.first
+          when :first, :last, :all
+            ActiveSupport::Deprecation.warn(
+              "Calling #find(#{finder.inspect}) is deprecated. Please call " \
+              "##{finder} directly instead."
+            )
+
+            send(finder)
+          else
+            super
+          end
+        end
+      end
+
+      def first(*args)
+        if args.empty?
+          super
+        else
+          if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
+            super
+          else
+            ActiveSupport::Deprecation.warn(
+              "Relation#first with finder options is deprecated. Please build " \
+              "a scope and then call #first on it instead."
+            )
+
+            apply_finder_options(args.first, true).first
+          end
+        end
+      end
+
+      def last(*args)
+        if args.empty?
+          super
+        else
+          if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
+            super
+          else
+            ActiveSupport::Deprecation.warn(
+              "Relation#last with finder options is deprecated. Please build " \
+              "a scope and then call #last on it instead."
+            )
+
+            apply_finder_options(args.first, true).last
+          end
+        end
+      end
+
+      def all(*args)
+        ActiveSupport::Deprecation.warn(
+          "Relation#all is deprecated. If you want to eager-load a relation, you can " \
+          "call #load (e.g. `Post.where(published: true).load`). If you want " \
+          "to get an array of records from a relation, you can call #to_a (e.g. " \
+          "`Post.where(published: true).to_a`)."
+        )
+        apply_finder_options(args.first, true).to_a
+      end
+    end
+
+    include DeprecatedMethods
+    alias_method_chain :update_all, :deprecated_options
+  end
+end

data/lib/active_record/deprecated_finders/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module DeprecatedFinders
+    VERSION = "0.0.1"
+  end
+end

data/test/associations_test.rb

@@ -0,0 +1,67 @@
+require 'helper'
+
+describe 'associations' do
+  before do
+    @klass = Class.new(ActiveRecord::Base)
+    def @klass.name; 'Post'; end
+    @klass.table_name = 'posts'
+  end
+
+  it 'translates hash scope options into scopes' do
+    extension = Module.new
+
+    assert_deprecated do
+      @klass.has_many :comments, readonly: 'a', order: 'b', limit: 'c', group: 'd', having: 'e',
+                                 offset: 'f', select: 'g', uniq: 'h', include: 'i', conditions: 'j',
+                                 extend: extension
+    end
+
+    scope = @klass.new.comments
+
+    scope.readonly_value.must_equal 'a'
+    scope.order_values.must_equal ['b']
+    scope.limit_value.must_equal 'c'
+    scope.group_values.must_equal ['d']
+    scope.having_values.must_equal ['e']
+    scope.offset_value.must_equal 'f'
+    scope.select_values.must_equal ['g']
+    scope.uniq_value.must_equal 'h'
+    scope.includes_values.must_equal ['i']
+    scope.where_values.must_include 'j'
+    scope.extensions.must_equal [extension]
+  end
+
+  it 'supports proc where values' do
+    ActiveSupport::Deprecation.silence do
+      @klass.has_many :comments, conditions: proc { 'omg' }
+    end
+    @klass.new.comments.where_values.must_include 'omg'
+    @klass.joins(:comments).to_sql.must_include 'omg'
+  end
+
+  it 'supports proc where values which access the owner' do
+    ActiveSupport::Deprecation.silence do
+      @klass.has_many :comments, conditions: proc { title }
+    end
+    @klass.new(title: 'omg').comments.where_values.must_include 'omg'
+  end
+
+  it 'allows an extend option plus a block extension' do
+    mod = Module.new { def foo; 'foo'; end }
+    ActiveSupport::Deprecation.silence do
+      @klass.has_many(:comments, extend: mod) { def bar; 'bar'; end }
+    end
+
+    obj = @klass.new
+    obj.comments.foo.must_equal 'foo'
+    obj.comments.bar.must_equal 'bar'
+  end
+
+  it "allows a declaration with a scope with no options" do
+    ActiveSupport::Deprecation.silence do
+      @klass.has_many :comments, -> { limit 5 }
+    end
+    scope = @klass.new.comments
+    scope.limit_value.must_equal 5
+  end
+end

data/test/calculate_test.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+describe 'calculate' do
+  after do
+    Post.destroy_all
+  end
+
+  it 'supports finder options' do
+    Post.create id: 1
+    Post.create id: 2, title: 'foo'
+    Post.create id: 3, title: 'foo'
+
+    assert_deprecated { Post.calculate(:sum, :id, conditions: { title: 'foo' }) }.must_equal 5
+  end
+end

data/test/default_scope_test.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+describe 'default scope' do
+  before do
+    Post.create(id: 1, title: 'foo lol')
+    Post.create(id: 2, title: 'foo omg')
+    Post.create(id: 3)
+
+    @klass = Class.new(Post)
+    @klass.table_name = 'posts'
+  end
+
+  after do
+    Post.delete_all
+  end
+
+  it 'works with a finder hash' do
+    assert_deprecated { @klass.default_scope conditions: { id: 1 } }
+    @klass.all.map(&:id).must_equal [1]
+  end
+
+  it 'works with a finder hash and a scope' do
+    @klass.default_scope { @klass.where("title like '%foo%'") }
+    ActiveSupport::Deprecation.silence do
+      @klass.default_scope conditions: "title like '%omg%'"
+    end
+
+    @klass.all.map(&:id).must_equal [2]
+  end
+
+  it 'works with a block that returns a hash' do
+    @klass.default_scope { { conditions: { id: 1 } } }
+    assert_deprecated { @klass.all.to_a }.map(&:id).must_equal [1]
+  end
+end

data/test/dynamic_methods_test.rb

@@ -0,0 +1,133 @@
+require 'helper'
+
+describe 'dynamic_methods' do
+  before do
+    @posts = [
+      Post.create(title: 'foo', category: '1'),
+      Post.create(title: 'bar', category: '1'),
+      Post.create(title: 'bar', category: '2')
+    ]
+  end
+
+  after do
+    Post.delete_all
+    Comment.delete_all
+  end
+
+  it 'supports find_all_by' do
+    assert_deprecated do
+      Post.find_all_by_title('bar').must_equal [@posts[1], @posts[2]]
+      Post.find_all_by_title_and_category('bar', '2').must_equal [@posts[2]]
+    end
+  end
+
+  it 'supports find_all_by with finder options' do
+    assert_deprecated do
+      Post.find_all_by_title('bar', conditions: { category: '1' }).must_equal [@posts[1]]
+    end
+  end
+
+  it 'supports find_last_by' do
+    assert_deprecated do
+      Post.find_last_by_title('foo').must_equal @posts[0]
+      Post.find_last_by_title('bar').must_equal @posts[2]
+    end
+  end
+
+  it 'supports find_last_by with finder options' do
+    assert_deprecated do
+      Post.find_last_by_title('bar', conditions: { category: '1' }).must_equal @posts[1]
+    end
+  end
+
+  it 'supports scoped_by' do
+    scope = assert_deprecated { Post.scoped_by_title('bar') }
+    scope.is_a?(ActiveRecord::Relation).must_equal true
+    scope.to_a.must_equal [@posts[1], @posts[2]]
+  end
+
+  it 'supports find_or_initialize_by' do
+    assert_deprecated { Post.find_or_initialize_by_title_and_category('bar', '1').must_equal @posts[1] }
+
+    post = assert_deprecated { Post.find_or_initialize_by_title_and_category('bar', '3') }
+    post.new_record?.must_equal true
+    post.title.must_equal 'bar'
+    post.category.must_equal '3'
+  end
+
+  it 'supports find_or_create_by' do
+    assert_deprecated { Post.find_or_create_by_title_and_category('bar', '1').must_equal @posts[1] }
+
+    post = assert_deprecated { Post.find_or_create_by_title_and_category('bar', '3') }
+    post.new_record?.must_equal false
+    post.title.must_equal 'bar'
+    post.category.must_equal '3'
+  end
+
+  it 'supports find_or_create_by!' do
+    assert_deprecated { Post.find_or_create_by_title_and_category!('bar', '1').must_equal @posts[1] }
+
+    post = assert_deprecated { Post.find_or_create_by_title_and_category!('bar', '3') }
+    post.new_record?.must_equal false
+    post.title.must_equal 'bar'
+    post.category.must_equal '3'
+
+    klass = Class.new(ActiveRecord::Base)
+    def klass.name; 'Post'; end
+    klass.table_name = 'posts'
+    klass.validates_presence_of :category
+
+    lambda {
+      ActiveSupport::Deprecation.silence { klass.find_or_create_by_title!('z') }
+    }.must_raise ActiveRecord::RecordInvalid
+  end
+
+  it 'supports find_by with finder options' do
+    assert_deprecated do
+      Post.find_by_title('bar', conditions: { category: '2' }).must_equal @posts[2]
+    end
+  end
+
+  it 'supports find_by! with finder options' do
+    assert_deprecated do
+      Post.find_by_title!('bar', conditions: { category: '2' }).must_equal @posts[2]
+    end
+
+    lambda {
+      assert_deprecated { Post.find_by_title!('bar', conditions: { category: '3' }) }
+    }.must_raise ActiveRecord::RecordNotFound
+  end
+
+  it 'supports find_by with a block' do
+    assert_deprecated do
+      Post.find_by_title('foo') { |r| [r, 'block'] }.must_equal [@posts[0], 'block']
+      Post.find_by_title('baz') { |r| [r, 'block'] }.must_equal nil
+    end
+  end
+
+  it 'supports find_by! with a block' do
+    assert_deprecated do
+      Post.find_by_title!('foo') { |r| [r, 'block'] }.must_equal [@posts[0], 'block']
+    end
+  end
+
+  it 'adds to an association when find_or_initialize_by is called' do
+    post = @posts.first
+    comment = ActiveSupport::Deprecation.silence { post.comments.find_or_initialize_by_title('omg') }
+    post.comments.must_equal [comment]
+  end
+
+  it 'adds to an association when find_or_create_by is called' do
+    post = @posts.first
+    post.comments.load_target
+
+    comment = ActiveSupport::Deprecation.silence { post.comments.find_or_create_by_title('omg') }
+    post.comments.must_equal [comment]
+    post.reload.comments.must_equal [comment]
+  end
+
+  it "doesn't mess with method_missing for non-find_or_{initialize|create}_by methods" do
+    post = @posts.first
+    post.comments.lol.must_equal 'lol'
+  end
+end

data/test/find_in_batches_test.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+describe 'find_in_batches' do
+  after do
+    Post.destroy_all
+  end
+
+  it 'accepts finder options' do
+    foo = Post.create title: 'foo'
+    Post.create title: 'bar'
+
+    assert_deprecated do
+      Post.find_in_batches(conditions: "title = 'foo'") do |records|
+        records.must_equal [foo]
+      end
+    end
+  end
+end