baby_squeel 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4dec1d36d240f113d9122c83549c06601f29124c
-  data.tar.gz: f97d4bc708832c1895e0e612c6bd76dfe63b6877
+  metadata.gz: 3569d1726ce4c979428cbc2fed31fe8103f16405
+  data.tar.gz: 7d60acb4736d2a7cdda1e921bcb32ac1b8597601
 SHA512:
-  metadata.gz: 7be1b2e3d861f50328cb1a9b05f8e02099a1db3c33dfeda3259a77667291b8f3b373d3e0a395230b1b64af7b8d8c2d559f52e31752c7e20401371e5eaa1fecaf
-  data.tar.gz: 877ad6134d70a905a9142f92265e059ef48e49edd9ef513445a966b0a2a22758c0e1792be9180b749be5d2673e5e817a15550fe93e465eb61e2440709bd9b770
+  metadata.gz: 81b72fb9e8b0f80dc8a0c5e52b215ed89e8f8801407ec2a60747f06171f35b9e6f8d0970c7009573092b17eaaa67ea8fabfa8dcf542b1aa0396b777df966bd4a
+  data.tar.gz: fdcbff4355e934d51d6f6e57e19fdbda28a93eac0acb3ea91b4fc1d1d7c9ed84ae06c75dcb500a72325577374df38c0969ebef9dbee45b08a7cd0845de27c374

data/.rubocop.yml

@@ -7,9 +7,15 @@ Style/BlockDelimiters:
 Style/Documentation:
   Enabled: false
 
+Style/SpecialGlobalVars:
+  Enabled: false
+
 Style/NilComparison:
   Exclude:
     - spec/**/*
 
 Metrics/LineLength:
   Max: 100
+
+Metrics/AbcSize:
+  Enabled: false

data/.travis.yml

@@ -16,4 +16,5 @@ env:
     - AR=4.1.15
     - AR=4.2.0
     - AR=4.2.6
+    - AR=5.0.0.beta2
     - AR=5.0.0.beta3

data/README.md

@@ -53,41 +53,6 @@ Post.joins(:author).selecting { [id, author.id] }
 # INNER JOIN "authors" ON "posts"."author_id" = "authors"."id"
 ```
 
-#### Joins
-
-```ruby
-Post.joining { author }
-# SELECT "posts".* FROM "posts"
-# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
-
-Post.joining { [author.outer, comments] }
-# SELECT "posts".* FROM "posts"
-# LEFT OUTER JOIN "authors" ON "authors"."id" = "posts"."author_id"
-# INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
-
-Post.joining { author.comments }
-# SELECT "posts".* FROM "posts"
-# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
-# INNER JOIN "comments" ON "comments"."author_id" = "authors"."id"
-
-Post.joining { author.outer.comments.outer }
-# SELECT "posts".* FROM "posts"
-# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
-# LEFT OUTER JOIN "comments" ON "comments"."author_id" = "authors"."id"
-
-Post.joining { author.comments.outer }
-# SELECT "posts".* FROM "posts"
-# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
-# LEFT OUTER JOIN "comments" ON "comments"."author_id" = "authors"."id"
-
-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"
-# )
-```
-
 #### Wheres
 
 ```ruby
@@ -110,6 +75,16 @@ Post.joins(:author).where.has { author.name == 'Ray' }
 # WHERE "authors"."name" = 'Ray'
 ```
 
+Here's the best part. Where conditions will always reference the correct table alias for a given association:
+
+```ruby
+Post.joins(author: :posts).where.has { author.posts.title =~ '%fun%' }
+# SELECT "posts".* FROM "posts"
+# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+# INNER JOIN "posts" "posts_authors" ON "posts_authors"."author_id" = "authors"."id"
+# WHERE ("posts_authors"."title" LIKE '%fun%')
+```
+
 #### Orders
 
 ```ruby
@@ -130,6 +105,47 @@ Post.joins(:author).ordering { author.id.desc }
 # ORDER BY "authors"."id" DESC
 ```
 
+
+#### Joins
+
+```ruby
+Post.joining { author }
+# SELECT "posts".* FROM "posts"
+# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+
+Post.joining { [author.outer, comments] }
+# SELECT "posts".* FROM "posts"
+# LEFT OUTER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+# INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+
+Post.joining { author.comments }
+# SELECT "posts".* FROM "posts"
+# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+# INNER JOIN "comments" ON "comments"."author_id" = "authors"."id"
+
+Post.joining { author.outer.comments.outer }
+# SELECT "posts".* FROM "posts"
+# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+# LEFT OUTER JOIN "comments" ON "comments"."author_id" = "authors"."id"
+
+Post.joining { author.comments.outer }
+# SELECT "posts".* FROM "posts"
+# INNER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+# LEFT OUTER JOIN "comments" ON "comments"."author_id" = "authors"."id"
+
+Post.joining { author.outer.posts }
+# SELECT "posts".* FROM "posts"
+# LEFT OUTER JOIN "authors" ON "authors"."id" = "posts"."author_id"
+# INNER JOIN "posts" "posts_authors" ON "posts_authors"."author_id" = "authors"."id"
+
+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"
+# )
+```
+
 #### Functions
 
 ```ruby
@@ -158,7 +174,7 @@ You can also run `bin/console` to open up a prompt where you'll have access to s
 
 ## Todo
 
-I'd like to support complex joins with explicit outer joins and aliasing.
++ Subqueries
 
 ## Contributing
 

data/Rakefile

@@ -15,9 +15,10 @@ def run_version(version, cmd)
     system({ 'AR' => version }, cmd)
   end
 
-  abort "\nFAILED: #{display}" unless $CHILD_STATUS.success?
+  abort "\nFAILED: #{display}" unless $?.success?
 end
 
+desc 'Run against all ActiveRecord versions'
 task 'spec:matrix' do
   travis = YAML.load_file '.travis.yml'
 

data/lib/baby_squeel.rb

@@ -7,4 +7,5 @@ module BabySqueel
 end
 
 ::ActiveRecord::Base.extend BabySqueel::ActiveRecord::QueryMethods
+::ActiveRecord::Relation.prepend BabySqueel::ActiveRecord::QueryMethods
 ::ActiveRecord::QueryMethods::WhereChain.prepend BabySqueel::ActiveRecord::WhereChain

data/lib/baby_squeel/active_record.rb

@@ -3,14 +3,17 @@ require 'baby_squeel/dsl'
 module BabySqueel
   module ActiveRecord
     module QueryMethods
+      # Constructs Arel for ActiveRecord::Base#joins using the DSL.
       def joining(&block)
-        joins DSL.evaluate(self, &block)
+        joins DSL.evaluate(unscoped, &block)
       end
 
+      # Constructs Arel for ActiveRecord::Base#select using the DSL.
       def selecting(&block)
         select DSL.evaluate(self, &block)
       end
 
+      # Constructs Arel for ActiveRecord::Base#order using the DSL.
       def ordering(&block)
         order DSL.evaluate(self, &block)
       end
@@ -18,6 +21,7 @@ module BabySqueel
 
     module WhereChain
       if ::ActiveRecord::VERSION::MAJOR > 4
+        # Constructs Arel for ActiveRecord::Base#where using the DSL.
         def has(&block)
           opts = DSL.evaluate(@scope, &block)
           factory = @scope.send(:where_clause_factory)
@@ -25,6 +29,7 @@ module BabySqueel
           @scope
         end
       else
+        # Constructs Arel for ActiveRecord::Base#where using the DSL.
         def has(&block)
           @scope.where_values += [DSL.evaluate(@scope, &block)]
           @scope

data/lib/baby_squeel/association.rb

@@ -1,42 +1,45 @@
 require 'baby_squeel/table'
-require 'baby_squeel/join_dependency'
 
 module BabySqueel
-  class AliasingError < StandardError
-    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
-
-    def initialize(association, alias_name)
-      super format(MESSAGE, association: association, alias_name: alias_name)
-    end
-  end
-
   class Association < Table
-    def initialize(parent, reflection)
-      @parent = parent
-      @reflection = reflection
-      super(@reflection.klass)
-    end
-
-    def _arel
-      props[:on] ? super : ([*@parent._arel] + join_constraints)
+    class AliasingError < StandardError
+      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
+
+      def initialize(association, alias_name)
+        super format(MESSAGE, association: association, alias_name: alias_name)
+      end
     end
 
-    private
-
-    def join_constraints
-      if props[:table].is_a? Arel::Nodes::TableAlias
-        raise AliasingError.new(@reflection.name, props[:table].right)
-      end
+    attr_reader :_reflection
 
-      JoinDependency.new(@scope, @reflection, props[:join]).constraints
+    def initialize(parent, reflection)
+      @parent = parent
+      @_reflection = reflection
+      super(@_reflection.klass)
     end
 
