activerecord-deprecated_finders 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+notifications:
+  email:
+    - j@jonathanleighton.com
+before_install:
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_deprecated_finders.gemspec
+gemspec
+
+if ENV['RAILS']
+  gem 'rails', path: ENV['RAILS']
+else
+  gem 'rails', git: 'git://github.com/rails/rails', branch: 'master'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jon Leighton
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,15 @@
+# Active Record Deprecated Finders
+
+This gem will be used to extract and deprecate old-style finder option
+hashes in Active Record:
+
+``` ruby
+Post.find(:all, conditions: { published_on: 2.weeks.ago }, limit: 5)
+```
+
+It will be a dependency of Rails 4.0 to provide the deprecated
+functionality.
+
+It will be removed as a dependency in Rails 4.1, but users can manually
+include it in their Gemfile and it will continue to be maintained until
+Rails 5.

data/Rakefile

@@ -0,0 +1,28 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ["test"]
+  t.pattern = "test/**/*_test.rb"
+  t.ruby_opts = ['-w']
+end
+
+task :default => :test
+
+specname = "activerecord-deprecated_finders.gemspec"
+deps = `git ls-files`.split("\n") - [specname]
+
+task :gemspec => specname
+
+file specname => deps do
+  files       = `git ls-files`.split("\n")
+  test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  require 'erb'
+
+  File.open specname, 'w:utf-8' do |f|
+    f.write ERB.new(File.read("#{specname}.erb")).result(binding)
+  end
+end

data/activerecord-deprecated_finders.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/active_record/deprecated_finders/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jon Leighton"]
+  gem.email         = ["j@jonathanleighton.com"]
+  gem.description   = %q{This gem contains deprecated finder APIs extracted from Active Record.}
+  gem.summary       = %q{This gem contains deprecated finder APIs extracted from Active Record.}
+  gem.homepage      = "https://github.com/rails/activerecord-deprecated_finders"
+
+  gem.files         = [".gitignore",".travis.yml","Gemfile","LICENSE","README.md","Rakefile","activerecord-deprecated_finders.gemspec","lib/active_record/deprecated_finders.rb","lib/active_record/deprecated_finders/association_builder.rb","lib/active_record/deprecated_finders/base.rb","lib/active_record/deprecated_finders/collection_proxy.rb","lib/active_record/deprecated_finders/dynamic_matchers.rb","lib/active_record/deprecated_finders/relation.rb","lib/active_record/deprecated_finders/version.rb","test/associations_test.rb","test/calculate_test.rb","test/default_scope_test.rb","test/dynamic_methods_test.rb","test/find_in_batches_test.rb","test/finder_options_test.rb","test/finder_test.rb","test/helper.rb","test/scope_test.rb","test/scoped_test.rb","test/update_all_test.rb","test/with_scope_test.rb"]
+  gem.test_files    = ["test/associations_test.rb","test/calculate_test.rb","test/default_scope_test.rb","test/dynamic_methods_test.rb","test/find_in_batches_test.rb","test/finder_options_test.rb","test/finder_test.rb","test/helper.rb","test/scope_test.rb","test/scoped_test.rb","test/update_all_test.rb","test/with_scope_test.rb"]
+  gem.executables   = []
+  gem.name          = "activerecord-deprecated_finders"
+  gem.require_paths = ["lib"]
+  gem.version       = ActiveRecord::DeprecatedFinders::VERSION
+
+  gem.add_development_dependency 'minitest',     '>= 3'
+  gem.add_development_dependency 'activerecord', '~> 4.0.0.beta'
+  gem.add_development_dependency 'sqlite3',      '~> 1.3'
+end

data/lib/active_record/deprecated_finders.rb

@@ -0,0 +1,10 @@
+require 'active_support/lazy_load_hooks'
+require 'active_record/deprecated_finders/version'
+
+ActiveSupport.on_load(:active_record) do
+  require 'active_record/deprecated_finders/base'
+  require 'active_record/deprecated_finders/relation'
+  require 'active_record/deprecated_finders/dynamic_matchers'
+  require 'active_record/deprecated_finders/collection_proxy'
+  require 'active_record/deprecated_finders/association_builder'
+end

data/lib/active_record/deprecated_finders/association_builder.rb

@@ -0,0 +1,78 @@
+require 'active_record/associations/builder/association'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/deprecation'
+
+module ActiveRecord::Associations::Builder
+  class DeprecatedOptionsProc
+    attr_reader :options
+
+    def initialize(options)
+      options[:includes]  = options.delete(:include)    if options[:include]
+      options[:where]     = options.delete(:conditions) if options[:conditions]
+      options[:extending] = options.delete(:extend)     if options[:extend]
+
+      @options = options
+    end
+
+    def to_proc
+      options = self.options
+      proc do |owner|
+        if options[:where].respond_to?(:to_proc)
+          context = owner || self
+          where(context.instance_eval(&options[:where]))
+            .merge!(options.except(:where))
+        else
+          merge(options)
+        end
+      end
+    end
+
+    def arity
+      1
+    end
+  end
+
+  class Association
+    DEPRECATED_OPTIONS = [:readonly, :order, :limit, :group, :having,
+                          :offset, :select, :uniq, :include, :conditions, :extend]
+
+    self.valid_options += [:select, :conditions, :include, :extend, :readonly]
+
+    def initialize_with_deprecated_options(model, name, scope, options)
+      if scope.is_a?(Hash)
+        options            = scope
+        deprecated_options = options.slice(*DEPRECATED_OPTIONS)
+
+        if deprecated_options.empty?
+          scope = nil
+        else
+          ActiveSupport::Deprecation.warn(
+            "The following options in your #{model.name}.#{macro} :#{name} declaration are deprecated: " \
+            "#{deprecated_options.keys.map(&:inspect).join(',')}. Please use a scope block instead. " \
+            "For example, the following:\n" \
+            "\n" \
+            "    has_many :spam_comments, conditions: { spam: true }, class_name: 'Comment'\n" \
+            "\n" \
+            "should be rewritten as the following:\n" \
+            "\n" \
+            "    has_many :spam_comments, -> { where spam: true }, class_name: 'Comment'\n"
+          )
+          scope   = DeprecatedOptionsProc.new(deprecated_options)
+          options = options.except(*DEPRECATED_OPTIONS)
+        end
+      end
+
+      initialize_without_deprecated_options(model, name, scope, options)
+    end
+
+    alias_method_chain :initialize, :deprecated_options
+  end
+
+  class CollectionAssociation
+    include Module.new {
+      def valid_options
+        super + [:order, :group, :having, :limit, :offset, :uniq]
+      end
+    }
+  end
+end

data/lib/active_record/deprecated_finders/base.rb

@@ -0,0 +1,151 @@
+require 'active_support/deprecation'
+
+module ActiveRecord
+  module DeprecatedFinders
+    class ScopeWrapper
+      def self.wrap(klass, scope)
+        if scope.is_a?(Hash)
+          ActiveSupport::Deprecation.warn(
+            "Calling #scope or #default_scope with a hash is deprecated. Please use a lambda " \
+            "containing a scope. E.g. scope :red, -> { where(color: 'red') }"
+          )
+
+          new(klass, scope)
+        elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
+          new(klass, scope)
+        else
+          scope
+        end
+      end
+
+      def initialize(klass, scope)
+        @klass = klass
+        @scope = scope
+      end
+
+      def call(*args)
+        if @scope.respond_to?(:call)
+          result = @scope.call(*args)
+
+          if result.is_a?(Hash)
+            msg = "Returning a hash from a #scope or #default_scope block is deprecated. Please " \
+              "return an actual scope object instead. E.g. scope :red, -> { where(color: 'red') } " \
+              "rather than scope :red, -> { { conditions: { color: 'red' } } }. "
+
+            if @scope.respond_to?(:source_location)
+              msg << "(The scope was defined at #{@scope.source_location.join(':')}.)"
+            end
+
+            ActiveSupport::Deprecation.warn(msg)
+          end
+        else
+          result = @scope
+        end
+
+        if result.is_a?(Hash)
+          @klass.unscoped.apply_finder_options(result, true)
+        else
+          result
+        end
+      end
+    end
+
+    def default_scope(scope = {}, &block)
+      if block_given?
+        super ScopeWrapper.new(self, block), &nil
+      else
+        super ScopeWrapper.wrap(self, scope)
+      end
+    end
+
+    def scoped(options = nil)
+      ActiveSupport::Deprecation.warn("Model.scoped is deprecated. Please use Model.all instead.")
+      options ? all.apply_finder_options(options, true) : all
+    end
+
+    def all(options = nil)
+      options ? super().all(options) : super()
+    end
+
+    def scope(name, body = {}, &block)
+      super(name, ScopeWrapper.wrap(self, body), &block)
+    end
+
+    def with_scope(scope = {}, action = :merge)
+      ActiveSupport::Deprecation.warn(
+        "ActiveRecord::Base#with_scope and #with_exclusive_scope are deprecated. " \
+        "Please use ActiveRecord::Relation#scoping instead. (You can use #merge " \
+        "to merge multiple scopes together.)"
+      )
+
+      # If another Active Record class has been passed in, get its current scope
+      scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
+
+      previous_scope = self.current_scope
+
+      if scope.is_a?(Hash)
+        # Dup first and second level of hash (method and params).
+        scope = scope.dup
+        scope.each do |method, params|
+          scope[method] = params.dup unless params == true
+        end
+
+        scope.assert_valid_keys([ :find, :create ])
+        relation = construct_finder_arel(scope[:find] || {})
+        relation.default_scoped = true unless action == :overwrite
+
+        if previous_scope && previous_scope.create_with_value && scope[:create]
+          scope_for_create = if action == :merge
+            previous_scope.create_with_value.merge(scope[:create])
+          else
+            scope[:create]
+          end
+
+          relation = relation.create_with(scope_for_create)
+        else
+          scope_for_create = scope[:create]
+          scope_for_create ||= previous_scope.create_with_value if previous_scope
+          relation = relation.create_with(scope_for_create) if scope_for_create
+        end
+
+        scope = relation
+      end
+
+      scope = previous_scope.merge(scope) if previous_scope && action == :merge
+      scope.scoping { yield }
+    end
+
+    protected
+
+    # Works like with_scope, but discards any nested properties.
+    def with_exclusive_scope(method_scoping = {}, &block)
+      if method_scoping.values.any? { |e| e.is_a?(ActiveRecord::Relation) }
+        raise ArgumentError, <<-MSG
+New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
+
+User.unscoped.where(:active => true)
+
+Or call unscoped with a block:
+
+User.unscoped do
+User.where(:active => true).all
+end
+
+MSG
+      end
+      with_scope(method_scoping, :overwrite, &block)
+    end
+
+    private
+
+    def construct_finder_arel(options = {}, scope = nil)
+      relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options, true) : options
+      relation = scope.merge(relation) if scope
+      relation
+    end
+  end
+
+  class Base
+    extend DeprecatedFinders
+  end
+end

data/lib/active_record/deprecated_finders/collection_proxy.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module Associations
+    class CollectionProxy
+      module InterceptDynamicInstantiators
+        def method_missing(method, *args, &block)
+          match = DynamicMatchers::Method.match(klass, method)
+
+          if match && match.is_a?(DynamicMatchers::Instantiator)
+            scoping do
+              klass.send(method, *args) do |record|
+                proxy_association.add_to_target(record)
+                yield record if block_given?
+              end
+            end
+          else
+            super
+          end
+        end
+      end
+
+      def self.inherited(subclass)
+        subclass.class_eval do
+          # Ensure this get included first
+          include ActiveRecord::Delegation::ClassSpecificRelation
+
+          # Now override the method_missing definition
+          include InterceptDynamicInstantiators
+        end
+      end
+    end
+  end
+end

data/lib/active_record/deprecated_finders/dynamic_matchers.rb

