piggyback 0.2.4 → 0.3.0b

data/CHANGELOG

@@ -1,3 +1,7 @@
+= 0.3.0b / 2011-08-13
+
+  * Changed API to be attribute-based
+
 = 0.2.4 / 2011-03-24
 
   * Changed join type from INNER to OUTER

data/Manifest

@@ -1,10 +1,10 @@
 CHANGELOG
 MIT-LICENSE
+Manifest
 README.markdown
 Rakefile
 lib/piggyback.rb
-piggyback.gemspec
+piggyback.tmproj
 spec/models.rb
 spec/piggyback_spec.rb
 spec/spec_helper.rb
-Manifest

data/README.markdown

@@ -4,51 +4,51 @@ An extension for piggybacking of ActiveRecord™ models.
 
 ### What is Piggybacking?
 
-Piggybacking refers to the technique of dynamically including attributes from an associated object into the master object. This is achieved by joining the associated object's table in a database query and selecting the attributes that should be included with the parent object.
+Piggybacking refers to the technique of dynamically including attributes from an associated model. This is achieved by joining the associated model in a database query and selecting the attributes that should be included with the parent object.
 
 This is best illustrated in an example. Consider these models:
 
-    class Author < ActiveRecord::Base
+    class User < ActiveRecord::Base
       has_many :posts
     end
     
     class Post < ActiveRecord::Base
-      belongs_to :author
+      belongs_to :user
     end
     
 ActiveRecord supports piggybacking simply by joining the associated table and selecting columns from it:
 
-    post = Post.select('posts.*, author.name AS author_name') \
-               .joins("JOIN authors ON posts.author_id = authors.id") \
+    post = Post.select('posts.*, user.name AS user_name') \
+               .joins("JOIN users ON posts.user_id = users.id") \
                .first
 
-    post.title        # => "Why piggybacking in ActiveRecord is flawed"    
-    post.author_name  # => "Alec Smart"
+    post.title      # => "Why piggybacking in ActiveRecord is flawed"    
+    post.user_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.
+As you can see, the `name` attribute from `User` 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.select('posts.*, author.birthday AS author_birthday, author.rating AS author_rating') \
-               .joins("JOIN authors ON posts.author_id = authors.id") \
+    post = Post.select('posts.*, user.birthday AS user_birthday, user.rating AS user_rating') \
+               .joins("JOIN users ON posts.user_id = users.id") \
                .first
 
-    post.author_birthday  # => "2011-03-01"
-    post.author_rating    # => "4.5"
+    post.user_birthday  # => "2011-03-01"
+    post.user_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.
+Any attributes originating from the `users` 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.
 
 We could work around this by defining attribute reader methods in the `Post` model that implicitly convert the values:
 
     class Post < ActiveRecord::Base
-      belongs_to :author
+      belongs_to :user
       
-      def author_birthday
-        Date.parse(read_attribute(:author_birthday))
+      def user_birthday
+        Date.parse(read_attribute(:user_birthday))
       end
       
-      def author_rating
-        read_attribute(:author_rating).to_f
+      def user_rating
+        read_attribute(:user_rating).to_f
       end
     end
     
@@ -62,41 +62,54 @@ Piggyback introduces the `piggybacks` directive which allows us to easily define
 You simply declare which association you want to piggyback and how the attribute names should be mapped:
 
     class Post < ActiveRecord::Base
-      belongs_to :author
-      piggybacks :author, :birthday => :author_birthday, :rating => :author_rating 
+      belongs_to :user
+
+      piggyback_attr :name, :email  , :from => :user
+      piggyback_attr :user_rating   , :from => :user, :source => :rating
+      piggyback_attr :member_since  , :from => :user, :source => :created_at
     end
 
 Now you can do the following:
 
-    post = Post.piggyback(:author).first
-
-    post.author_birthday  # => Tue, 01 Mar 2011
-    post.author_rating    # => 4.5
+    posts = Post.piggiback(:name, :email, :user_rating, :member_since)
+    post = posts.first
+    
+    post.name          # => "John Doe"
+    post.user_rating   # => 4.5
+    post.member_since  # => Tue, 01 Mar 2011
 
 The type-casting works with any type of attribute, even with serialized ones.
 
+Since we selected all attributes from the user, we could alternatively have used: 
+
+    posts = Post.piggiback(:from => :user)
+    
+Or we could have as well selected all piggiback attributes simply with:
+
+    posts = Post.piggiback
+
 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).where(:published => true)
+    Post.select('posts.id, posts.body').piggiback(:name, :email).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.
 
 If you don't need to map the attribute names of the piggybacked model, you can simply do:
 
-    piggyback :author, [:name, :birthday, :rating]
+    piggyback_attr :name, :birthday, :rating, :from => :user
 
 
 ### Computed values
 
-If you want to use an SQL-expression for selecting an attribute, Piggyback can also help you with that. If `Author` didn't have a single `name` attribute, but `first_name` and `last_name`, you could concatenate them into a single attribute:
+If you want to use an SQL-expression for selecting an attribute, Piggyback can also help you with that. If `User` didn't have a single `name` attribute, but `first_name` and `last_name`, you could concatenate them into a single attribute:
 
     class Post < ActiveRecord::Base
-      belongs_to :author
-      piggybacks :author, :author_name => "authors.first_name || ' ' || authors.last_name" 
+      belongs_to :user
+      piggybacks :name, :from => :user, :source => :first_name, :sql => "users.first_name || ' ' || users.last_name" 
     end
 
-    post.author_name  # => "Donald Duck"
+    post.user_name  # => "Donald Duck"
     
-In fact, every value you pass in as a string will be treated as raw SQL in the SELECT clause.
+The `:source` option in this case is only required for type-casting and was used because `first_name` is part of the SQL expression. If we would be dealing with a numeric column in this case, the `:source` option would be more relevant since it would be used for type casting.

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rake'  
 require 'echoe'  
   
-Echoe.new('piggyback', '0.2.4') do |p|  
+Echoe.new('piggyback', '0.3.0b') 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

@@ -1,126 +1,145 @@
 module Piggyback
   extend ActiveSupport::Concern
   
-  class Association #:nodoc:
-    
-    attr_reader :mappings
-    
-    def initialize(reflection, mappings = {})
-      @reflection = reflection
-      @mappings   = mappings
-    end
-    
-    def add_mappings(mappings)
-      @mappings.merge!(mappings)
-    end
-    
-    def table
-      @table ||= @reflection.active_record.arel_table      
-    end
-    
-    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)
-      @mappings.has_key? attr_name
-    end
-    
-    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
-  end
-
   module ClassMethods
-    
-    def piggyback_associations
-      read_inheritable_attribute(:piggyback_associations) || write_inheritable_attribute(:piggyback_associations, {})
-    end
-    
-    def piggyback_association_for_attribute(attr_name)
-      piggyback_associations.each_value.detect{ |association| association.has_attribute? attr_name }
+
+    def piggyback_attributes
+      read_inheritable_attribute(:piggyback_attributes) || write_inheritable_attribute(:piggyback_attributes, {})
     end
+
+    def define_attribute_methods
+      piggyback_attributes.values.each do |attribute|
+        columns_hash[attribute.name] = attribute.column
+        if attribute.serialized_class
+          serialized_attributes[attribute.name] = attribute.serialized_class
+        end
+      end
+      super
+    end    
     
-    def piggybacks(association, *attributes)
+    def piggyback_attr(*attributes)
       
-      attributes.flatten!
-      mapped_attributes = attributes.extract_options!
-      reflection = reflect_on_association(association.to_sym)
+      options = attributes.extract_options!
+      options.assert_valid_keys(:from, :source, :sql)
+
+      raise ArgumentError, "No attributes specified for piggybacking"  if attributes.empty?      
       
-      raise ArgumentError, "#{name} has no association named '#{association}'"           if reflection.nil?
-      raise ArgumentError, "Piggyback only supports belongs_to and has_one associations" if reflection.collection?
-      raise ArgumentError, "No attributes specified for piggybacking"                    if attributes.empty?
-            
-      mappings = {}
+      if attributes.many? && (options[:source] || options[:sql])
+        raise ArgumentError, "Options :source and :sql can only be used with a single attribute" 
+      end
       
       attributes.each do |attr_name|
-        mappings[attr_name.to_s] = attr_name.to_s
+        attribute = Attribute.new(self, attr_name, options)
+        piggyback_attributes[attribute.name] = attribute
       end
+    end
+    
+    def piggyback(*attr_names)
+      attr_names.flatten!
+      options = attr_names.extract_options!
       
-      mapped_attributes.each do |attr_name, mapped_name|
-        mappings[attr_name.to_s] = mapped_name.is_a?(String) ? Arel.sql(mapped_name) : mapped_name.to_s
+      if attr_names.empty?
+        attr_names = piggyback_attributes.keys
+      else
+        froms = Array.wrap(options[:from])
+        if froms.any?
+          piggyback_attributes.each_value do |attribute|
+            attr_names << attribute.name if froms.include?(attribute.from)              
+          end
+        end
       end
 
-      association = (piggyback_associations[reflection.name] ||= Association.new(reflection))
-      association.add_mappings(mappings)
+      attr_names.map!(&:to_s).uniq!
 
-      # These default procs for +columns_hash+ and +serialized_attributes+
-      # allow +read_attribute+ to work transparently and consistently with 
-      # attributes from joined models. They rely heavily on the implementation
-      # of +read_attribute+ and related methods. Since ActiveRecord doesn't
-      # provide hooks for overriding this behavior, it is the simplest and
-      # least intrusive way to implement proper type casting for attributes
-      # while avoiding code duplication.
-      
-      columns_hash.default_proc = lambda do |hash, attr_name|
-        if association = piggyback_association_for_attribute(attr_name)
-          association.column(attr_name)
+      attributes = []
+      piggybacks = []
+      joins      = []
+
+      attr_names.each do |attr_name|
+                
+        if attr_name == '*'
+          attributes.concat(arel_table.columns)
+          next
         end
+          
+        attribute = piggyback_attributes[attr_name]
+        if attribute
+          piggybacks << attribute.select_sql
+          joins      << attribute.join_sql
+        else
+          attribute = arel_table[attr_name]
+          raise "Unkown attribute #{attr_name}" if attribute.nil?
+          attributes << attribute
+        end        
+      end
+      
+      if !scoped.select_values.any? && attributes.empty?
+        attributes << "#{quoted_table_name}.*"
       end
+      
+      context = select(attributes + piggybacks)
+      joins.any? ? context.joins(joins.uniq) : context
+    end
+  end
 
-      serialized_attributes.default_proc = lambda do |hash, attr_name|
-        if association = piggyback_association_for_attribute(attr_name)
-          association.serialized_attribute(attr_name)
+  class Attribute #:nodoc:
+
+    attr_reader :owner, :name, :from, :source, :sql, :reflection
+
+    def initialize(owner, name, options = {})
+      @owner  = owner
+      @name   = name.to_s
+      @from   = options[:from]
+      @source = (options[:source] || name).to_s
+      @sql    = Arel.sql(options[:sql]) if options[:sql]
+
+      @reflection = @owner.reflect_on_association(from)
+      
+      raise ArgumentError, "#{@owner} has no association #{from.inspect}"                 if @reflection.nil?      
+      raise ArgumentError, "Piggyback only supports belongs_to and has_one associations"  if @reflection.collection?
+    end
+    
+    def select_sql
+      unless defined? @select_sql 
+        @select_sql = if sql
+          sql.as(Arel.sql(name))
+        elsif source == name
+          reflection.klass.arel_table[name]
+        else
+          reflection.klass.arel_table[source].as(Arel.sql(name))
         end
       end
+      @select_sql
     end
-
-    def piggyback_attributes(assoc_name)
-      piggyback_associations[assoc_name].mappings.keys
+    
+    def join_sql
+      unless defined? @join_sql
+        join_table = reflection.klass.arel_table
+        
+        join = owner.arel_table.join(join_table, Arel::Nodes::OuterJoin)
+        @join_sql = if reflection.belongs_to?
+          join.on(owner.arel_table[reflection.primary_key_name].eq(join_table.primary_key))
+        else
+          join.on(owner.arel_table.primary_key.eq(join_table[reflection.primary_key_name]))
+        end.join_sql
+      end
+      @join_sql
+    end
+        
+    def column
+      unless defined? @column
+        @column = reflection.klass.columns_hash[source]
+      end
+      @column
     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)
+    def serialized_class
+      unless defined? @serialized_class
+        @serialized_class = reflection.klass.serialized_attributes[source]
       end
+      @serialized_class
     end
-  end
+  end  
 end
 
 ActiveRecord::Base.send(:include, Piggyback)

data/piggyback.gemspec

@@ -2,20 +2,20 @@
 
 Gem::Specification.new do |s|
   s.name = %q{piggyback}
-  s.version = "0.2.4"
+  s.version = "0.3.0b"
 
   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-24}
+  s.authors = [%q{Andreas Korth}]
+  s.date = %q{2011-08-15}
   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"]
-  s.files = ["CHANGELOG", "MIT-LICENSE", "README.markdown", "Rakefile", "lib/piggyback.rb", "piggyback.gemspec", "spec/models.rb", "spec/piggyback_spec.rb", "spec/spec_helper.rb", "Manifest"]
+  s.extra_rdoc_files = [%q{CHANGELOG}, %q{README.markdown}, %q{lib/piggyback.rb}]
+  s.files = [%q{CHANGELOG}, %q{MIT-LICENSE}, %q{Manifest}, %q{README.markdown}, %q{Rakefile}, %q{lib/piggyback.rb}, %q{piggyback.tmproj}, %q{spec/models.rb}, %q{spec/piggyback_spec.rb}, %q{spec/spec_helper.rb}, %q{piggyback.gemspec}]
   s.homepage = %q{http://github.com/juni0r/piggyback}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Piggyback", "--main", "README.markdown"]
-  s.require_paths = ["lib"]
+  s.rdoc_options = [%q{--line-numbers}, %q{--inline-source}, %q{--title}, %q{Piggyback}, %q{--main}, %q{README.markdown}]
+  s.require_paths = [%q{lib}]
   s.rubyforge_project = %q{piggyback}
-  s.rubygems_version = %q{1.5.2}
+  s.rubygems_version = %q{1.8.8}
   s.summary = %q{Piggyback attributes from associated models with ActiveRecord}
 
   if s.respond_to? :specification_version then

data/piggyback.tmproj

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>currentDocument</key>
+	<string>lib/piggyback.rb</string>
+	<key>documents</key>
+	<array>
+		<dict>
+			<key>expanded</key>
+			<true/>
+			<key>name</key>
+			<string>piggyback</string>
+			<key>regexFileFilter</key>
+			<string>!.*\.(lock|rvmrc|tmproj|gemspec)|(Manifest)</string>
+			<key>regexFolderFilter</key>
+			<string>!.*/(\.[^/]*|tmp|pkg|log|doc)$</string>
+			<key>sourceDirectory</key>
+			<string></string>
+		</dict>
+	</array>
+	<key>fileHierarchyDrawerWidth</key>
+	<integer>202</integer>
+	<key>metaData</key>
+	<dict>
+		<key>README.markdown</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>288</integer>
+				<key>line</key>
+				<integer>77</integer>
+			</dict>
+			<key>columnSelection</key>
+			<false/>
+			<key>firstVisibleColumn</key>
+			<integer>152</integer>
+			<key>firstVisibleLine</key>
+			<integer>54</integer>
+			<key>selectFrom</key>
+			<dict>
+				<key>column</key>
+				<integer>298</integer>
+				<key>line</key>
+				<integer>77</integer>
+			</dict>
+			<key>selectTo</key>
+			<dict>
+				<key>column</key>
+				<integer>288</integer>
+				<key>line</key>
+				<integer>77</integer>
+			</dict>
+		</dict>
+		<key>lib/piggyback.rb</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>16</integer>
+				<key>line</key>
+				<integer>96</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>72</integer>
+		</dict>
+		<key>spec/models.rb</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>44</integer>
+				<key>line</key>
+				<integer>1</integer>
+			</dict>
+			<key>columnSelection</key>
+			<false/>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+			<key>selectFrom</key>
+			<dict>
+				<key>column</key>
+				<integer>29</integer>
+				<key>line</key>
+				<integer>1</integer>
+			</dict>
+			<key>selectTo</key>
+			<dict>
+				<key>column</key>
+				<integer>44</integer>
+				<key>line</key>
+				<integer>1</integer>
+			</dict>
+		</dict>
+		<key>spec/piggyback_spec.rb</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>spec/spec_helper.rb</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>19</integer>
+				<key>line</key>
+				<integer>4</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+	</dict>
+	<key>openDocuments</key>
+	<array>
+		<string>spec/piggyback_spec.rb</string>
+		<string>README.markdown</string>
+		<string>spec/models.rb</string>
+		<string>spec/spec_helper.rb</string>
+		<string>lib/piggyback.rb</string>
+	</array>
+	<key>showFileHierarchyDrawer</key>
+	<false/>
+	<key>showFileHierarchyPanel</key>
+	<true/>
+	<key>treeState</key>
+	<dict>
+		<key>piggyback</key>
+		<dict>
+			<key>isExpanded</key>
+			<true/>
+			<key>subItems</key>
+			<dict>
+				<key>lib</key>
+				<dict>
+					<key>isExpanded</key>
+					<true/>
+					<key>subItems</key>
+					<dict/>
+				</dict>
+				<key>spec</key>
+				<dict>
+					<key>isExpanded</key>
+					<true/>
+					<key>subItems</key>
+					<dict/>
+				</dict>
+			</dict>
+		</dict>
+	</dict>
+	<key>windowFrame</key>
+	<string>{{93, 131}, {1568, 1024}}</string>
+</dict>
+</plist>

data/spec/models.rb

@@ -26,9 +26,14 @@ class Essential < ActiveRecord::Base
   has_one :detail, :inverse_of => :essential
   has_many :details
   
-  piggybacks :detail, [:first_name, :last_name, :count, :checked, :birthday, :baggage], 
-    :name => "details.first_name || ' ' || details.last_name",
-    :detail_updated_at => :updated_at
+  piggyback_attr  :first_name, 
+                  :last_name, 
+                  :count, 
+                  :checked, 
+                  :birthday, 
+                  :baggage,           from: :detail
+  piggyback_attr  :detail_updated_at, from: :detail, source: :updated_at
+  piggyback_attr  :name,              from: :detail, source: :first_name, sql:"details.first_name || ' ' || details.last_name"
 end
 
 class Detail < ActiveRecord::Base
@@ -36,7 +41,7 @@ class Detail < ActiveRecord::Base
 
   serialize :baggage
 
-  piggybacks :essential, :token
+  piggyback_attr :token, from: :essential
 
   def name
     "#{first_name} #{last_name}"

data/spec/piggyback_spec.rb

@@ -9,26 +9,30 @@ describe Piggyback do
     end
     
     it "should require the association to be defined" do
-      definition_should_raise "Essential has no association named 'bogus'" do
-        piggybacks :bogus, [:attribute]
+      definition_should_raise "Essential has no association :bogus" do
+        piggyback_attr :attribute, from: :bogus
       end
     end
     
     it "should not work with has_many associations" do
       definition_should_raise "Piggyback only supports belongs_to and has_one associations" do
-        piggybacks :details, [:attribute]
+        piggyback_attr :attribute, from: :details
       end
     end
     
     it "should require attributes" do
       definition_should_raise "No attributes specified for piggybacking" do
-        piggybacks :detail
+        piggyback_attr from: :detail
       end
     end
   end
-      
+  
   context "relation" do
 
+    ESSENTIAL_ATTRIBUTES = %w{ id token created_at updated_at }
+    DETAIL_ATTRIBUTES    = %w{ first_name last_name name count checked birthday baggage detail_updated_at }
+    ALL_ATTRIBUTES       = ESSENTIAL_ATTRIBUTES + DETAIL_ATTRIBUTES
+    
     before do
       Essential.create!(:token => "ESSENTIAL").create_detail(
         :first_name => "John",
@@ -39,70 +43,90 @@ describe Piggyback do
         :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
+    it "should work with belongs_to associations" do
+      Detail.piggyback(:token).first.token.should eql("ESSENTIAL")
+      Detail.create!
+      Detail.piggyback(:token).should have(2).items
     end
   
-    it "should not load the association" do
-      essential.should_not_receive(:detail)
-      essential.first_name.should be_present
+    it "should include records without an association" do
+      Essential.create!
+      Essential.piggyback(:name).should have(2).items
     end
-    
-    it "should read string attributes" do
-      essential.first_name.should eql("John")
+
+    it "should include all native and piggybacked attributes if none are specified" do
+      essential = Essential.piggyback.first
+      essential.attributes.keys.should =~ ALL_ATTRIBUTES
     end
 
-    it "should read integer attributes" do
-      essential.count.should eql(23)
+    it "should include all native attributes when none were explicitly specified" do
+      essential = Essential.piggyback(:checked).first
+      essential.attributes.keys.should =~ ESSENTIAL_ATTRIBUTES + %w{ checked }
     end
 
-    it "should read boolean attributes" do
-      essential.checked.should eql(false)
+    it "should include only native attributes that were explicitly specified" do
+      essential = Essential.piggyback(:id, :name).first
+      essential.attributes.keys.should =~ %w{ id name }
     end
 
-    it "should read date attributes" do
-      essential.birthday.should eql(Date.new(1974,12,18))
+    it "should include all native attributes when using the wildcard :*" do
+      essential = Essential.piggyback(:*).first
+      essential.attributes.keys.should =~ ESSENTIAL_ATTRIBUTES
     end
 
-    it "should read serialized attributes" do
-      essential.baggage.should eql({:key => "value"})
+    it "should include all attributes from the specified associations" do
+      essential = Essential.piggyback(from: :detail).first
+      essential.attributes.keys.should =~ ALL_ATTRIBUTES
     end
-    
-    it "should read a mapped attribute" do
-      essential.detail_updated_at.should be_instance_of(Time)
+
+    it "should include all native attributes and those of the specified associations" do
+      essential = Essential.piggyback(:*, from: :detail).first
+      essential.attributes.keys.should =~ ALL_ATTRIBUTES
     end
     
-    it "should read computed attributes" do
-      essential.name.should eql("John Doe")
+    it "should include native and piggybackd attributes as specified" do
+      essential = Essential.piggyback(:id, :token, :first_name, :last_name).first        
+      essential.attributes.keys.should =~ %w{ id token first_name last_name }
     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
+    it "should not include native columns if any were selected before" do
+      essential = Essential.select('essentials.id').piggyback(:checked).first
+      essential.attributes.keys.should =~ %w{ id checked }
     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
+    context "attribute methods" do
+      
+      let :essential do
+        Essential.piggyback.first
+      end
+      
+      it "should read string attributes" do
+        essential.first_name.should eql("John")
+      end
+
+      it "should read integer attributes" do
+        essential.count.should eql(23)
+      end
+
+      it "should read boolean attributes" do
+        essential.checked.should eql(false)
+      end
+
+      it "should read date attributes" do
+        essential.birthday.should eql(Date.new(1974,12,18))
+      end
+
+      it "should read serialized attributes" do
+        essential.baggage.should eql({:key => "value"})
+      end
+
+      it "should read a mapped attribute" do
+        essential.detail_updated_at.should be_instance_of(Time)
+      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"\.\*/)
+      it "should read computed attributes" do
+        essential.name.should eql("John Doe")
+      end
     end
-  end
-  
-  it "should return the column names for a given association name" do
-    Essential.piggyback_attributes(:detail).should =~ 
-      %w{ first_name last_name name count checked birthday baggage detail_updated_at }
-  end
+  end  
 end

data/spec/spec_helper.rb

@@ -12,5 +12,6 @@ end
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:", :verbosity => "silent")
 ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(File.join(GEM_ROOT,'log','test.log'))
+ActiveRecord::Base::include_root_in_json = false
 
 require 'models'

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: piggyback
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.2.4
+  prerelease: 5
+  version: 0.3.0b
 platform: ruby
 authors: 
 - Andreas Korth
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-24 00:00:00 +01:00
-default_executable: 
+date: 2011-08-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -59,15 +58,15 @@ extra_rdoc_files:
 files: 
 - CHANGELOG
 - MIT-LICENSE
+- Manifest
 - README.markdown
 - Rakefile
 - lib/piggyback.rb
-- piggyback.gemspec
+- piggyback.tmproj
 - spec/models.rb
 - spec/piggyback_spec.rb
 - spec/spec_helper.rb
-- Manifest
-has_rdoc: true
+- piggyback.gemspec
 homepage: http://github.com/juni0r/piggyback
 licenses: []
 
@@ -96,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: piggyback
-rubygems_version: 1.5.2
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: Piggyback attributes from associated models with ActiveRecord