-    def spawn
-      Association.new(@parent, @reflection).tap do |table|
-        table.props = props
+    # Intelligently constructs Arel nodes. There are three outcomes:
+    #
+    # 1. The user explicitly constructed their join using #on.
+    #    See BabySqueel::Table#_arel.
+    #
+    # 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.
+    #
+    # 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.
+    def _arel(associations = [])
+      if _on
+        super
+      elsif _table.is_a? Arel::Nodes::TableAlias
+        raise AliasingError.new(_reflection.name, _table.right)
+      else
+        @parent._arel([self, *associations])
       end
     end
   end

data/lib/baby_squeel/dsl.rb

@@ -4,14 +4,28 @@ require 'baby_squeel/association'
 
 module BabySqueel
   class DSL < Table
+    # Evaluates a block in the context of a new DSL instance.
     def self.evaluate(scope, &block)
       new(scope).evaluate(&block)
     end
 
+    # Create a SQL function. See Arel::Nodes::NamedFunction.
+    #
+    # ==== Arguments
+    #
+    # * +name+ - The name of a SQL function (ex. coalesce).
+    # * +args+ - The arguments to be passed to the SQL function.
+    #
+    # ==== Example
+    #     Post.select { func('coalesce', id, 1) }
+    #     #=> SELECT COALESCE("posts"."id", 1) FROM "posts"
+    #
     def func(name, *args)
       Nodes.wrap Arel::Nodes::NamedFunction.new(name.to_s, args)
     end
 
+    # Evaluates a DSL block. If arity is given, this method
+    # `yield` itself, rather than `instance_eval`.
     def evaluate(&block)
       if block.arity.zero?
         Nodes.unwrap instance_eval(&block)

data/lib/baby_squeel/join_dependency.rb

@@ -1,55 +1,39 @@
-# Props to Arel Helpers
-# https://github.com/camertron/arel-helpers/blob/master/lib/arel-helpers/join_association.rb
-#
-# This is really, really ugly.
-#
 module BabySqueel
   class JoinDependency
-    def initialize(scope, reflection, join_type)
+    def initialize(scope, associations = [])
       @scope = scope
-      @reflection = reflection
-      @join_type = join_type
+      @associations = associations
     end
 
-    if ::ActiveRecord::VERSION::MAJOR > 4
-      def constraints
-        dependency.join_constraints([], @join_type).flat_map(&:joins)
-      end
-    elsif ::ActiveRecord::VERSION::STRING >= '4.2.0'
-      def constraints
-        dependency.join_constraints([]).flat_map do |constraint|
-          constraint.joins.map { |join| rebuild join }
-        end
-      end
-    elsif ::ActiveRecord::VERSION::STRING >= '4.1.0'
-      def constraints
-        dependency.join_constraints([]).flat_map { |join| rebuild join }
-      end
-    else
-      def constraints
-        manager = Arel::SelectManager.new(@scope)
-
-        dependency.join_associations.each do |assoc|
-          assoc.join_type = @join_type
-          assoc.join_to(manager)
-        end
-
-        manager.join_sources
+    # 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 constraints
+      @associations.each.with_index.inject([]) do |joins, (assoc, i)|
+        inject @associations[0..i], joins, assoc._join
       end
     end
 
     private
 
-    def rebuild(join)
-      @join_type.new(join.left, join.right)
+    def inject(associations, theirs, join_node)
+      names = join_names associations
+      mine = build names, join_node
+      theirs + mine[theirs.length..-1]
     end
 
-    def dependency
-      ::ActiveRecord::Associations::JoinDependency.new(
-        @reflection.active_record,
-        [@reflection.name],
-        []
-      )
+    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

data/lib/baby_squeel/nodes.rb

@@ -3,6 +3,8 @@ require 'baby_squeel/operators'
 module BabySqueel
   module Nodes
     class << self
+      # 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)
@@ -11,6 +13,8 @@ module BabySqueel
         end
       end
 
+      # Unwraps a BabySqueel::Proxy before being passed to
+      # ActiveRecord.
       def unwrap(node)
         if node.respond_to? :_arel
           node._arel
@@ -22,9 +26,8 @@ module BabySqueel
       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.
+    # 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)
@@ -52,11 +55,11 @@ module BabySqueel
       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.
+    # 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 Arel::OrderPredications
       include Operators::Comparison
       include Operators::Equality
@@ -64,5 +67,23 @@ module BabySqueel
       include Operators::Grouping
       include Operators::Matching
     end
+
+    class Attribute < Generic
+      def initialize(parent, name)
+        @parent = parent
+        @name = name
+        super(parent._table[name])
+      end
+
+      def _arel
+        parent_arel = @parent._arel
+
+        if parent_arel && parent_arel.last
+          parent_arel.last.left[@name]
+        else
+          super
+        end
+      end
+    end
   end
 end

data/lib/baby_squeel/operators.rb

@@ -1,6 +1,17 @@
 module BabySqueel
   module Operators
     module ArelAliasing
+      # Allows the creation of shorthands for Arel methods.
+      #
+      # ==== Arguments
+      #
+      # * +operator+ - A custom operator.
+      # * +arel_name+ - The name of the Arel method you want to alias.
+      #
+      # ==== Example
+      #    BabySqueel::Nodes::Generic.arel_alias :unlike, :does_not_match
+      #    Post.where { title.unlike 'something' }
+      #
       def arel_alias(operator, arel_name)
         define_method operator do |other|
           send(arel_name, other)
@@ -23,6 +34,17 @@ module BabySqueel
     end
 
     module Generic
+      # Create a SQL operation. See Arel::Nodes::InfixOperation.
+      #
+      # ==== Arguments
+      #
+      # * +operator+ - A SQL operator.
+      # * +other+ - The argument to be passed to the SQL operator.
+      #
+      # ==== Example
+      #    Post.select { title.op('||', 'diddly') }
+      #    #=> SELECT "posts"."title" || 'diddly' FROM "posts"
+      #
       def op(operator, other)
         Nodes.wrap Arel::Nodes::InfixOperation.new(operator, self, other)
       end

data/lib/baby_squeel/table.rb

@@ -1,3 +1,5 @@
+require 'baby_squeel/join_dependency'
+
 module BabySqueel
   class AssociationNotFoundError < StandardError
     def initialize(scope, name)
@@ -6,16 +8,21 @@ module BabySqueel
   end
 
   class Table
-    attr_writer :props
+    attr_accessor :_on, :_join, :_table
 
     def initialize(scope)
       @scope = scope
+      @_table = scope.arel_table
+      @_join = Arel::Nodes::InnerJoin
     end
 
+    # See Arel::Table#[]
     def [](key)
-      Nodes.wrap props[:table][key]
+      Nodes::Attribute.new(self, key)
     end
 
+    # Constructs a new BabySqueel::Association. Raises
+    # an exception if the association is not found.
     def association(name)
       if reflection = @scope.reflect_on_association(name)
         Association.new(self, reflection)
@@ -24,58 +31,63 @@ module BabySqueel
       end
     end
 
+    # Alias a table. This is only possible when joining
+    # an association explicitly.
     def alias(alias_name)
-      spawn.alias! alias_name
+      clone.alias! alias_name
     end
 
     def alias!(alias_name)
-      props.store :table, props[:table].alias(alias_name)
+      self._table = _table.alias(alias_name)
       self
     end
 
+    # Instruct the table to be joined with an INNER JOIN.
     def outer
-      spawn.outer!
+      clone.outer!
     end
 
     def outer!
-      props.store :join, Arel::Nodes::OuterJoin
+      self._join = Arel::Nodes::OuterJoin
       self
     end
 
+    # Instruct the table to be joined with an INNER JOIN.
     def inner
-      spawn.inner!
+      clone.inner!
     end
 
     def inner!
-      props.store :join, Arel::Nodes::InnerJoin
+      self._join = Arel::Nodes::InnerJoin
       self
     end
 
+    # Specify an explicit join.
     def on(node)
-      spawn.on! node
+      clone.on! node
     end
 
     def on!(node)
-      props.store :on, Arel::Nodes::On.new(node)
+      self._on = Arel::Nodes::On.new(node)
       self
     end
 
-    def _arel
-      props[:join].new(props[:table], props[:on]) if props[:on]
+    # This method will be invoked by BabySqueel::Nodes::unwrap. When called,
+    # there are two possible outcomes:
+    #
+    # 1. Join explicitly using an on clause.
+    # 2. Resolve the assocition's join clauses using ActiveRecord.
+    #
+    def _arel(associations = [])
+      if _on
+        _join.new(_table, _on)
+      else
+        JoinDependency.new(@scope, associations).constraints
+      end
     end
 
     private
 
-    def props
-      @props ||= { table: @scope.arel_table, join: Arel::Nodes::InnerJoin }
-    end
-
-    def spawn
-      Table.new(@scope).tap do |table|
-        table.props = props
-      end
-    end
-
     def resolve(name)
       if @scope.column_names.include?(name.to_s)
         self[name]

data/lib/baby_squeel/version.rb

@@ -1,3 +1,3 @@
 module BabySqueel
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: baby_squeel
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ray Zane
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-16 00:00:00.000000000 Z
+date: 2016-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord