piggyback 0.2.3 → 0.2.4

data/CHANGELOG

@@ -1,3 +1,7 @@
+= 0.2.4 / 2011-03-24
+
+  * Changed join type from INNER to OUTER
+
 = 0.2.3 / 2011-03-21
 
   * Updated documentation.

data/README.markdown

@@ -18,25 +18,23 @@ This is best illustrated in an example. Consider these models:
     
 ActiveRecord supports piggybacking simply by joining the associated table and selecting columns from it:
 
-    post = Post.joins(:author).select('posts.*, author.name AS author_name').first
+    post = Post.select('posts.*, author.name AS author_name') \
+               .joins("JOIN authors ON posts.author_id = authors.id") \
+               .first
 
-    post.title
-    # => "Why piggybacking in ActiveRecord is flawed"
-    
-    post.author_name
-    # => "Alec Smart"
+    post.title        # => "Why piggybacking in ActiveRecord is flawed"    
+    post.author_name  # => "Alec Smart"
     
 As you can see, the `name` attribute from `Author` is treated as if it were an attribute of `Post`. ActiveRecord dynamically determines a model's attributes from the result set returned by the database. Every column in the result set becomes an attribute of the instantiated ActiveRecord objects. Whether the columns originate from the model's own or from a foreign table doesn't make a difference.
 
 Or so it seems. Actually there is a drawback which becomes obvious when we select non-string columns:
 
-    post = Post.joins(:author).select('posts.*, author.birthday AS author_birthday, author.rating AS author_rating').first
-
-    post.author_birthday
-    # => "2011-03-01"
+    post = Post.select('posts.*, author.birthday AS author_birthday, author.rating AS author_rating') \
+               .joins("JOIN authors ON posts.author_id = authors.id") \
+               .first
 
-    post.author_rating
-    # => "4.5"
+    post.author_birthday  # => "2011-03-01"
+    post.author_rating    # => "4.5"
     
 Any attributes originating from the `authors` table are treated as strings instead of being automatically type-casted as we would expect. The database returns result sets as plain text and ActiveRecord needs to obtain type information separately from the table schema in order to do its type-casting magic. Unfortunately, a model only knows about the columns types in its own table, so type-casting doesn't work with columns selected from foreign tables.
 
@@ -65,7 +63,6 @@ You simply declare which association you want to piggyback and how the attribute
 
     class Post < ActiveRecord::Base
       belongs_to :author
-      
       piggybacks :author, :birthday => :author_birthday, :rating => :author_rating 
     end
 
@@ -73,19 +70,16 @@ Now you can do the following:
 
     post = Post.piggyback(:author).first
 
-    post.author_birthday
-    # => Tue, 01 Mar 2011
-
-    post.author_rating
-    # => 4.5
+    post.author_birthday  # => Tue, 01 Mar 2011
+    post.author_rating    # => 4.5
 
 The type-casting works with any type of attribute, even with serialized ones.
 
-As you can see, the `piggibacks` statement replaces the `joins` and `select` parts of the query. Using it is optional but makes life easier since you don't have to write the SQL for `select` by hand.
+As you can see, the `piggibacks` statement replaces the `joins` and `select` parts of the query. Using it is optional but makes life easier. In certain situations however, you may want to select columns by hand or use another kind of join for related table. By default `piggibacks` uses `OUTER JOIN` in order to include both records that have an associated record and ones that don't.
 
 Of course, `piggibacks` plays nice with Arel and you can add additional `joins`, `select` and other statements as you like, for example:
 
-    Post.select('posts.title, posts.body').piggibacks(:author).joins(:comments).where(:published => true)
+    Post.select('posts.title, posts.body').piggibacks(:author).where(:published => true)
 
 __Please note:__ If you want to restrict the columns selected from the master table as in the example above, you have to do so _before_ the `piggibacks` statement. Otherwise it will insert the select-all wildcard `SELECT posts.*` rendering your column selection useless.
 
@@ -100,11 +94,9 @@ If you want to use an SQL-expression for selecting an attribute, Piggyback can a
 
     class Post < ActiveRecord::Base
       belongs_to :author
-  
       piggybacks :author, :author_name => "authors.first_name || ' ' || authors.last_name" 
     end
 
-    post.author_name
-    # => "Donald Duck"
+    post.author_name  # => "Donald Duck"
     
 In fact, every value you pass in as a string will be treated as raw SQL in the SELECT clause.

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rake'  
 require 'echoe'  
   
-Echoe.new('piggyback', '0.2.3') do |p|  
+Echoe.new('piggyback', '0.2.4') do |p|  
   p.description     = "Piggyback attributes from associated models with ActiveRecord"  
   p.url             = "http://github.com/juni0r/piggyback"  
   p.author          = "Andreas Korth"  

data/lib/piggyback.rb

@@ -3,7 +3,7 @@ module Piggyback
   
   class Association #:nodoc:
     
-    attr_reader :reflection, :mappings
+    attr_reader :mappings
     
     def initialize(reflection, mappings = {})
       @reflection = reflection
@@ -14,12 +14,32 @@ module Piggyback
       @mappings.merge!(mappings)
     end
     
