active-record-ex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 510af257c830989c351130a6613f9320e7f18e4c
+  data.tar.gz: 91e4ae0a1b8da4acee5c958cd28d76ca6f3444e6
+SHA512:
+  metadata.gz: 98f6ac04aec0f9c0a4142f569be1e794f4cc7b288415db89d41791568028167f4100d33bd2924c21148f6410861d2be2c8f2e106de0bd5de90bdfd7a641d60a3
+  data.tar.gz: 530f2749ba17228e2a812acae3c84d3a142da31550f20579b118f723de3dcc0b850d87218dff9388b0aad9920a1c4e339fc87a5387687f5e5e320a8509513107

data/.gitignore

@@ -0,0 +1,35 @@
+# Created by .ignore support plugin (hsz.mobi)
+
+### Ruby template
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+.idea
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+ Gemfile.lock
+ .ruby-version
+ .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.1.2
+cache:
+  bundler: true

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active-record-ex.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 PagerDuty, Inc.
+
+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,39 @@
+# ActiveRecordEx
+
+A library to make `ActiveRecord::Relation`s even more awesome.
+
+[![Build Status](https://travis-ci.org/PagerDuty/active-record-ex.svg?branch=master)](https://travis-ci.org/PagerDuty/active-record-ex)
+
+`ActiveRecordEx` is made of several [modules](#modules) that are used by `include`ing them on your `ActiveRecord` model classes.
+
+#### Compatibility
+
+Currently, only ActiveRecord 3.2 with Ruby 2.1 is supported. However, other versions have not been tested and may be compatible.
+
+## Modules
+
+### `AssocOrdering`
+
+Extends setters for `has_many` associations so that ordering of association arrays is persisted.
+
+### `AssumeDestroy`
+
+Changes the behavior of `accepts_nested_attributes_for` so that an explicit `_destroy: true` is not required to destroy an association model.
+
+Instead, all models in the association will be destroyed if they are not included in the set of models used to update the association.
+
+### `ManyToMany`
+
+Allows chaining of calls to `has_many` and `belongs_to` relationships.
+
+### `NillableFind`
+
+Allows you to treat passing `nil` to a parent association as representing the "parent" of all of the child associations without a parent association.
+
+### `PolymorphicBuild`
+
+Allows choosing the subclass of a model in an association via a passed `:type` parameter, useful for `accepts_nested_attributes_for` on a polymorphic association.
+
+## Development
+
+Run tests with `rake test`.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc 'Run tests'
+task default: :test

data/active-record-ex.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record_ex/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'active-record-ex'
+  spec.version       = ActiveRecordEx::VERSION
+  spec.authors       = ['Arjun Kavi', 'PagerDuty']
+  spec.email         = ['arjun.kavi@gmail.com', 'developers@pagerduty.com']
+  spec.license       = 'MIT'
+  spec.summary       = 'Relation -> Relation methods'
+  spec.description   = 'A library to make ActiveRecord::Relations even more awesome'
+  spec.homepage      = 'https://github.com/PagerDuty/active-record-ex'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'shoulda'
+  spec.add_development_dependency 'mocha'
+
+  spec.add_runtime_dependency 'activesupport', '~> 3.2'
+  spec.add_runtime_dependency 'activerecord', '~> 3.2'
+end

data/lib/active_record_ex.rb

@@ -0,0 +1,5 @@
+require 'active_record_ex/version'
+require 'active_record_ex/relation_extensions'
+require 'active_record_ex/assoc_ordering'
+require 'active_record_ex/assume_destroy'
+require 'active_record_ex/many_to_many'

data/lib/active_record_ex/assoc_ordering.rb

@@ -0,0 +1,57 @@
+# Extends setters for has_many associations
+# So that ordering of association arrays is persisted
+module ActiveRecordEx
+  module AssocOrdering
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def has_many(assoc_name, options = {}, &extension)
+        order_field = options.delete(:order_on)
+        super
+        return unless order_field
+
+        define_model_setter(assoc_name, order_field)
+      end
+
+      def accepts_nested_attributes_for(assoc_name, options = {})
+        order_field = options.delete(:order_on)
+        allow_destroy = options[:allow_destroy] || options[:assume_destroy]
+        super
+        return unless order_field
+
+        define_attribute_setter(assoc_name, order_field, allow_destroy)
+      end
+
+      protected
+
+      def define_model_setter(assoc_name, order_field)
+        setter_name = "#{assoc_name}="
+        unordering_setter_name = "#{assoc_name}_without_ordering="
+        ordering_setter_name = "#{assoc_name}_with_ordering="
+
+        define_method(ordering_setter_name) do |models|
+          models.each_with_index{ |m, i| m.send("#{order_field}=", i + 1) }
+          self.send(unordering_setter_name, models)
+        end
+        alias_method_chain setter_name, :ordering
+      end
+
+      def define_attribute_setter(assoc_name, order_field, allow_destroy)
+        attrs_name = "#{assoc_name}_attributes"
+        setter_name = "#{attrs_name}="
+        unordering_setter_name = "#{attrs_name}_without_ordering="
+        ordering_setter_name = "#{attrs_name}_with_ordering="
+
+        define_method(ordering_setter_name) do |attrs|
+          new_attrs = attrs
+          new_attrs = attrs.reject{ |a| a[:_destroy] } if allow_destroy
+          new_attrs.each_with_index{ |a, i| a[order_field] = i + 1 }
+          self.send(unordering_setter_name, attrs)
+        end
+        alias_method_chain setter_name, :ordering
+      end
+    end
+  end
+end

data/lib/active_record_ex/assume_destroy.rb

@@ -0,0 +1,42 @@
+# extends accepts_nested_attributes_for
+# by default, accepts_nested_attributes_for "allow_destroy"s,
+# ie, will destroy associations if explicitly marked by _destroy: true
+# this flips that, causing an association to be destroyed 
+# if it's not included in the updating attrs
+module ActiveRecordEx
+  module AssumeDestroy
+    def self.included base
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def accepts_nested_attributes_for(assoc_name, options={})
+        assume_destroy = options[:assume_destroy]
+        options.delete(:assume_destroy)
+        options[:allow_destroy] = assume_destroy
+
+        super assoc_name, options
+
+        return unless assume_destroy
+        attrs_name = ("#{assoc_name.to_s}_attributes").to_sym
+        setter_name = ("#{attrs_name.to_s}=").to_sym
+        unassuming_setter_name = ("#{attrs_name.to_s}_without_assume=").to_sym
+        assuming_setter_name = ("#{attrs_name.to_s}_with_assume=").to_sym
+
+        define_method(assuming_setter_name) do |attrs|
+          ids = attrs.map { |a| a['id'] || a[:id] }.compact
+          assocs = self.send(assoc_name)
+
+          dead_assocs = []
+          # the ternary's 'cause Arel doesn't do the right thing with an empty array
+          dead_assocs = assocs.where('id NOT IN (?)', ids.any? ? ids : '') unless self.new_record?
+          dead_attrs = dead_assocs.map {|assoc| {id: assoc.id, _destroy: true }}
+
+          attrs = attrs.concat(dead_attrs)
+          self.send(unassuming_setter_name, attrs)
+        end
+        alias_method_chain setter_name, :assume
+      end
+    end
+  end
+end

data/lib/active_record_ex/many_to_many.rb

@@ -0,0 +1,138 @@
+# allows you to chain has_manys and belongs_tos
+# eg: $esc_pol.escalation_rules.escalation_targets
+# eg: $usr.schedules.escalation_policies
+module ActiveRecordEx
+  module ManyToMany
+    class ModelArel < ActiveRecord::Relation
+      def initialize(model)
+        super(model.class, model.class.arel_table)
+        @loaded = true
+        @records = [model]
+      end
+
+      def reset
+        # reset says "my currently loaded into memory models no longer currently represent this relation".
+        # That's never true for a ModelArel, so we no-op
+      end
+
+      def pluck(key)
+        key = key.name if key.respond_to? :name
+        @records.map(&:"#{key}")
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def belongs_to(name, options={})
+        subtypes = options.delete(:subtypes)
+        super
+        define_belongs_assoc(name, options.merge(subtypes: subtypes))
+      end
+
+      def has_many(name, options = {}, &extension)
+        super
+        define_has_assoc(name.to_s.singularize, options)
+      end
+
+      def has_one(name, options = {}, &extension)
+        super
+        define_has_assoc(name.to_s, options)
+      end
+
+      def singularize(method_name)
+        define_method(method_name) do |*params|
+          ModelArel.new(self).send(method_name, *params)
+        end
+      end
+
+      protected
+
+      def define_belongs_assoc(name, options)
+        if options[:polymorphic] && options[:subtypes]
+          define_polymorphic_assoc(name, options[:subtypes])
+        elsif !options[:polymorphic]
+          define_monomorphic_assoc(name, options)
+        end
+      end
+
+      def define_has_assoc(name, options)
+        if options[:through]
+          define_through_assoc(name, options)
+        else
+          define_plain_has_assoc(name, options)
+        end
+      end
+
+      def define_monomorphic_assoc(name, options)
+        name = name.to_s.singularize
+        klass_name = options[:class_name] || self.parent_string + name.camelize
+        key_name = options[:foreign_key] || name.foreign_key
+
+        method_name = name.pluralize.to_sym
+        define_singleton_method(method_name) do
+          klass = klass_name.constantize
+          foreign_key = self.arel_table[key_name]
+          primary_keys = self.pluck(foreign_key).uniq
+          # eg, Account.where(id: ids)
+          klass.where(klass.primary_key => primary_keys)
+        end
+      end
+
+      def define_polymorphic_assoc(name, subtypes)
+        Array.wrap(subtypes).each do |subtype_klass|
+          key_name = name.to_s.foreign_key
+          type_key = "#{name.to_s}_type"
+          type_val = subtype_klass.to_s
+
+          method_name = subtype_klass.to_s.demodulize.underscore.pluralize.to_sym
+          define_singleton_method(method_name) do
+            foreign_key = self.arel_table[key_name]
+            primary_keys = self.where(type_key => type_val).pluck(foreign_key).uniq
+            # eg, Account.where(id: ids)
+            subtype_klass.where(subtype_klass.primary_key => primary_keys)
+          end
+        end
+      end
+
+      def define_plain_has_assoc(name, options)
+        klass_name = options[:class_name] || self.parent_string + name.camelize
+
+        conditions = {}
+        if options[:as]
+          type_key_name = "#{options[:as].to_s}_type"
+          conditions[type_key_name] = self.to_s
+          foreign_key_name = options[:as].to_s.foreign_key
+        else
+          foreign_key_name = options[:foreign_key] || self.to_s.foreign_key
+        end
+
+        method_name = name.pluralize.to_sym
+        define_singleton_method(method_name) do
+          primary_key = self.arel_table[self.primary_key]
+          foreign_keys = self.pluck(primary_key).uniq
+
+          other_klass = klass_name.constantize
+          other_klass.where(conditions).where(foreign_key_name => foreign_keys)
+        end
+      end
+
+      def define_through_assoc(name, options)
+        through_method = options[:through].to_s.pluralize
+        method_name = name.pluralize.to_sym
+        define_singleton_method(method_name) do
+          through_base = self.send(through_method)
+          through_base.send(method_name)
+        end
+      end
+
+      def parent_string
+        parent = self.parent
+        return '' if parent == Object
+        "#{parent.to_s}::"
+      end
+    end
+  end
+end

data/lib/active_record_ex/nillable_find.rb

@@ -0,0 +1,33 @@
+module ActiveRecordEx
+  module NillableFind
+    class NillableArel
+      def initialize(base, ids, parent_scope)
+        @base = base
+        @ids = ids
+        @parent_scope = parent_scope
+      end
+
+      def method_missing(method_name, *args, &block)
+        return super unless  @base.respond_to? method_name
+
+        normals = @base.where(id: @ids).send(method_name, *args)
+        return normals unless @ids.include? nil
+
+        used = @base.send(method_name, *args)
+        # return those in normals AND those in parent scope not belonging to another
+        normals.disjunct(used.relative_complement(@parent_scope))
+      end
+    end
+
+    def self.included(base)
+      raise ArgumentError.new("#{base} must include ManyToMany") unless base.included_modules.include? ActiveRecordEx::ManyToMany
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def nillable_find(ids, parent_scope)
+        NillableArel.new(self, ids, parent_scope)
+      end
+    end
+  end
+end

data/lib/active_record_ex/polymorphic_build.rb

@@ -0,0 +1,30 @@
+# Allows choosing the subclass of a model
+# via a passed :type parameter
+# this is useful for using accepts_nested_attributes_for
+# with subclassed associations
+module ActiveRecordEx
+  module PolymorphicBuild
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_eval do
+        attr_accessible :type
+
+        class << self
+          alias_method_chain :new, :typing
+        end
+      end
+    end
+
+    module ClassMethods
+      def new_with_typing(attrs = {}, options = {})
+        if attrs[:type] && (klass = attrs[:type].constantize) < self
+          klass.new(attrs, options)
+        elsif attrs[:type] && !((klass = attrs[:type].constantize) <= self)
+          raise ArgumentError.new("Attempting to instantiate #{klass}, which is not a subclass of #{self}")
+        else
+          new_without_typing(attrs, options)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_ex/relation_extensions.rb

@@ -0,0 +1,37 @@
+module ActiveRecord
+  class Relation
+    def where_only(value)
+      relation = clone
+      relation.where_values = build_where(value)
+      relation
+    end
+
+    def none
+      self.where('1=0')
+    end
+
+    def disjunct(other)
+      other_where = other.collapsed_where
+      this_where = self.collapsed_where
+      self.where_only(this_where.or(other_where))
+    end
+
+    # If self and other are viewed as sets
+    # relative_complement represents everything
+    # that's in other but NOT in self
+    def relative_complement(other)
+      this_where = self.collapsed_where
+      other_where = other.collapsed_where
+      self.where_only(this_where.not.and(other_where))
+    end
+
+    protected
+
+    def collapsed_where
+      values = self.where_values
+      values = [true] if values.empty?
+      # FIXME: Needs to wrap string literal conditions (e.g., where("id > 1"))
+      Arel::Nodes::And.new(values)
+    end
+  end
+end

data/lib/active_record_ex/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordEx
+  VERSION = '0.1.0'
+end

data/test/test_helper.rb

@@ -0,0 +1,104 @@
+require 'active_record'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+require 'active_record_ex/relation_extensions'
+
+class ActiveSupport::TestCase
+  def db_expects(arel, query, response = nil)
+    response_columns = response.try(:first).try(:keys).try(:map, &:to_s) || []
+    response_rows = response.try(:map, &:values) || []
+    response = ActiveRecord::Result.new(response_columns, response_rows)
+
+    case query.first
+    when /^SELECT/
+      arel.connection.expects(:exec_query).with(*query).returns(response)
+    when /^DELETE/
+      arel.connection.expects(:exec_delete).with(*query).returns(response)
+    end
+  end
+end
+
+# Used as a "dummy" model in tests to avoid using a database connection
+class StubModel < ActiveRecord::Base
+  self.abstract_class = true
+
+  conn = Class.new(ActiveRecord::ConnectionAdapters::AbstractAdapter) do
+    def quote_column_name(name)
+      "`#{name.to_s.gsub('`', '``')}`"
+    end
+
+    def quote_table_name(name)
+      quote_column_name(name).gsub('.', '`.`')
+    end
+
+    def select(sql, name = nil, _ = [])
+      exec_query(sql, name).to_a
+    end
+  end
+
+  visitor = Class.new(Arel::Visitors::ToSql) do
+    def table_exists?(*_)
+      true
+    end
+
+    def column_for(attr)
+      pk = attr == 'id'
+      column = ActiveRecord::ConnectionAdapters::Column.new(attr, nil, pk ? :integer : :string)
+      column.primary = pk
+      column
+    end
+  end
+
+  @@connection = conn.new({})
+  @@connection.visitor = visitor.new(@@connection)
+
+  class << self
+    def connection
+      @@connection
+    end
+
+    def columns; []; end
+
+    def get_primary_key(*_); 'id'; end
+  end
+
+  # prevent AR from hitting the DB to get the schema
+  def get_primary_key(*_); 'id'; end
+
+  def with_transaction_returning_status; yield; end
+end
+
+# SQLCounter is part of ActiveRecord but is not distributed with the gem (used for internal tests only)
+# see https://github.com/rails/rails/blob/3-2-stable/activerecord/test/cases/helper.rb#L59
+module ActiveRecord
+  class SQLCounter
+    cattr_accessor :ignored_sql
+    self.ignored_sql = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    ignored_sql.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+
+    cattr_accessor :log
+    self.log = []
+
+    attr_reader :ignore
+
+    def initialize(ignore = self.class.ignored_sql)
+      @ignore   = ignore
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      return if 'CACHE' == values[:name] || ignore.any? { |x| x =~ sql }
+      self.class.log << sql
+    end
+  end
+
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end

data/test/unit/assoc_ordering_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+require 'active_record_ex/assoc_ordering'
+
+class OrderedAssoc < StubModel
+  attr_accessor :name
+  attr_accessor :order
+  attr_accessor :has_orderd_assoc_id
+end
+
+class DestroyableAssoc < StubModel
+  attr_accessor :name
+  attr_accessor :order
+  attr_accessor :has_orderd_assoc_id
+end
+
+class HasOrderedAssoc < StubModel
+  include ActiveRecordEx::AssocOrdering
+
+  has_many :ordered_assocs, order_on: :order
+  accepts_nested_attributes_for :ordered_assocs, order_on: :order
+
+  has_many :destroyable_assocs, order_on: :order
+  accepts_nested_attributes_for :destroyable_assocs, order_on: :order, allow_destroy: true
+
+  def save
+  end
+end
+
+
+class AssocOrderingTest < ActiveSupport::TestCase
+  context 'A class with ActiveREcord::AssocOrdering included' do
+    setup { @model = HasOrderedAssoc.new }
+
+    should 'order associations set as models' do
+      assocs = [OrderedAssoc.new(name: 'first'), OrderedAssoc.new(name: 'second')]
+      @model.ordered_assocs = assocs
+      sorted = @model.ordered_assocs.sort_by(&:order)
+      assert_equal 'first', sorted[0].name
+      assert_equal 1, sorted[0].order
+      assert_equal 'second', sorted[1].name
+      assert_equal 2, sorted[1].order
+    end
+
+    should 'order associations set as attributes' do
+      attrs = {ordered_assocs_attributes:
+        [{name: 'first'}, {name: 'second'}]
+      }
+      expected_attrs = [{name: 'first', order: 1}, {name: 'second', order: 2}]
+      @model.expects(:ordered_assocs_attributes_without_ordering=).with(expected_attrs)
+      @model.update_attributes(attrs)
+    end
+
+    should 'not ignore marked-for-destroy association attributes for ordering that don\'t allow destroy' do
+      attrs = {ordered_assocs_attributes:
+        [{name: 'first', _destroy: true}, {name: 'second'}]
+      }
+      expected_attrs = [{name: 'first', _destroy: true, order: 1}, {name: 'second', order: 2}]
+      @model.expects(:ordered_assocs_attributes_without_ordering=).with(expected_attrs)
+      @model.update_attributes(attrs)
+    end
+
+    should 'ignore marked-for-destroy association attributes for ordering that allow destroy' do
+      attrs = {destroyable_assocs_attributes:
+        [{name: 'first', _destroy: true}, {name: 'second'}]
+      }
+      expected_attrs = [{name: 'first', _destroy: true}, {name: 'second', order: 1}]
+      @model.expects(:destroyable_assocs_attributes_without_ordering=).with(expected_attrs)
+      @model.update_attributes(attrs)
+    end
+  end
+end

data/test/unit/assume_destroy_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+require 'active_record_ex/assume_destroy'
+
+class AssumeDestroyTest < ActiveRecord::TestCase
+  class AssumesDestroy < StubModel
+    include ActiveRecordEx::AssumeDestroy
+
+    has_many :destroyees
+    accepts_nested_attributes_for :destroyees,  assume_destroy: true
+  end
+
+  class Destroyee < StubModel
+  end
+
+  context 'ActiveRecordEx::AssumeDestroy' do
+    setup do 
+      @subject = AssumesDestroy.new
+      @subject.stubs(:new_record?).returns(false)
+    end
+
+    context 'preconditions in ActiveRecord' do
+      should 'DELETE records marked for destruction' do
+        attrs = []
+        stub_association_query(@subject, '\'\'', [{'id' => 1}, {'id' => 2}])
+        db_expects(@subject, ['SELECT `destroyees`.* FROM `destroyees`  WHERE `destroyees`.`assumes_destroy_id` IS NULL AND `destroyees`.`id` IN (1, 2)', 'AssumeDestroyTest::Destroyee Load'], [{'id' => 1}, {'id' => 2}])
+        db_expects(@subject.destroyees, ['DELETE FROM `destroyees` WHERE `destroyees`.`id` = ?', 'SQL', [[nil, 1]]])
+        db_expects(@subject.destroyees, ['DELETE FROM `destroyees` WHERE `destroyees`.`id` = ?', 'SQL', [[nil, 2]]])
+
+        @subject.update_attributes(destroyees_attributes: attrs)
+      end
+    end
+
+    should 'not mark any for destruction if subject is new' do
+      @subject.stubs(:new_record?).returns(true)
+      attrs = [{name: 'one'}]
+      expected_attrs = [{name: 'one'}]
+      @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
+
+      # shouldn't even hit the DB
+      assert_no_queries { @subject.destroyees_attributes = attrs }
+    end
+
+    should 'mark all associations for destruction when passed an empty array' do
+      attrs = []
+      stub_association_query(@subject, '\'\'', [{'id' => 1}, {'id' => 2}])
+
+      expected_attrs = [{id: 1, _destroy: true}, {id: 2, _destroy: true}]
+      @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
+      @subject.destroyees_attributes = attrs
+    end
+
+    should 'mark all existing associations for destruction when passed an array of just new' do
+      attrs = [{name: 'one'}]
+      stub_association_query(@subject, '\'\'', [{'id' => 1}, {'id' => 2}])
+
+      expected_attrs = [{name: 'one'}, {id: 1, _destroy: true}, {id: 2, _destroy: true}]
+      @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
+      @subject.destroyees_attributes = attrs
+    end
+
+    should 'not mark explicitly passed in associations for destruction' do
+      attrs = [{name: 'one'}, {id: 1}]
+      stub_association_query(@subject, '1', [{id: 2}])
+
+      expected_attrs = [{name: 'one'}, {id: 1}, {id: 2, _destroy: true}]
+      @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
+      @subject.destroyees_attributes = attrs
+    end
+
+    should 'preserve existing marks for destruction' do 
+      attrs = [{name: 'one'}, {id: 1, _destroy: true}]
+      stub_association_query(@subject, '1', [{id: 2}])
+
+      expected_attrs = [{name: 'one'}, {id: 1, _destroy: true}, {id: 2, _destroy: true}]
+      @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
+      @subject.destroyees_attributes = attrs
+    end
+  end
+
+  def stub_association_query(subject, id_string, id_response)
+    db_expects(subject, ["SELECT `destroyees`.* FROM `destroyees`  WHERE `destroyees`.`assumes_destroy_id` IS NULL AND (id NOT IN (#{id_string}))", 'AssumeDestroyTest::Destroyee Load'], id_response)
+  end
+end

data/test/unit/many_to_many_test.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+require 'active_record_ex/many_to_many'
+
+class ManyToManyTest < ActiveSupport::TestCase
+  class HasManied < StubModel
+    include ActiveRecordEx::ManyToMany
+
+    has_one :one
+    has_many :simple_belongs_tos
+    has_many :belongs_to_throughs, through: :simple_belongs_tos
+    has_many :class_nameds, class_name: 'ManyToManyTest::SomeClassName'
+    has_many :foreign_keyeds, foreign_key: :some_foreign_key_id
+    has_many :aseds, as: :some_as
+
+    singularize :ones
+  end
+  class SimpleBelongsTo < StubModel
+    include ActiveRecordEx::ManyToMany
+
+    belongs_to :has_manied
+    has_many :belongs_to_throughs
+
+    singularize :has_manieds
+  end
+  class BelongsToThrough < StubModel
+    include ActiveRecordEx::ManyToMany
+
+    belongs_to :has_manied
+  end
+  class SomeClassName < StubModel
+    include ActiveRecordEx::ManyToMany
+
+    belongs_to :some_name, class_name: 'ManyToManyTest::HasManied'
+  end
+  class ForeignKeyed < StubModel
+    include ActiveRecordEx::ManyToMany
+
+    belongs_to :has_manied, foreign_key: :some_foreign_key_id
+  end
+  class Ased < StubModel
+    include ActiveRecordEx::ManyToMany
+
+    belongs_to :some_as, polymorphic: true, subtypes: [HasManied]
+  end
+  class One < StubModel
+  end
+
+  context 'ActiveRecord::ManyToMany' do
+    context '#has_one' do
+      setup { @arel = HasManied.scoped }
+      should 'handle the simple case correctly' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}])
+        db_expects(@arel, ['SELECT `ones`.* FROM `ones`  WHERE `ones`.`has_manied_id` IN (1)', 'ManyToManyTest::One Load'])
+        @arel.ones.to_a
+      end
+    end
+
+    context '#has_many' do
+      setup { @arel = HasManied.scoped }
+
+      should 'handle the simple case correctly' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
+        db_expects(@arel, ['SELECT `simple_belongs_tos`.* FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1)', 'ManyToManyTest::SimpleBelongsTo Load'])
+        @arel.simple_belongs_tos.to_a
+      end
+
+      should 'handle the empty base case correctly' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds`  WHERE (1=0)'], [])
+        db_expects(@arel, ['SELECT `simple_belongs_tos`.* FROM `simple_belongs_tos`  WHERE 1=0', 'ManyToManyTest::SimpleBelongsTo Load'])
+        @arel.none.simple_belongs_tos.to_a
+      end
+
+      should 'handle the multiple base ids case correctly' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}, {id: 2}])
+        db_expects(@arel, ['SELECT `simple_belongs_tos`.* FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1, 2)', 'ManyToManyTest::SimpleBelongsTo Load'])
+        @arel.simple_belongs_tos.to_a
+      end
+
+      should 'chain queries for has_many through:' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}])
+        db_expects(@arel, ['SELECT `simple_belongs_tos`.`id` FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1)'], [{id: 1}])
+        db_expects(@arel, ['SELECT `belongs_to_throughs`.* FROM `belongs_to_throughs`  WHERE `belongs_to_throughs`.`simple_belongs_to_id` IN (1)', 'ManyToManyTest::BelongsToThrough Load'])
+
+        @arel.belongs_to_throughs.to_a
+      end
+
+      should 'not N+1 has_many through:' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}, {id: 2}])
+        db_expects(@arel, ['SELECT `simple_belongs_tos`.`id` FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1, 2)'], [{id: 1}, {id: 2}])
+        db_expects(@arel, ['SELECT `belongs_to_throughs`.* FROM `belongs_to_throughs`  WHERE `belongs_to_throughs`.`simple_belongs_to_id` IN (1, 2)', 'ManyToManyTest::BelongsToThrough Load'])
+
+        @arel.belongs_to_throughs.to_a
+      end
+
+      should 'use the class name passed in' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
+        db_expects(@arel, ['SELECT `some_class_names`.* FROM `some_class_names`  WHERE `some_class_names`.`has_manied_id` IN (1)', 'ManyToManyTest::SomeClassName Load'])
+        @arel.class_nameds.to_a
+      end
+
+      should 'use the foreign key passed in' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
+        db_expects(@arel, ['SELECT `foreign_keyeds`.* FROM `foreign_keyeds`  WHERE `foreign_keyeds`.`some_foreign_key_id` IN (1)', 'ManyToManyTest::ForeignKeyed Load'])
+        @arel.foreign_keyeds.to_a
+      end
+
+      should 'use the as passed in' do
+        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
+        db_expects(@arel, ['SELECT `aseds`.* FROM `aseds`  WHERE `aseds`.`some_as_type` = \'ManyToManyTest::HasManied\' AND `aseds`.`some_as_id` IN (1)', 'ManyToManyTest::Ased Load'])
+        @arel.aseds.to_a
+      end
+    end
+
+    context '#belongs_to' do
+      should 'handle the simple case correctly' do
+        @arel = SimpleBelongsTo.scoped
+        db_expects(@arel, ['SELECT `simple_belongs_tos`.`has_manied_id` FROM `simple_belongs_tos` '], [has_manied_id: 1])
+        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
+        @arel.has_manieds.to_a
+      end
+
+      should 'use the class name passed in' do
+        @arel = SomeClassName.scoped
+        db_expects(@arel, ['SELECT `some_class_names`.`some_name_id` FROM `some_class_names` '], [some_name_id: 1])
+        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
+        @arel.some_names.to_a
+      end
+      
+      should 'use the foreign key passed in' do
+        @arel = ForeignKeyed.scoped
+        db_expects(@arel, ['SELECT `foreign_keyeds`.`some_foreign_key_id` FROM `foreign_keyeds` '], [some_foreign_key_id: 1])
+        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
+        @arel.has_manieds.to_a
+      end
+
+      should 'handle polymorphic belongs_to' do
+        @arel = Ased.scoped
+        db_expects(@arel, ['SELECT `aseds`.`some_as_id` FROM `aseds`  WHERE `aseds`.`some_as_type` = \'ManyToManyTest::HasManied\''], [some_as_id: 1])
+        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
+        @arel.has_manieds.to_a
+      end
+    end
+
+    context '#singularize' do
+      should 'work for belongs_tos without triggering an extra query' do
+        @model = SimpleBelongsTo.new
+        @model.stubs(:has_manied_id).returns(42)
+        @arel = HasManied.scoped
+        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (42)', 'ManyToManyTest::HasManied Load'])
+        @model.has_manieds.to_a
+      end
+
+      should 'work for has_ones without triggering an extra query' do
+        @model = HasManied.new
+        @model.stubs(:id).returns(42)
+        @arel = One.scoped
+        db_expects(@arel, ['SELECT `ones`.* FROM `ones`  WHERE `ones`.`has_manied_id` IN (42)', 'ManyToManyTest::One Load'])
+        @model.ones.to_a
+      end
+    end
+  end
+end

data/test/unit/nillable_find_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+require 'active_record_ex/many_to_many'
+require 'active_record_ex/nillable_find'
+
+class NillableFindTest < ActiveSupport::TestCase
+  class Parent < StubModel
+    include ActiveRecordEx::ManyToMany
+    include ActiveRecordEx::NillableFind
+
+    has_many :children
+  end
+
+  class Child < StubModel
+  end
+
+  context 'ActiveRecordEx::NillableFind' do
+    context '#nillable_find' do
+      setup { @arel = Parent.scoped }
+      # RC == relative complement
+      should 'request the RC of the base scope in the parent scope when just passed nil' do
+        # fetch IDs
+        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE `parents`.`id` IS NULL'], [])
+        # fetch outside set
+        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents` '], [{id: 1}, {id: 2}])
+        # disjunct
+        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE ((1=0 OR NOT (`children`.`parent_id` IN (1, 2)) AND `children`.`foo` = \'bar\'))', 'NillableFindTest::Child Load'], [])
+
+        Parent.nillable_find([nil], Child.where(foo: 'bar')).children.all
+      end
+
+      should 'request the disjunct of the RC of base scope in parent scope and all children of non-nil ids' do
+        # fetch IDs
+        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE ((`parents`.`id` IN (1) OR `parents`.`id` IS NULL))'], [{id: 1}])
+        # fetch outside set
+        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents` '], [{id: 1}, {id: 2}])
+        # disjunct
+        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE ((`children`.`parent_id` IN (1) OR NOT (`children`.`parent_id` IN (1, 2)) AND `children`.`foo` = \'bar\'))', 'NillableFindTest::Child Load'], [])
+
+        Parent.nillable_find([1, nil], Child.where(foo: 'bar')).children.all
+      end
+
+      should 'request nothing when passed no an empty set of ids' do
+        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE 1=0'], [])
+        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE 1=0', 'NillableFindTest::Child Load'], [])
+
+        Parent.nillable_find([], Child.where(foo: 'bar')).children.all
+      end
+
+      should 'request as a normal many-to-many when passed only normal ids' do
+        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE `parents`.`id` IN (1)'], [{id: 1}])
+        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE `children`.`parent_id` IN (1)', 'NillableFindTest::Child Load'], [])
+
+        Parent.nillable_find([1], Child.where(foo: 'bar')).children.all
+      end
+    end
+  end
+end

data/test/unit/polymorphic_build_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+require 'active_record_ex/polymorphic_build'
+
+class PolymorphicBuildTest < ActiveSupport::TestCase
+  class PolyBase < StubModel
+    include ActiveRecordEx::PolymorphicBuild
+    attr_accessor :type
+  end
+
+  class PolyChild < PolyBase
+  end
+
+  should 'instantiate an instance with the subclass passed in' do
+    inst = PolyBase.new(type: PolyChild.to_s)
+    assert_equal PolyChild, inst.class
+  end
+
+  should 'instantiate an instance with the class itself passed in' do
+    inst = PolyBase.new(type: PolyBase.to_s)
+    assert_equal PolyBase, inst.class
+  end
+
+  should 'throw an error if the passed in class is not a subclass' do
+    assert_raise(ArgumentError) do
+      PolyBase.new(type: StubModel.to_s)
+    end
+  end
+end

data/test/unit/relation_extensions_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class RelationExtensionsTest < ActiveSupport::TestCase
+  class HasManied < StubModel
+    has_many :belongs_tos
+  end
+
+  class BelongsTo < StubModel
+    belongs_to :has_manied
+    attr_accessor :has_manied_id
+  end
+
+  context '#relative_complement' do
+    setup do
+      @hm1 = HasManied.new
+      @hm2 = HasManied.new
+      @bt1 = @hm1.belongs_tos.new
+    end
+
+    context 'disjoint set' do
+      should 'return all belongs_tos' do
+        assert_equal @hm1.belongs_tos.all, @hm2.belongs_tos.relative_complement(@hm1.belongs_tos)
+      end
+    end
+
+    context 'identical set' do
+      should 'return nothing' do
+        assert_empty @hm1.belongs_tos.relative_complement(@hm1.belongs_tos)
+      end
+    end
+
+    context 'subset' do
+      should 'return all other belongs_tos' do
+        assert_equal @hm1.belongs_tos.where('id <> ?', @bt1.id).all, BelongsTo.where(id: @bt1.id).relative_complement(@hm1.belongs_tos).all
+      end
+    end
+
+    context 'by empty set' do
+      should 'return all belongs_tos' do
+        assert_equal @hm1.belongs_tos.all, BelongsTo.where(id: -1).relative_complement(@hm1.belongs_tos)
+      end
+    end
+
+    context 'of empty set' do
+      should 'return nothing' do
+        assert_empty @hm1.belongs_tos.relative_complement(BelongsTo.where(id: -1))
+      end
+    end
+
+    context 'by unconditional' do
+      should 'return nothing' do
+        assert_empty BelongsTo.scoped.relative_complement(@hm1.belongs_tos)
+      end
+    end
+
+    context 'of unconditional' do
+      should 'return all belongs_tos' do
+        assert_equal @hm2.belongs_tos.all, @hm1.belongs_tos.relative_complement(BelongsTo.scoped)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: active-record-ex
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Arjun Kavi
+- PagerDuty
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: A library to make ActiveRecord::Relations even more awesome
+email:
+- arjun.kavi@gmail.com
+- developers@pagerduty.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- active-record-ex.gemspec
+- lib/active_record_ex.rb
+- lib/active_record_ex/assoc_ordering.rb
+- lib/active_record_ex/assume_destroy.rb
+- lib/active_record_ex/many_to_many.rb
+- lib/active_record_ex/nillable_find.rb
+- lib/active_record_ex/polymorphic_build.rb
+- lib/active_record_ex/relation_extensions.rb
+- lib/active_record_ex/version.rb
+- test/test_helper.rb
+- test/unit/assoc_ordering_test.rb
+- test/unit/assume_destroy_test.rb
+- test/unit/many_to_many_test.rb
+- test/unit/nillable_find_test.rb
+- test/unit/polymorphic_build_test.rb
+- test/unit/relation_extensions_test.rb
+homepage: https://github.com/PagerDuty/active-record-ex
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Relation -> Relation methods
+test_files:
+- test/test_helper.rb
+- test/unit/assoc_ordering_test.rb
+- test/unit/assume_destroy_test.rb
+- test/unit/many_to_many_test.rb
+- test/unit/nillable_find_test.rb
+- test/unit/polymorphic_build_test.rb
+- test/unit/relation_extensions_test.rb