baby_squeel 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7d31d8ac2c6564c5116b4fcfb2175c7747e1689
-  data.tar.gz: a1882420d085c5d2e071434ae8da6d28951ad3f9
+  metadata.gz: 394545743835687d87f67feb11e76e787cebc34a
+  data.tar.gz: 4a3f636a36f4e83a889e3948ea6acf35f235b402
 SHA512:
-  metadata.gz: 3fdc066c0f04ebe17744c95cbc4499a492c993ca23d06fc6b11b41077d7d2a45591504f7a831b4fdf1e21aa16c640b6847a1bbf58e7fc3b1b232e0366209b0d9
-  data.tar.gz: dac5d32acfb013e580aa4e51433a6b1e2bafe17288001feb09295f1da2b26e93a61486598c8884707e687ee591c024ac7ad82091b5a1833ed239f2ee009cfb42
+  metadata.gz: ba300fa29631298a8143a580ab34bb66298b022aa9e32d0204f4855e23a464090c3ba0032f1c63152bd3de90a46f12f2ed609234b735de41cce50cd841a512e6
+  data.tar.gz: 6e565e66b5e8dd456f4a388f5b1e0b903ddcc2f1baaee86aed0ca0c295238a66d9a0d16f31cd6f9ce4e4679700354b2c98782284e418d2c981d7db88fab864fc

data/CHANGELOG.md

@@ -1,6 +1,21 @@
-## Unreleased
+## [1.0.0] - 2016-9-9
+### Added
+- Polyamorous. Unfortunately, this *does* monkey-patch Active Record internals, but there just isn't any other reliable way to generate outer joins. Baby Squeel, itself, will still keep monkey patching to an absolute minimum.
+- Within DSL blocks, you can use `exists` and `not_exists` with Active Record relations. For example: `Post.where.has { exists Post.where(title: 'Fun') }`.`
+- Support for polymorphic associations.
+
+### Deprecations
+- Removed support for Active Record 4.0.x
 
-Nothing yet.
+### Changed
+- BabySqueel::JoinDependency is no longer a class responsible for creating Arel joins. It is now a namespace for utilities used when working with the ActiveRecord::Association::JoinDependency class.
+- BabySqueel::Nodes::Generic is now BabySqueel::Nodes::Node.
+- Arel nodes are only extended with the behaviors they need. Previously, all Arel nodes were being extended with `Arel::AliasPredication`, `Arel::OrderPredications`, and `Arel::Math`.
+
+### Fixed
+- Fixed deprecation warnings on Active Record 5 when initializing an Arel::Table without a type caster.
+- No more duplicate joins. Previously, Baby Squeel did a very poor job of ensuring that you didn't join an association twice.
+- Alias detection should now *actually* work. The previous implementation was naive.
 
 ## [0.3.1] - 2016-08-02
 ### Added

data/ISSUE_TEMPLATE.md

@@ -0,0 +1,39 @@
+#### Issue
+
+Please explain this issue you're encountering to the best of your ability.
+
+#### Reproduction
+
+```ruby
+require 'bundler/inline'
+require 'minitest/spec'
+require 'minitest/autorun'
+
+gemfile true do
+  source 'https://rubygems.org'
+  gem 'activerecord', '~> 5.0.0' # which Active Record version?
+  gem 'sqlite3'
+  gem 'baby_squeel', github: 'rzane/baby_squeel'
+end
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define do
+  create_table :dogs, force: true do |t|
+    t.string :name
+  end
+end
+
+class Dog < ActiveRecord::Base
+end
+
+class BabySqueelTest < Minitest::Spec
+  it 'works' do
+    scope = Dog.where.has { name == 'Fido' }
+
+    scope.to_sql.must_equal %{
+      SELECT "dogs".* FROM "dogs" WHERE "dogs"."name" = 'Fido'
+    }.squish
+  end
+end
+```

data/README.md

@@ -175,6 +175,14 @@ Post.joining { author.outer.posts }
 Post.joining { author.alias('a').on((author.id == author_id) | (author.name == title)) }
 # SELECT "posts".* FROM "posts"
 # INNER JOIN "authors" "a" ON ("authors"."id" = "posts"."author_id" OR "authors"."name" = "posts"."title")
+
+Picture.joining { imageable.of(Post) }
+# SELECT "pictures".* FROM "pictures"
+# INNER JOIN "posts" ON "posts"."id" = "pictures"."imageable_id" AND "pictures"."imageable_type" = 'Post'
+
+Picture.joining { imageable.of(Post).outer }
+# SELECT "pictures".* FROM "pictures"
+# LEFT OUTER JOIN "posts" ON "posts"."id" = "pictures"."imageable_id" AND "pictures"."imageable_type" = 'Post'
 ```
 
 ##### Grouping