-    def map(&block)
-      @mappings.map(&block)
+    def table
+      @table ||= @reflection.active_record.arel_table      
     end
     
-    def attributes
-      @mappings.keys
+    def foreign_table
+      @foreign_table ||= @reflection.klass.arel_table      
+    end
+    
+    def select
+      @mappings.map do |attr_name, mapped_name|
+        if attr_name == mapped_name
+          foreign_table[attr_name]
+        elsif mapped_name.is_a? Arel::Nodes::SqlLiteral
+          mapped_name.as(attr_name)
+        else
+          foreign_table[mapped_name].as(attr_name)
+        end
+      end      
+    end
+    
+    def joins
+      if @reflection.belongs_to?
+        table.join(foreign_table, Arel::Nodes::OuterJoin).on(foreign_table.primary_key.eq(table[@reflection.primary_key_name]))
+      else
+        table.join(foreign_table, Arel::Nodes::OuterJoin).on(foreign_table[@reflection.primary_key_name].eq(table.primary_key))
+      end.join_sql
     end
     
     def has_attribute?(attr_name)
@@ -29,14 +49,10 @@ module Piggyback
     def column(attr_name)
       @reflection.klass.columns_hash[@mappings[attr_name]]
     end
-
+    
     def serialized_attribute(attr_name)
       @reflection.klass.serialized_attributes[@mappings[attr_name]]
     end
-    
-    def quoted_table_name
-      @reflection.klass.quoted_table_name
-    end
   end
 
   module ClassMethods
@@ -94,25 +110,15 @@ module Piggyback
     end
 
     def piggyback_attributes(assoc_name)
-      piggyback_associations[assoc_name].attributes
+      piggyback_associations[assoc_name].mappings.keys
     end
 
-    def piggyback(*assoc_names)
-      columns = piggyback_associations.values_at(*assoc_names).map do |association|
-        association.map do |attr_name, mapped_name|
-          if attr_name == mapped_name
-            "#{association.quoted_table_name}.#{connection.quote_column_name(attr_name)}"
-          else
-            if mapped_name.is_a? Arel::Nodes::SqlLiteral
-              "#{mapped_name} AS #{attr_name}"
-            else
-              "#{association.quoted_table_name}.#{connection.quote_column_name(mapped_name)} AS #{attr_name}"
-            end
-          end
-        end
+    def piggyback(*assocs)
+      context = scoped
+      context = context.select("#{quoted_table_name}.*") unless context.select_values.any?
+      piggyback_associations.values_at(*assocs).inject(context) do |ctx, assoc|
+        ctx.select(assoc.select).joins(assoc.joins)
       end
-      columns.unshift("#{quoted_table_name}.*") unless scoped.select_values.any?
-      select(columns.flatten.join(', ')).joins(*assoc_names)
     end
   end
 end

data/piggyback.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{piggyback}
-  s.version = "0.2.3"
+  s.version = "0.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andreas Korth"]
-  s.date = %q{2011-03-21}
+  s.date = %q{2011-03-24}
   s.description = %q{Piggyback attributes from associated models with ActiveRecord}
   s.email = %q{andreas.korth@gmail.com}
   s.extra_rdoc_files = ["CHANGELOG", "README.markdown", "lib/piggyback.rb"]

data/spec/piggyback_spec.rb

@@ -26,21 +26,28 @@ describe Piggyback do
       end
     end
   end
-  
+      
   context "relation" do
 
-    let :essential do 
-      Essential.create(:token => "TOKEN").create_detail(
+    before do
+      Essential.create!(:token => "ESSENTIAL").create_detail(
         :first_name => "John",
         :last_name  => "Doe",
         :count      => 23,
         :checked    => false,
         :birthday   => "18.12.1974",
         :baggage    => {:key => "value"})
-      
+    end
+
+    let :essential do       
       Essential.piggyback(:detail).first
     end
 
+    it "should include records without an association" do
+      Essential.create!(:token => "WITHOUT_DETAIL")
+      Essential.piggyback(:detail).should have(2).items
+    end
+  
     it "should not load the association" do
       essential.should_not_receive(:detail)
       essential.first_name.should be_present
@@ -73,6 +80,25 @@ describe Piggyback do
     it "should read computed attributes" do
       essential.name.should eql("John Doe")
     end
+
+    it "should work with belongs_to associations" do
+      Detail.piggyback(:essential).first.token.should eql("ESSENTIAL")
+      Detail.create!
+      Detail.piggyback(:essential).should have(2).items
+    end
+  end
+  
+  context "scope" do
+    
+    it "should SELECT * if no columns were selected before" do
+      Essential.piggyback(:detail).to_sql.should match(/^SELECT "essentials"\.\*,/)
+    end
+
+    it "should not SELECT * if columns were selected before" do
+      sql = Essential.select(:id).piggyback(:detail).to_sql
+      sql.should match(/^SELECT id,/)
+      sql.should_not match(/"essentials"\.\*/)
+    end
   end
   
   it "should return the column names for a given association name" do

metadata

@@ -2,7 +2,7 @@
 name: piggyback
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors: 
 - Andreas Korth
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 +01:00
+date: 2011-03-24 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency