piggyback 0.3.0b → 0.5.0

data/CHANGELOG

@@ -1,3 +1,11 @@
+= 0.5.0 / 2011-11-19
+
+  * Changed syntax for attribute mappings
+
+= 0.4.0 / 2011-09-01
+
+  * Conform to ActiveRecord 3.1.0
+
 = 0.3.0b / 2011-08-13
 
   * Changed API to be attribute-based

data/Manifest

@@ -4,7 +4,7 @@ Manifest
 README.markdown
 Rakefile
 lib/piggyback.rb
-piggyback.tmproj
+piggyback.gemspec
 spec/models.rb
 spec/piggyback_spec.rb
 spec/spec_helper.rb

data/README.markdown

@@ -64,9 +64,7 @@ You simply declare which association you want to piggyback and how the attribute
     class Post < ActiveRecord::Base
       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
+      piggyback_attr :name, :email, { :user_rating => :rating , :member_since => :created_at }, :from => :user
     end
 
 Now you can do the following:
@@ -107,9 +105,17 @@ If you want to use an SQL-expression for selecting an attribute, Piggyback can a
 
     class Post < ActiveRecord::Base
       belongs_to :user
-      piggybacks :name, :from => :user, :source => :first_name, :sql => "users.first_name || ' ' || users.last_name" 
+      piggyback_attr ({ :user_name => "users.first_name || ' ' || users.last_name" }), :from => :user,  
     end
 
     post.user_name  # => "Donald Duck"
     
-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.
+Or you could compute a numeric value. In this case however, you'll want to add the name of the original column to get proper type casting for the computed value. If you don't specifiy the column name, the result be a string instead of a float. You specify the column by passing an array containing the SQL statement and the name of the column:
+    
+    class Post < ActiveRecord::Base
+      belongs_to :user
+      piggyback_attr ({ :monthly_salary  => [ "users.salary / 12", :salary ] }), :from => :user,  
+    end
+
+    post.monthly_salary  # => 1300.0
+

data/Rakefile

@@ -1,15 +1,37 @@
 require 'rake'  
 require 'echoe'  
-  
-Echoe.new('piggyback', '0.3.0b') do |p|  
+
+Echoe.new('piggyback', '0.5.0') do |p|  
+
   p.description     = "Piggyback attributes from associated models with ActiveRecord"  
   p.url             = "http://github.com/juni0r/piggyback"  
   p.author          = "Andreas Korth"  
   p.email           = "andreas.korth@gmail.com"  
-  p.ignore_pattern  = ["tmp/*", "log/*", "Gemfile", "Gemfile.lock"]
 
-  p.runtime_dependencies     = ["activerecord >=3.0.0"] 
-  p.development_dependencies = ["rspec", "sqlite3"]
+  p.retain_gemspec = true
+
+  p.ignore_pattern = %w{ 
+    Gemfile 
+    Gemfile.lock 
+    vendor/**/*
+    tmp/*
+    log/*
+    *.tmproj
+  }
+                 
+  p.runtime_dependencies     = [ "activerecord >=3.1.0" ]
+  p.development_dependencies = [ "echoe", "rspec", "sqlite3" ]
 end  
   
-Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task default: :spec

data/lib/piggyback.rb

@@ -1,107 +1,144 @@
 module Piggyback
   extend ActiveSupport::Concern
   
+  included do
+    class_attribute :piggyback_attributes
+    self.piggyback_attributes = {}
+  end
+  
   module ClassMethods
 
-    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
+
+        if column = attribute.column
+          columns_hash[attribute.name] = column
+        end
+
+        if klass = attribute.serialized_class
+          serialized_attributes[attribute.name] = klass
         end
       end
       super
     end    
     
     def piggyback_attr(*attributes)
-      
       options = attributes.extract_options!
-      options.assert_valid_keys(:from, :source, :sql)
+      options.assert_valid_keys(:from)
 
       raise ArgumentError, "No attributes specified for piggybacking"  if attributes.empty?      
       
-      if attributes.many? && (options[:source] || options[:sql])
-        raise ArgumentError, "Options :source and :sql can only be used with a single attribute" 
-      end
+      from = options[:from]
+      reflection = reflect_on_association(from)
       
-      attributes.each do |attr_name|
-        attribute = Attribute.new(self, attr_name, options)
-        piggyback_attributes[attribute.name] = attribute
+      raise ArgumentError, "#{self.name} has no association #{from.inspect}"              if reflection.nil?      
+      raise ArgumentError, "Piggyback only supports belongs_to and has_one associations"  if reflection.collection?
+          
+      attributes.each do |attribute|
+        case attribute
+          
+        when Symbol
+          add_piggyback_attribute(reflection, attribute)
+
+        when Hash
+          mappings = attribute
+          mappings.each do |attribute, mapping|
+            case mapping
+
+            when Symbol
+              add_piggyback_attribute(reflection, attribute, source: mapping)
+
+            when String
+              add_piggyback_attribute(reflection, attribute, sql: mapping)
+
+            when Array
+              add_piggyback_attribute(reflection, attribute, sql: mapping.first, source: mapping.last)
+            end
+          end
+        end        
       end
     end
     
     def piggyback(*attr_names)
-      attr_names.flatten!
-      options = attr_names.extract_options!
       
-      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
+      options = attr_names.extract_options!
 
-      attr_names.map!(&:to_s).uniq!
+      attr_names.flatten!
+      attr_names.map!(&:to_s)
 
-      attributes = []
       piggybacks = []
+      attributes = []
       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
+      if attr_names.empty?
+        
+        if options.has_key?(:from)          
+          froms = Array.wrap(options[:from])          
+          piggybacks = piggyback_attributes.values.select do |attribute|
+            froms.include?(attribute.reflection.name)
+          end          
         else
-          attribute = arel_table[attr_name]
-          raise "Unkown attribute #{attr_name}" if attribute.nil?
-          attributes << attribute
-        end        
+          piggybacks = piggyback_attributes.values
+        end
+
+      else
+        attr_names.uniq.each do |attr_name|
+          if attribute = piggyback_attributes[attr_name]
+            piggybacks << attribute
+          elsif attribute = arel_table[attr_name]
+            attributes << attribute
+          else
+            raise "Unkown attribute #{attr_name}"
+          end        
+        end
       end
-      
-      if !scoped.select_values.any? && attributes.empty?
-        attributes << "#{quoted_table_name}.*"
+
+      if scoped.select_values.none? && attributes.empty?
+        attributes << "#{quoted_table_name}.*" 
+      end
+
+      piggybacks.each do |attribute|
+        attributes << attribute.select
+        joins      << attribute.reflection.name
       end
+
+      context = select(attributes)
       
-      context = select(attributes + piggybacks)
-      joins.any? ? context.joins(joins.uniq) : context
+      if joins.any?
+        dependency = ActiveRecord::Associations::JoinDependency.new(self, joins.uniq.compact, [])
+        joins = dependency.join_associations.each{ |assoc| assoc.join_type = Arel::OuterJoin }
+        context.joins(joins)
+      else
+        context        
+      end      
+    end
+    
+    private
+    
+    def add_piggyback_attribute(reflection, name, options = {})
+      attribute = Attribute.new(reflection, name, options)
+      self.piggyback_attributes = piggyback_attributes.merge(attribute.name => attribute)
     end
   end
 
   class Attribute #:nodoc:
 
-    attr_reader :owner, :name, :from, :source, :sql, :reflection
+    attr_reader :reflection, :name, :sql, :source
 
-    def initialize(owner, name, options = {})
-      @owner  = owner
+    def initialize(reflection, name, options = {})
+      @reflection  = reflection
       @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?
+      if options[:sql]
+        @sql = Arel.sql(options[:sql])
+        @source = options[:source].to_s if options[:source]
+      else
+        @source = (options[:source] || name).to_s
+      end
     end
     
-    def select_sql
-      unless defined? @select_sql 
-        @select_sql = if sql
+    def select
+      unless defined? @select 
+        @select = if sql
           sql.as(Arel.sql(name))
         elsif source == name
           reflection.klass.arel_table[name]
@@ -109,35 +146,15 @@ module Piggyback
           reflection.klass.arel_table[source].as(Arel.sql(name))
         end
       end
-      @select_sql
-    end
-    
-    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
+      @select
     end
-        
+
     def column
-      unless defined? @column
-        @column = reflection.klass.columns_hash[source]
-      end
-      @column
+      reflection.klass.columns_hash[source]
     end
 
     def serialized_class
-      unless defined? @serialized_class
-        @serialized_class = reflection.klass.serialized_attributes[source]
-      end
-      @serialized_class
+      reflection.klass.serialized_attributes[source]
     end
   end  
 end

data/piggyback.gemspec

@@ -1,37 +1,40 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{piggyback}
-  s.version = "0.3.0b"
+  s.name = "piggyback"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  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 = [%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 = [%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.8.8}
-  s.summary = %q{Piggyback attributes from associated models with ActiveRecord}
+  s.authors = ["Andreas Korth"]
+  s.date = "2011-11-19"
+  s.description = "Piggyback attributes from associated models with ActiveRecord"
+  s.email = "andreas.korth@gmail.com"
+  s.extra_rdoc_files = ["CHANGELOG", "README.markdown", "lib/piggyback.rb"]
+  s.files = ["CHANGELOG", "MIT-LICENSE", "Manifest", "README.markdown", "Rakefile", "lib/piggyback.rb", "piggyback.gemspec", "spec/models.rb", "spec/piggyback_spec.rb", "spec/spec_helper.rb"]
+  s.homepage = "http://github.com/juni0r/piggyback"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Piggyback", "--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "piggyback"
+  s.rubygems_version = "1.8.11"
+  s.summary = "Piggyback attributes from associated models with ActiveRecord"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 3.1.0"])
+      s.add_development_dependency(%q<echoe>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<sqlite3>, [">= 0"])
     else
-      s.add_dependency(%q<activerecord>, [">= 3.0.0"])
+      s.add_dependency(%q<activerecord>, [">= 3.1.0"])
+      s.add_dependency(%q<echoe>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<sqlite3>, [">= 0"])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 3.0.0"])
+    s.add_dependency(%q<activerecord>, [">= 3.1.0"])
+    s.add_dependency(%q<echoe>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<sqlite3>, [">= 0"])
   end

data/spec/models.rb

@@ -13,31 +13,47 @@ silence_stream(STDOUT) do
       t.string  :last_name
       t.string  :words
       t.integer :count
+      t.float   :salary
       t.boolean :checked
       t.date    :birthday
       t.text    :baggage
 
       t.timestamps
     end
+    
+    create_table :features do |t|
+      t.belongs_to :essential
+      t.integer :value
+      t.boolean :active
+    end
   end
 end
 
 class Essential < ActiveRecord::Base
-  has_one :detail, :inverse_of => :essential
+  has_one :detail, inverse_of: :essential
   has_many :details
   
   piggyback_attr  :first_name, 
                   :last_name, 
-                  :count, 
+                  :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"
+                  :baggage,
+                  { :updated => :updated_at }, 
+                  { 
+                    :name    => "details.first_name || ' ' || details.last_name",
+                    :monthly => [ "details.salary / 12", :salary ]
+                  }, 
+                  from: :detail
+
+  has_one  :feature, conditions:{ active:true }
+  has_many :features
+
+  piggyback_attr :value, from: :feature
 end
 
 class Detail < ActiveRecord::Base
-  belongs_to :essential, :inverse_of => :detail
+  belongs_to :essential, inverse_of: :detail
 
   serialize :baggage
 
@@ -47,3 +63,7 @@ class Detail < ActiveRecord::Base
     "#{first_name} #{last_name}"
   end
 end
+
+class Feature < ActiveRecord::Base
+  belongs_to :essential, :inverse_of => :detail
+end

data/spec/piggyback_spec.rb

@@ -27,17 +27,29 @@ describe Piggyback do
     end
   end
   
+  it "should respect association options" do
+    essential = Essential.create!
+    Feature.create!(essential_id:essential.id, value:23, active:false)
+    Feature.create!(essential_id:essential.id, value:42, active:true)
+    Feature.create!(essential_id:essential.id, value:45, active:false)      
+    
+    essential = Essential.piggyback.first
+    essential.value.should eql(42)
+  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
+    DETAIL_ATTRIBUTES    = %w{ first_name last_name count checked birthday baggage name updated monthly }
+    FEATURE_ATTRIBUTES   = %w{ value }
+    ALL_ATTRIBUTES       = ESSENTIAL_ATTRIBUTES + DETAIL_ATTRIBUTES + FEATURE_ATTRIBUTES
     
     before do
       Essential.create!(:token => "ESSENTIAL").create_detail(
         :first_name => "John",
         :last_name  => "Doe",
         :count      => 23,
+        :salary     => 14_814,
         :checked    => false,
         :birthday   => "18.12.1974",
         :baggage    => {:key => "value"})
@@ -68,25 +80,17 @@ describe Piggyback do
       essential = Essential.piggyback(:id, :name).first
       essential.attributes.keys.should =~ %w{ id name }
     end
-
-    it "should include all native attributes when using the wildcard :*" do
-      essential = Essential.piggyback(:*).first
-      essential.attributes.keys.should =~ ESSENTIAL_ATTRIBUTES
-    end
-
+    
     it "should include all attributes from the specified associations" do
       essential = Essential.piggyback(from: :detail).first
+      essential.attributes.keys.should =~ ESSENTIAL_ATTRIBUTES + DETAIL_ATTRIBUTES
+      essential = Essential.piggyback(from: [:detail, :feature]).first
       essential.attributes.keys.should =~ ALL_ATTRIBUTES
     end
 
-    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 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 }
+      essential = Essential.piggyback(:id, :token, :first_name, :last_name, :value).first        
+      essential.attributes.keys.should =~ %w{ id token first_name last_name value }
     end
 
     it "should not include native columns if any were selected before" do
@@ -121,12 +125,16 @@ describe Piggyback do
       end
 
       it "should read a mapped attribute" do
-        essential.detail_updated_at.should be_instance_of(Time)
+        essential.updated.should be_instance_of(Time)
       end
 
-      it "should read computed attributes" do
+      it "should read computed string attributes" do
         essential.name.should eql("John Doe")
       end
+
+      it "should read computed float attributes" do
+        essential.monthly.should eql(1234.5)
+      end
     end
   end  
 end

metadata

@@ -1,103 +1,107 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: piggyback
-version: !ruby/object:Gem::Version 
-  prerelease: 5
-  version: 0.3.0b
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Andreas Korth
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-15 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2152819980 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 3.0.0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2152819980
+- !ruby/object:Gem::Dependency
+  name: echoe
+  requirement: &2152819560 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: sqlite3
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *2152819560
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152819100 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: *2152819100
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &2152818640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152818640
 description: Piggyback attributes from associated models with ActiveRecord
 email: andreas.korth@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - CHANGELOG
 - README.markdown
 - lib/piggyback.rb
-files: 
+files:
 - CHANGELOG
 - MIT-LICENSE
 - Manifest
 - README.markdown
 - Rakefile
 - lib/piggyback.rb
-- piggyback.tmproj
+- piggyback.gemspec
 - spec/models.rb
 - spec/piggyback_spec.rb
 - spec/spec_helper.rb
-- piggyback.gemspec
 homepage: http://github.com/juni0r/piggyback
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --line-numbers
 - --inline-source
 - --title
 - Piggyback
 - --main
 - README.markdown
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "1.2"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.2'
 requirements: []
-
 rubyforge_project: piggyback
-rubygems_version: 1.8.8
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Piggyback attributes from associated models with ActiveRecord
 test_files: []
-

data/piggyback.tmproj

@@ -1,169 +0,0 @@
-<?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>