@@ -279,18 +287,9 @@ The following methods give you access to BabySqueel's DSL:
 | `where.has`   | `where`                  |
 | `when_having` | `having`                 |
 
-## Compatibility Mode
-
-If you want `select`, `order`, `joins`, `group`, and `having` to be able to accept DSL blocks, you can do so by adding the following to an initializer.
-
-```ruby
-# config/initializers/baby_squeel.rb
-BabySqueel.configure do |config|
-  config.enable_compat!
-end
-```
+## Migrating from Squeel
 
-Calling `enable_compat!` will override methods in Active Record, so use caution.
+Check out the [migration guide](https://github.com/rzane/baby_squeel/wiki/Migrating-from-Squeel).
 
 ## Development
 

data/baby_squeel.gemspec

@@ -19,7 +19,8 @@ Gem::Specification.new do |spec|
 
   spec.files = Dir.glob('{lib/**/*,*.{md,txt,gemspec}}')
 
-  spec.add_dependency 'activerecord', '>= 4.0.0'
+  spec.add_dependency 'activerecord', '>= 4.1.0'
+  spec.add_dependency 'polyamorous', '~> 1.3'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/baby_squeel.rb

@@ -1,31 +1,47 @@
 require 'active_record'
 require 'active_record/relation'
+require 'polyamorous'
 require 'baby_squeel/version'
 require 'baby_squeel/errors'
-require 'baby_squeel/active_record'
+require 'baby_squeel/active_record/base'
+require 'baby_squeel/active_record/query_methods'
+require 'baby_squeel/active_record/where_chain'
 
 module BabySqueel
   class << self
+    # Configures BabySqueel using the given block
     def configure
       yield self
     end
 
+    # Turn on BabySqueel's compatibility mode. This will
+    # make BabySqueel act more like Squeel.
     def enable_compatibility!
       require 'baby_squeel/compat'
       BabySqueel::Compat.enable!
     end
 
-    def [](thing)
+    # Get a BabySqueel table instance.
+    #
+    # ==== Examples
+    #     BabySqueel[Post]
+    #     BabySqueel[:posts]
+    #     BabySqueel[Post.arel_table]
+    #
+    def [](thing, **kwargs)
       if thing.respond_to?(:model_name)
         Relation.new(thing)
+      elsif thing.kind_of?(Arel::Table)
+        Table.new(thing)
       else
-        Table.new(Arel::Table.new(thing))
+        Table.new(Arel::Table.new(thing, **kwargs))
       end
     end
   end
 end
 
-::ActiveRecord::Base.extend BabySqueel::ActiveRecord::Sifting
-::ActiveRecord::Base.extend BabySqueel::ActiveRecord::QueryMethods
-::ActiveRecord::Relation.prepend BabySqueel::ActiveRecord::QueryMethods
-::ActiveRecord::QueryMethods::WhereChain.prepend BabySqueel::ActiveRecord::WhereChain
+ActiveSupport.on_load :active_record do
+  ::ActiveRecord::Base.extend BabySqueel::ActiveRecord::Base
+  ::ActiveRecord::Relation.prepend BabySqueel::ActiveRecord::QueryMethods
+  ::ActiveRecord::QueryMethods::WhereChain.prepend BabySqueel::ActiveRecord::WhereChain
+end

data/lib/baby_squeel/active_record/base.rb

@@ -0,0 +1,27 @@
+require 'baby_squeel/dsl'
+
+module BabySqueel
+  module ActiveRecord
+    module Base
+      delegate :joining, :joining!, :selecting, :ordering,
+               :grouping, :when_having, to: :all
+
+      # Define a sifter that can be used within DSL blocks.
+      #
+      # ==== Examples
+      #    class Post < ActiveRecord::Base
+      #      sifter :name_contains do |string|
+      #        name =~ "%#{string}%"
+      #      end
+      #    end
+      #
+      #    Post.where.has { sift(:name_contains, 'joe') }
+      #
+      def sifter(name, &block)
+        define_singleton_method "sift_#{name}" do |*args|
+          DSL.evaluate_sifter(self, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/baby_squeel/{active_record.rb → active_record/query_methods.rb}

@@ -1,20 +1,12 @@
 require 'baby_squeel/dsl'
+require 'baby_squeel/join_dependency/injector'
 
 module BabySqueel
   module ActiveRecord
-    module Sifting
-      def sifter(name, &block)
-        define_singleton_method "sift_#{name}" do |*args|
-          DSL.evaluate_sifter(self, *args, &block)
-        end
-      end
-    end
-
     module QueryMethods
       # Constructs Arel for ActiveRecord::Base#joins using the DSL.
       def joining(&block)
-        arel, binds = DSL.evaluate_joins(unscoped, &block)
-        joins(arel).tap { |s| s.bind_values += binds }
+        joins DSL.evaluate(self, &block)
       end
 
       # Constructs Arel for ActiveRecord::Base#select using the DSL.
@@ -36,13 +28,15 @@ module BabySqueel
       def when_having(&block)
         having DSL.evaluate(self, &block)
       end
-    end
 
-    module WhereChain
-      # Constructs Arel for ActiveRecord::Base#where using the DSL.
-      def has(&block)
-        @scope.where! DSL.evaluate(@scope, &block)
-        @scope
+      private
+
+      # This is a monkey patch, and I'm not happy about it.
+      # Active Record will call `group_by` on the `joins`. The
+      # Injector has a custom `group_by` method that handles
+      # BabySqueel::JoinExpression nodes.
+      def build_joins(manager, joins)
+        super manager, BabySqueel::JoinDependency::Injector.new(joins)
       end
     end
   end

data/lib/baby_squeel/active_record/where_chain.rb

@@ -0,0 +1,13 @@
+require 'baby_squeel/dsl'
+
+module BabySqueel
+  module ActiveRecord
+    module WhereChain
+      # Constructs Arel for ActiveRecord::Base#where using the DSL.
+      def has(&block)
+        @scope.where! DSL.evaluate(@scope, &block)
+        @scope
+      end
+    end
+  end
+end

data/lib/baby_squeel/association.rb

@@ -2,12 +2,57 @@ require 'baby_squeel/relation'
 
 module BabySqueel
   class Association < Relation
+    # An Active Record association reflection
     attr_reader :_reflection
 
+    # Specifies the model that the polymorphic
+    # association should join with
+    attr_accessor :_polymorphic_klass
+
     def initialize(parent, reflection)
       @parent = parent
       @_reflection = reflection
-      super(@_reflection.klass)
+
+      # In the case of a polymorphic reflection these
+      # attributes will be set after calling #of
+      unless @_reflection.polymorphic?
+        super @_reflection.klass
+      end
+    end
+
+    def of(klass)
+      unless _reflection.polymorphic?
+        raise PolymorphicSpecificationError.new(_reflection.name, klass)
+      end
+
+      clone.of! klass
+    end
+
+    def of!(klass)
+      self._scope = klass
+      self._table = klass.arel_table
+      self._polymorphic_klass = klass
+      self
+    end
+
+    def needs_polyamorous?
+      _join == Arel::Nodes::OuterJoin || _reflection.polymorphic?
+    end
+
+    # See JoinExpression#add_to_tree.
+    def add_to_tree(hash)
+      polyamorous = Polyamorous::Join.new(
+        _reflection.name,
+        _join,
+        _polymorphic_klass
+      )
+
+      hash[polyamorous] ||= {}
+    end
+
+    # See BabySqueel::Table#find_alias.
+    def find_alias(association, associations = [])
+      @parent.find_alias(association, [self, *associations])
     end
 
     # Intelligently constructs Arel nodes. There are three outcomes:
@@ -15,18 +60,27 @@ module BabySqueel
     # 1. The user explicitly constructed their join using #on.
     #    See BabySqueel::Table#_arel.
     #
+    #        Post.joining { author.on(author_id == author.id) }
+    #
     # 2. The user aliased an implicitly joined association. ActiveRecord's
     #    join dependency gives us no way of handling this, so we have to
     #    throw an error.
     #
+    #        Post.joining { author.as('some_alias') }
+    #
     # 3. The user implicitly joined this association, so we pass this
     #    association up the tree until it hits the top-level BabySqueel::Table.
     #    Once it gets there, Arel join nodes will be constructed.
+    #
+    #        Post.joining { author }
+    #
     def _arel(associations = [])
       if _on
         super
       elsif _table.is_a? Arel::Nodes::TableAlias
         raise AssociationAliasingError.new(_reflection.name, _table.right)
+      elsif _reflection.polymorphic? && _polymorphic_klass.nil?
+        raise PolymorphicNotSpecifiedError.new(_reflection.name)
       else
         @parent._arel([self, *associations])
       end

data/lib/baby_squeel/compat.rb

@@ -1,5 +1,7 @@
 module BabySqueel
   module Compat
+    # Monkey-patches BabySqueel and ActiveRecord
+    # in order to behave more like Squeel
     def self.enable!
       BabySqueel::DSL.prepend BabySqueel::Compat::DSL
       ::ActiveRecord::Base.singleton_class.prepend QueryMethods
@@ -7,10 +9,12 @@ module BabySqueel
     end
 
     module DSL
+      # An alias for BabySqueel::DSL#sql
       def `(str)
         sql(str)
       end
 
+      # Allows you to call out of an instance_eval'd block.
       def my(&block)
         @caller.instance_eval(&block)
       end
@@ -23,6 +27,7 @@ module BabySqueel
     end
 
     module QueryMethods
+      # Overrides ActiveRecord::QueryMethods#joins
       def joins(*args, &block)
         if block_given? && args.empty?
           joining(&block)
@@ -47,6 +52,7 @@ module BabySqueel
         end
       end
 
+      # Overrides ActiveRecord::QueryMethods#order
       def order(*args, &block)
         if block_given? && args.empty?
           ordering(&block)
@@ -55,6 +61,7 @@ module BabySqueel
         end
       end
 
+      # Overrides ActiveRecord::QueryMethods#group
       def group(*args, &block)
         if block_given? && args.empty?
           grouping(&block)
@@ -63,6 +70,7 @@ module BabySqueel
         end
       end
 
+      # Overrides ActiveRecord::QueryMethods#having
       def having(*args, &block)
         if block_given? && args.empty?
           when_having(&block)
@@ -71,6 +79,7 @@ module BabySqueel
         end
       end
 
+      # Overrides ActiveRecord::QueryMethods#where
       def where(*args, &block)
         if block_given? && args.empty?
           where.has(&block)

data/lib/baby_squeel/dsl.rb

@@ -15,15 +15,6 @@ module BabySqueel
         new(scope).evaluate(&block)
       end
 
-      # Evaluates a block specifically for a join. In this
-      # case, we'll return an array of Arel join nodes and
-      # a list of bind parameters.
-      def evaluate_joins(scope, &block)
-        dependency = evaluate!(scope, &block)._arel
-        join_arel = Nodes.unwrap(dependency._arel)
-        [join_arel, dependency.bind_values]
-      end
-
       # Evaluates a block in the context of a new DSL instance
       # and passes all arguments to the block.
       def evaluate_sifter(scope, *args, &block)
@@ -48,6 +39,32 @@ module BabySqueel
       Nodes.wrap Arel::Nodes::NamedFunction.new(name.to_s, args)
     end
 
+    # Generate an EXISTS subselect from an ActiveRecord::Relation
+    #
+    # ==== Arguments
+    #
+    # * +relation+ - An ActiveRecord::Relation
+    #
+    # ==== Example
+    #     Post.where.has { exists Post.where(id: 1) }
+    #
+    def exists(relation)
+      func 'EXISTS', sql(relation.to_sql)
+    end
+
+    # Generate a NOT EXISTS subselect from an ActiveRecord::Relation
+    #
+    # ==== Arguments
+    #
+    # * +relation+ - An ActiveRecord::Relation
+    #
+    # ==== Example
+    #     Post.where.has { not_exists Post.where(id: 1) }
+    #
+    def not_exists(rel)
+      func 'NOT EXISTS', sql(rel.to_sql)
+    end
+
     # See Arel::sql
     def sql(value)
       Nodes.wrap ::Arel.sql(value)

data/lib/baby_squeel/errors.rb

@@ -1,24 +1,48 @@
 module BabySqueel
-  class NotFoundError < StandardError
+  class NotFoundError < StandardError # :nodoc:
     def initialize(model_name, name)
       super "There is no column or association named '#{name}' for #{model_name}."
     end
   end
 
-  class AssociationNotFoundError < StandardError
+  class AssociationNotFoundError < StandardError  # :nodoc:
     def initialize(model_name, name)
       super "Association named '#{name}' was not found for #{model_name}."
     end
   end
 
-  class AssociationAliasingError < StandardError
+  class AssociationAliasingError < StandardError  # :nodoc:
     MESSAGE =
-      'Attempted to alias \'%{association}\' as \'%{alias_name}\', but the ' \
-      'association was implicitly joined. Either join the association ' \
-      'with `on` or remove the alias.'.freeze
+      "Attempted to alias '%{association}' as '%{alias_name}', but the " \
+      "association was implicitly joined. Either join the association " \
+      "with `on` or remove the alias. For example:" \
+      "\n\n  Post.joining { author }" \
+      "\n  Post.joining { author.on(author_id == author.id) }\n\n"
 
     def initialize(association, alias_name)
       super format(MESSAGE, association: association, alias_name: alias_name)
     end
   end
+
+  class PolymorphicSpecificationError < StandardError # :nodoc:
+    MESSAGE =
+      "'%{association}' is not a polymorphic association, therefore " \
+      "the following expression is invalid:" \
+      "\n\n  %{association}.of(%{klass})\n\n"
+
+    def initialize(association, klass)
+      super format(MESSAGE, association: association, klass: klass)
+    end
+  end
+
+  class PolymorphicNotSpecifiedError < StandardError # :nodoc:
+    MESSAGE =
+      "'%{association}' is a polymorphic association, therefore " \
+      "you must call #of when referencing the association. For example:" \
+      "\n\n  %{association}.of(SomeModel)\n\n"
+
+    def initialize(association)
+      super format(MESSAGE, association: association)
+    end
+  end
 end

data/lib/baby_squeel/join_dependency/builder.rb

@@ -0,0 +1,79 @@
+require 'baby_squeel/join_dependency/injector'
+
+module BabySqueel
+  module JoinDependency
+    # Unfortunately, this is mostly all duplication of
+    # ActiveRecord::QueryMethods#build_joins
+    class Builder # :nodoc:
+      attr_reader :relation
+
+      def initialize(relation)
+        @relation = relation
+        @joins_values = relation.joins_values.dup
+      end
+
+      def ensure_associated(*values)
+        @joins_values += values
+      end
+
+      def to_join_dependency
+        ::ActiveRecord::Associations::JoinDependency.new(
+          relation.model,
+          association_joins,
+          join_list
+        )
+      end
+
+      private
+
+      def join_list
+        join_nodes + join_strings_as_ast
+      end
+
+      def association_joins
+        buckets[:association_join] || []
+      end
+
+      def stashed_association_joins
+        buckets[:stashed_join] || []
+      end
+
+      def join_nodes
+        (buckets[:join_node] || []).uniq
+      end
+
+      def string_joins
+        (buckets[:string_join] || []).map(&:strip).uniq
+      end
+
+      if Arel::VERSION >= '7.0.0'
+        def join_strings_as_ast
+          manager = Arel::SelectManager.new(relation.table)
+          relation.send(:convert_join_strings_to_ast, manager, string_joins)
+        end
+      else
+        def join_strings_as_ast
+          manager = Arel::SelectManager.new(relation.table.engine, relation.table)
+          relation.send(:custom_join_ast, manager, string_joins)
+        end
+      end
+
+      def buckets
+        @buckets ||= Injector.new(@joins_values).group_by do |join|
+          case join
+          when String
+            :string_join
+          when Hash, Symbol, Array
+            :association_join
+          when ::ActiveRecord::Associations::JoinDependency
+            :stashed_join
+          when ::Arel::Nodes::Join
+            :join_node
+          else
+            raise 'unknown class: %s' % join.class.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baby_squeel/join_dependency/finder.rb

@@ -0,0 +1,36 @@
+module BabySqueel
+  module JoinDependency
+    class Finder # :nodoc:
+      attr_reader :join_dependency
+
+      def initialize(join_dependency)
+        @join_dependency = join_dependency
+      end
+
+      def find_alias(reflection)
+        join_association = find_association(reflection)
+        join_association.tables.first if join_association
+      end
+
+      private
+
+      def find(&block)
+        deeply_find(join_dependency.join_root, &block)
+      end
+
+      def find_association(reflection)
+        find { |assoc| assoc.reflection == reflection }
+      end
+
+      def deeply_find(root, &block)
+        root.children.each do |assoc|
+          found = assoc if yield assoc
+          found ||= deeply_find(assoc, &block)
+          return found if found
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/baby_squeel/join_dependency/injector.rb

@@ -0,0 +1,27 @@
+module BabySqueel
+  module JoinDependency
+    # This class allows BabySqueel to slip custom
+    # joins_values into Active Record's JoinDependency
+    class Injector < Array # :nodoc:
+      def initialize(joins)
+        @joins = joins
+      end
+
+      # Active Record will call group_by on this object
+      # in ActiveRecord::QueryMethods#build_joins. This
+      # allows BabySqueel::JoinExpressions to be treated
+      # like typical join hashes until Polyamorous can
+      # deal with them.
+      def group_by(&block)
+        @joins.group_by do |join|
+          case join
+          when BabySqueel::JoinExpression
+            :association_join
+          else
+            yield join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baby_squeel/join_expression.rb

@@ -0,0 +1,25 @@
+require 'baby_squeel/join_dependency/builder'
+require 'baby_squeel/join_dependency/finder'
+
+module BabySqueel
+  # This is the thing that gets added to Active Record's joins_values.
+  # By including Polyamorous::TreeNode, when this instance is found when
+  # traversing joins in ActiveRecord::Associations::JoinDependency::walk_tree,
+  # JoinExpression#add_to_tree will be called.
+  class JoinExpression
+    include Polyamorous::TreeNode
+
+    def initialize(associations)
+      @associations = associations
+    end
+
+    # Each individual association object knows how
+    # to build a Polyamorous::Join. Those joins
+    # will be added to the hash incrementally.
+    def add_to_tree(hash)
+      @associations.inject(hash) do |acc, assoc|
+        assoc.add_to_tree(acc)
+      end
+    end
+  end
+end

data/lib/baby_squeel/nodes.rb

@@ -1,4 +1,7 @@
-require 'baby_squeel/operators'
+require 'baby_squeel/nodes/node'
+require 'baby_squeel/nodes/attribute'
+require 'baby_squeel/nodes/function'
+require 'baby_squeel/nodes/grouping'
 
 module BabySqueel
   module Nodes
@@ -6,8 +9,13 @@ module BabySqueel
       # Wraps an Arel node in a Proxy so that it can
       # be extended.
       def wrap(arel)
-        if arel.class.parents.include?(Arel)
-          Generic.new(arel)
+        case arel
+        when Arel::Nodes::Grouping
+          Grouping.new(arel)
+        when Arel::Nodes::Function
+          Function.new(arel)
+        when Arel::Nodes::Node, Arel::Nodes::SqlLiteral
+          Node.new(arel)
         else
           arel
         end
@@ -25,85 +33,5 @@ module BabySqueel
         end
       end
     end
-
-    # This proxy class allows us to quack like any arel object. When a
-    # method missing is hit, we'll instantiate a new proxy object.
-    class Proxy < ActiveSupport::ProxyObject
-      # Resolve constants the normal way
-      def self.const_missing(name)
-        ::Object.const_get(name)
-      end
-
-      attr_reader :_arel
-
-      def initialize(arel)
-        @_arel = Nodes.unwrap(arel)
-      end
-
-      def respond_to?(meth, include_private = false)
-        meth.to_s == '_arel' || _arel.respond_to?(meth, include_private)
-      end
-
-      private
-
-      def method_missing(meth, *args, &block)
-        if _arel.respond_to?(meth)
-          Nodes.wrap _arel.send(meth, *Nodes.unwrap(args), &block)
-        else
-          super
-        end
-      end
-    end
-
-    # This is a generic proxy class that includes all possible modules.
-    # In the future, these proxy classes should be more specific and only
-    # include necessary/applicable modules.
-    class Generic < Proxy
-      extend Operators::ArelAliasing
-      include Operators::Comparison
-      include Operators::Equality
-      include Operators::Generic
-      include Operators::Grouping
-      include Operators::Matching
-
-      # Extend the Arel node with some extra modules. For example,
-      # Arel::Nodes::Grouping does not implement Math. InfixOperation doesn't
-      # implement AliasPredication. Without these extensions, the interface
-      # just seems inconsistent.
-      def initialize(node)
-        node.extend Arel::Math
-        node.extend Arel::AliasPredication
-        node.extend Arel::OrderPredications
-        super(node)
-      end
-    end
-
-    class Attribute < Generic
-      def initialize(parent, name)
-        @parent = parent
-        @name = name
-        super(parent._table[name])
-      end
-
-      def in(rel)
-        if rel.is_a? ::ActiveRecord::Relation
-          ::Arel::Nodes::In.new(self, Arel.sql(rel.to_sql))
-        else
-          super
-        end
-      end
-
-      def _arel
-        parent_arel = @parent._arel
-        parent_arel &&= parent_arel._arel
-        parent_arel &&= parent_arel.last
-
-        if parent_arel
-          parent_arel.left[@name]
-        else
-          super
-        end
-      end
-    end
   end
 end

data/lib/baby_squeel/nodes/attribute.rb

@@ -0,0 +1,30 @@
+require 'baby_squeel/nodes/node'
+
+module BabySqueel
+  module Nodes
+    class Attribute < Node
+      def initialize(parent, name)
+        @parent = parent
+        @name = name
+        super(parent._table[name])
+      end
+
+      def in(rel)
+        if rel.is_a? ::ActiveRecord::Relation
+          ::Arel::Nodes::In.new(self, Arel.sql(rel.to_sql))
+        else
+          super
+        end
+      end
+
+      def _arel
+        if @parent.kind_of? BabySqueel::Association
+          table = @parent.find_alias(@parent)
+          table ? table[@name] : super
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/baby_squeel/nodes/function.rb

@@ -0,0 +1,13 @@
+require 'baby_squeel/nodes/node'
+
+module BabySqueel
+  module Nodes
+    # See: https://github.com/rails/arel/pull/381
+    class Function < Node
+      def initialize(node)
+        super
+        node.extend Arel::OrderPredications
+      end
+    end
+  end
+end

data/lib/baby_squeel/nodes/grouping.rb

@@ -0,0 +1,16 @@
+require 'baby_squeel/nodes/node'
+
+module BabySqueel
+  module Nodes
+    # See: https://github.com/rails/arel/pull/435
+    class Grouping < Node
+      def initialize(node)
+        super
+        node.extend Arel::AliasPredication
+        node.extend Arel::OrderPredications
+        node.extend Arel::Math
+        node.extend Arel::Expressions
+      end
+    end
+  end
+end

data/lib/baby_squeel/nodes/node.rb

@@ -0,0 +1,18 @@
+require 'baby_squeel/operators'
+require 'baby_squeel/nodes/proxy'
+
+module BabySqueel
+  module Nodes
+    # This is a generic proxy class that includes all possible modules.
+    # In the future, these proxy classes should be more specific and only
+    # include necessary/applicable modules.
+    class Node < Proxy
+      extend Operators::ArelAliasing
+      include Operators::Comparison
+      include Operators::Equality
+      include Operators::Generic
+      include Operators::Grouping
+      include Operators::Matching
+    end
+  end
+end

data/lib/baby_squeel/nodes/proxy.rb

@@ -0,0 +1,36 @@
+module BabySqueel
+  module Nodes
+    # This proxy class allows us to quack like any arel object. When a
+    # method missing is hit, we'll instantiate a new proxy object.
+    class Proxy < ActiveSupport::ProxyObject
+      # Resolve constants the normal way
+      def self.const_missing(name)
+        ::Object.const_get(name)
+      end
+
+      attr_reader :_arel
+
+      def initialize(arel)
+        @_arel = Nodes.unwrap(arel)
+      end
+
+      def inspect
+        "BabySqueel{#{super}}"
+      end
+
+      def respond_to?(meth, include_private = false)
+        meth.to_s == '_arel' || _arel.respond_to?(meth, include_private)
+      end
+
+      private
+
+      def method_missing(meth, *args, &block)
+        if _arel.respond_to?(meth)
+          Nodes.wrap _arel.send(meth, *Nodes.unwrap(args), &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/baby_squeel/operators.rb

@@ -9,7 +9,7 @@ module BabySqueel
       # * +arel_name+ - The name of the Arel method you want to alias.
       #
       # ==== Example
-      #    BabySqueel::Nodes::Generic.arel_alias :unlike, :does_not_match
+      #    BabySqueel::Nodes::Node.arel_alias :unlike, :does_not_match
       #    Post.where.has { title.unlike 'something' }
       #
       def arel_alias(operator, arel_name)

data/lib/baby_squeel/relation.rb

@@ -15,19 +15,24 @@ module BabySqueel
       if reflection = _scope.reflect_on_association(name)
         Association.new(self, reflection)
       else
-        raise AssociationNotFoundError.new(_table_name, name)
+        not_found_error! name, type: AssociationNotFoundError
       end
     end
 
+    # Invokes a sifter defined on the model
+    #
+    # ==== Examples
+    #     Post.where.has { sift(:name_contains, 'joe') }
+    #
     def sift(sifter_name, *args)
       Nodes.wrap _scope.public_send("sift_#{sifter_name}", *args)
     end
 
     private
 
-    # @override BabySqueel::Table#_table_name
-    def _table_name
-      _scope.model_name
+    # @override BabySqueel::Table#not_found_error!
+    def not_found_error!(name, type: NotFoundError)
+      raise type.new(_scope.model_name, name)
     end
 
     # @override BabySqueel::Table#resolve

data/lib/baby_squeel/table.rb

@@ -1,12 +1,12 @@
-require 'baby_squeel/join_dependency'
+require 'baby_squeel/join_expression'
 
 module BabySqueel
   class Table
-    attr_accessor :_on, :_join, :_table
+    attr_accessor :_on, :_table
+    attr_writer :_join
 
     def initialize(arel_table)
       @_table = arel_table
-      @_join = Arel::Nodes::InnerJoin
     end
 
     # See Arel::Table#[]
@@ -14,23 +14,27 @@ module BabySqueel
       Nodes::Attribute.new(self, key)
     end
 
+    def _join
+      @_join ||= Arel::Nodes::InnerJoin
+    end
+
     # Alias a table. This is only possible when joining
     # an association explicitly.
     def alias(alias_name)
       clone.alias! alias_name
     end
 
-    def alias!(alias_name)
+    def alias!(alias_name) # :nodoc:
       self._table = _table.alias(alias_name)
       self
     end
 
-    # Instruct the table to be joined with an INNER JOIN.
+    # Instruct the table to be joined with a LEFT OUTER JOIN.
     def outer
       clone.outer!
     end
 
-    def outer!
+    def outer! # :nodoc:
       self._join = Arel::Nodes::OuterJoin
       self
     end
@@ -40,7 +44,7 @@ module BabySqueel
       clone.inner!
     end
 
-    def inner!
+    def inner! # :nodoc:
       self._join = Arel::Nodes::InnerJoin
       self
     end
@@ -50,26 +54,48 @@ module BabySqueel
       clone.on! node
     end
 
-    def on!(node)
-      self._on = Arel::Nodes::On.new(node)
+    def on!(node) # :nodoc:
+      self._on = node
       self
     end
 
+    # When referencing a joined table, the tables that
+    # attributes reference can change (due to aliasing).
+    # This method allows BabySqueel::Nodes::Attribute
+    # instances to find what their alias will be.
+    def find_alias(association, associations = [])
+      builder = JoinDependency::Builder.new(_scope.all)
+      builder.ensure_associated(_arel(associations))
+
+      finder = JoinDependency::Finder.new(builder.to_join_dependency)
+      finder.find_alias(association._reflection)
+    end
+
     # This method will be invoked by BabySqueel::Nodes::unwrap. When called,
-    # there are two possible outcomes:
+    # there are three possible outcomes:
     #
-    # 1. Join explicitly using an on clause.
-    # 2. Resolve the assocition's join clauses using ActiveRecord.
+    # 1. Join explicitly using an on clause. Just return Arel.
+    # 2. Implicit join without using an outer join. In this case, we'll just
+    #    give a hash to Active Record, and join the normal way.
+    # 3. Implicit join using an outer join. In this case, we need to use
+    #    Polyamorous to build the join. We'll return a JoinExpression.
     #
     def _arel(associations = [])
-      return unless _on || associations.any?
-      JoinDependency.new(self, associations)
+      if _on
+        _join.new(_table, Arel::Nodes::On.new(_on))
+      elsif associations.any?(&:needs_polyamorous?)
+        JoinExpression.new(associations)
+      elsif associations.any?
+        associations.reverse.inject({}) do |names, assoc|
+          { assoc._reflection.name => names }
+        end
+      end
     end
 
     private
 
-    def _table_name
-      arel_table.name
+    def not_found_error!
+      raise NotImplementedError, 'BabySqueel::Table will never raise a NotFoundError'
     end
 
     def resolve(name)
@@ -82,10 +108,7 @@ module BabySqueel
 
     def method_missing(name, *args, &block)
       return super if !args.empty? || block_given?
-
-      resolve(name) || begin
-        raise NotFoundError.new(_table_name, name)
-      end
+      resolve(name) || not_found_error!(name)
     end
   end
 end

data/lib/baby_squeel/version.rb

@@ -1,3 +1,3 @@
 module BabySqueel
-  VERSION = '0.3.1'.freeze
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: baby_squeel
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Ray Zane
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-02 00:00:00.000000000 Z
+date: 2016-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 4.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: polyamorous
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -88,17 +102,28 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- ISSUE_TEMPLATE.md
 - LICENSE.txt
 - README.md
 - baby_squeel.gemspec
 - lib/baby_squeel.rb
-- lib/baby_squeel/active_record.rb
+- lib/baby_squeel/active_record/base.rb
+- lib/baby_squeel/active_record/query_methods.rb
+- lib/baby_squeel/active_record/where_chain.rb
 - lib/baby_squeel/association.rb
 - lib/baby_squeel/compat.rb
 - lib/baby_squeel/dsl.rb
 - lib/baby_squeel/errors.rb
-- lib/baby_squeel/join_dependency.rb
+- lib/baby_squeel/join_dependency/builder.rb
+- lib/baby_squeel/join_dependency/finder.rb
+- lib/baby_squeel/join_dependency/injector.rb
+- lib/baby_squeel/join_expression.rb
 - lib/baby_squeel/nodes.rb
+- lib/baby_squeel/nodes/attribute.rb
+- lib/baby_squeel/nodes/function.rb
+- lib/baby_squeel/nodes/grouping.rb
+- lib/baby_squeel/nodes/node.rb
+- lib/baby_squeel/nodes/proxy.rb
 - lib/baby_squeel/operators.rb
 - lib/baby_squeel/relation.rb
 - lib/baby_squeel/table.rb
@@ -123,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A tiny squeel implementation without all of the evil.

data/lib/baby_squeel/join_dependency.rb

@@ -1,62 +0,0 @@
-module BabySqueel
-  class JoinDependency
-    delegate :_scope, :_join, :_on, :_table, to: :@table
-
-    def initialize(table, associations = [])
-      @table = table
-      @associations = associations
-    end
-
-    if ActiveRecord::VERSION::STRING < '4.1.0'
-      def bind_values
-        return [] unless relation?
-        _scope.joins(join_names(@associations)).bind_values
-      end
-    else
-      def bind_values
-        return [] unless relation?
-        relation = _scope.joins(join_names(@associations))
-        relation.arel.bind_values + relation.bind_values
-      end
-    end
-
-    # Converts an array of BabySqueel::Associations into an array
-    # of Arel join nodes.
-    #
-    # Each association is built individually so that the correct
-    # Arel join node will be used for each individual association.
-    def _arel
-      if _on
-        [_join.new(_table, _on)]
-      else
-        @associations.each.with_index.inject([]) do |joins, (assoc, i)|
-          construct @associations[0..i], joins, assoc._join
-        end
-      end
-    end
-
-    private
-
-    def relation?
-      @table.kind_of? BabySqueel::Relation
-    end
-
-    def construct(associations, theirs, join_node)
-      names = join_names associations
-      mine = build names, join_node
-      theirs + mine[theirs.length..-1]
-    end
-
-    def build(names, join_node)
-      _scope.joins(names).join_sources.map do |join|
-        join_node.new(join.left, join.right)
-      end
-    end
-
-    def join_names(associations = [])
-      associations.reverse.inject({}) do |names, assoc|
-        { assoc._reflection.name => names }
-      end
-    end
-  end
-end