@@ -0,0 +1,204 @@
+require 'active_support/deprecation'
+
+module ActiveRecord
+  module DynamicMatchers
+    module DeprecatedFinder
+      def body
+        <<-CODE
+          result = #{super}
+          result && block_given? ? yield(result) : result
+        CODE
+      end
+
+      def result
+        "all.apply_finder_options(options, true).#{super}"
+      end
+
+      def signature
+        "#{super}, options = {}"
+      end
+    end
+
+    module DeprecationWarning
+      def body
+        "#{deprecation_warning}\n#{super}"
+      end
+
+      def deprecation_warning
+        %{ActiveSupport::Deprecation.warn("This dynamic method is deprecated. Please use e.g. #{deprecation_alternative} instead.")}
+      end
+    end
+
+    module FindByDeprecationWarning
+      def body
+        <<-CODE
+          if block_given?
+            ActiveSupport::Deprecation.warn("Calling find_by or find_by! methods with a block is deprecated with no replacement.")
+          end
+
+          unless options.empty?
+            ActiveSupport::Deprecation.warn(
+              "Calling find_by or find_by! methods with options is deprecated. " \
+              "Build a scope instead, e.g. User.where('age > 21').find_by_name('Jon')."
+            )
+          end
+
+          #{super}
+        CODE
+      end
+    end
+
+    class FindBy
+      include DeprecatedFinder
+      include FindByDeprecationWarning
+    end
+
+    class FindByBang
+      include DeprecatedFinder
+      include FindByDeprecationWarning
+    end
+
+    class FindAllBy < Method
+      Method.matchers << self
+      include Finder
+      include DeprecatedFinder
+      include DeprecationWarning
+
+      def self.prefix
+        "find_all_by"
+      end
+
+      def finder
+        "where"
+      end
+
+      def result
+        "#{super}.to_a"
+      end
+
+      def deprecation_alternative
+        "Post.where(...).all"
+      end
+    end
+
+    class FindLastBy < Method
+      Method.matchers << self
+      include Finder
+      include DeprecatedFinder
+      include DeprecationWarning
+
+      def self.prefix
+        "find_last_by"
+      end
+
+      def finder
+        "where"
+      end
+
+      def result
+        "#{super}.last"
+      end
+
+      def deprecation_alternative
+        "Post.where(...).last"
+      end
+    end
+
+    class ScopedBy < Method
+      Method.matchers << self
+      include Finder
+      include DeprecationWarning
+
+      def self.prefix
+        "scoped_by"
+      end
+
+      def body
+        "#{deprecation_warning} \n where(#{attributes_hash})"
+      end
+
+      def deprecation_alternative
+        "Post.where(...)"
+      end
+    end
+
+    class Instantiator < Method
+      include DeprecationWarning
+
+      def self.dispatch(klass, attribute_names, instantiator, args, block)
+        if args.length == 1 && args.first.is_a?(Hash)
+          attributes = args.first.stringify_keys
+          conditions = attributes.slice(*attribute_names)
+          rest       = [attributes.except(*attribute_names)]
+        else
+          raise ArgumentError, "too few arguments" unless args.length >= attribute_names.length
+
+          conditions = Hash[attribute_names.map.with_index { |n, i| [n, args[i]] }]
+          rest       = args.drop(attribute_names.length)
+        end
+
+        klass.where(conditions).first ||
+          klass.create_with(conditions).send(instantiator, *rest, &block)
+      end
+
+      def signature
+        "*args, &block"
+      end
+
+      def body
+        <<-CODE
+          #{deprecation_warning}
+          #{self.class}.dispatch(self, #{attribute_names.inspect}, #{instantiator.inspect}, args, block)
+        CODE
+      end
+
+      def instantiator
+        raise NotImplementedError
+      end
+
+      def deprecation_alternative
+        "Post.#{self.class.prefix}#{self.class.suffix}(name: 'foo')"
+      end
+    end
+
+    class FindOrInitializeBy < Instantiator
+      Method.matchers << self
+
+      def self.prefix
+        "find_or_initialize_by"
+      end
+
+      def instantiator
+        "new"
+      end
+    end
+
+    class FindOrCreateBy < Instantiator
+      Method.matchers << self
+
+      def self.prefix
+        "find_or_create_by"
+      end
+
+      def instantiator
+        "create"
+      end
+    end
+
+    class FindOrCreateByBang < Instantiator
+      Method.matchers << self
+
+      def self.prefix
+        "find_or_create_by"
+      end
+
+      def self.suffix
+        "!"
+      end
+
+      def instantiator
+        "create!"
+      end
+    end
+  end
+end