preferences 0.1.4 → 0.1.5

data/CHANGELOG.rdoc

@@ -1,5 +1,10 @@
 == master
 
+== 0.1.5 / 2008-11-16
+
+* Add all prefers/preferred accessors for preferences to be analogous to ActiveRecord column accessors
+* Fix preferences defined in STI subclasses not working [Quinn Shanahan]
+
 == 0.1.4 / 2008-10-26
 
 * Change how the base module is included to prevent namespacing conflicts

data/README.rdoc

@@ -31,12 +31,12 @@ Generally, basic preferences can be accomplished through simple designs, such as
 additional columns or a bit vector described and implemented by preference_fu[http://agilewebdevelopment.com/plugins/preferencefu].
 However, as you find the need for non-binary preferences and the number of
 preferences becomes unmanageable as individual columns in the database, the next
-step is often to create a separate "preferences" table.  This is where the +preferences+
-plugin comes in.
+step is often to create a separate "preferences" table.  This is where the
++preferences+ plugin comes in.
 
-+preferences+ encapsulates this design by hiding the fact that preferences are
-stored in a separate table and making it dead-simple to define and manage
-preferences.
++preferences+ encapsulates this design by exposing preferences using simple
+attribute accessors on the model, hiding the fact that preferences are stored in
+a separate table and making it dead-simple to define and manage preferences.
 
 == Usage
 
@@ -60,26 +60,28 @@ In the above model, 5 preferences have been defined:
 * language
 
 For each preference, a data type and default value can be specified.  If no
-data type is given, it's considered a boolean value.  If no default value is
+data type is given, it's assumed to be a boolean value.  If no default value is
 given, the default is assumed to be nil.
 
 === Accessing preferences
 
-Once preferences have been defined for a model, they can be accessed either using
-the shortcut methods that are generated for each preference or the generic methods
-that are not specific to a particular preference.
+Once preferences have been defined for a model, they can be accessed either
+using the accessor methods that are generated for each preference or the generic
+methods that are not specific to a particular preference.
 
-==== Shortcut methods
+==== Accessors
 
-There are several shortcut methods that are generated.  They are shown below.
+There are several shortcut methods that are generated for each preference
+defined on a model.  These reflect the same set of methods (attribute accessors)
+that are generated for a model's columns.  Examples of these are shown below:
 
 Query methods:
   user.prefers_hot_salsa?         # => false
-  user.prefers_dark_chocolate?    # => false
+  user.preferred_language?        # => true
 
 Reader methods:
-  user.preferred_color      # => nil
-  user.preferred_language   # => "English"
+  user.prefers_hot_salsa          # => false
+  user.preferred_language         # => "English"
 
 Writer methods:
   user.prefers_hot_salsa = false        # => false
@@ -87,16 +89,16 @@ Writer methods:
 
 ==== Generic methods
 
-Each shortcut method is essentially a wrapper for the various generic methods
+Each preference accessor is essentially a wrapper for the various generic methods
 shown below:
 
 Query method:
-  user.prefers?(:hot_salsa)       # => false
-  user.prefers?(:dark_chocolate)  # => false
+  user.prefers?(:hot_salsa)     # => false
+  user.preferred?(:language)    # => true
 
 Reader method:
-  user.preferred(:color)      # => nil
-  user.preferred(:language)   # => "English"
+  user.prefers(:hot_salsa)      # => false
+  user.preferred(:language)     # => "English"
 
 Write method:
   user.set_preference(:hot_salsa, false)      # => false
@@ -135,7 +137,7 @@ through an example:
   user.preferred_color = 'red', car
   # user.set_preference(:color, 'red', car) # The generic way
 
-This will create a preference for the color "red" for the given car.  In this way,
+This will create a color preference of "red" for the given car.  In this way,
 you can have "color" preferences for different records.
 
 To access the preference for a particular record, you can use the same accessor
@@ -160,11 +162,11 @@ preferences by name.  For example,
 
 === Saving preferences
 
-Note that preferences are not saved until the owning record is saved.  Preferences
-are treated in a similar fashion to attributes.  For example,
+Note that preferences are not saved until the owning record is saved.
+Preferences are treated in a similar fashion to attributes.  For example,
 
   user = user.find(:first)
-  user.attributes = {:preferred_color => 'red'}
+  user.attributes = {:prefers_hot_salsa => false, :preferred_color => 'red'}
   user.save!
 
 Preferences are stored in a separate table called "preferences".

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/contrib/sshpublisher'
 
 spec = Gem::Specification.new do |s|
   s.name              = 'preferences'
-  s.version           = '0.1.4'
+  s.version           = '0.1.5'
   s.platform          = Gem::Platform::RUBY
   s.summary           = 'Adds support for easily creating custom preferences for models'
   

data/app/models/preference.rb

@@ -43,7 +43,10 @@ class Preference < ActiveRecord::Base
   
   # The definition for the attribute
   def definition
-    owner_type.constantize.preference_definitions[attribute] if owner_type
+    # Optimize number of queries to the database by only looking up the actual
+    # owner record for STI cases when the definition can't be found in the
+    # stored owner type class
+    owner_type && (find_definition(owner_type.constantize) || find_definition(owner.class))
   end
   
   # Typecasts the value depending on the preference definition's declared type
@@ -58,4 +61,11 @@ class Preference < ActiveRecord::Base
     group_id ? group_without_optional_lookup : group_type
   end
   alias_method_chain :group, :optional_lookup
+  
+  private
+    # Finds the definition for this preference's attribute in the given owner
+    # class.
+    def find_definition(owner_class)
+      owner_class.respond_to?(:preference_definitions) && owner_class.preference_definitions[attribute]
+    end
 end

data/lib/preferences.rb

@@ -20,11 +20,35 @@ module PluginAWeek #:nodoc:
   #   u = User.find_by_login('admin')
   #   u.attributes = {:prefers_notifications => true}
   #   u.save!
+  # 
+  # == Validations
+  # 
+  # Since the generated accessors for a preference allow the preference to be
+  # treated just like regular ActiveRecord column attributes, they can also be
+  # validated against in the same way.  For example,
+  # 
+  #   class User < ActiveRecord::Base
+  #     preference :color, :string
+  #     
+  #     validates_presence_of :preferred_color
+  #     validates_inclusion_of :preferred_color, :in => %w(red green blue)
+  #   end
+  #   
+  #   u = User.new
+  #   u.valid?                        # => false
+  #   u.errors.on(:preferred_color)   # => "can't be blank"
+  #   
+  #   u.preferred_color = 'white'
+  #   u.valid?                        # => false
+  #   u.errors.on(:preferred_color)   # => "is not included in the list"
+  #   
+  #   u.preferred_color = 'red'
+  #   u.valid?                        # => true
   module Preferences
     module MacroMethods
-      # Defines a new preference for all records in the model.  By default, preferences
-      # are assumed to have a boolean data type, so all values will be typecasted
-      # to true/false based on ActiveRecord rules.
+      # Defines a new preference for all records in the model.  By default,
+      # preferences are assumed to have a boolean data type, so all values will
+      # be typecasted to true/false based on ActiveRecord rules.
       # 
       # Configuration options:
       # * +default+ - The default value for the preference. Default is nil.
@@ -47,34 +71,37 @@ module PluginAWeek #:nodoc:
       # 
       # After the first preference is defined, the following associations are
       # created for the model:
-      # * +stored_preferences+ - A collection of all the custom preferences specified for a record
+      # * +stored_preferences+ - A collection of all the custom preferences specified for a record.  This will not include default preferences unless they have been explicitly set.
       # 
-      # == Generated shortcut methods
+      # == Generated accessors
       # 
       # In addition to calling <tt>prefers?</tt> and +preferred+ on a record, you
-      # can also use the shortcut methods that are generated when a preference is
-      # defined.  For example,
+      # can also use the shortcut accessor methods that are generated when a
+      # preference is defined.  For example,
       # 
       #   class User < ActiveRecord::Base
       #     preference :notifications
       #   end
       # 
       # ...generates the following methods:
-      # * <tt>prefers_notifications?</tt> - The same as calling <tt>record.prefers?(:notifications)</tt>
-      # * <tt>prefers_notifications=(value)</tt> - The same as calling <tt>record.set_preference(:notifications, value)</tt>
-      # * <tt>preferred_notifications</tt> - The same as called <tt>record.preferred(:notifications)</tt>
-      # * <tt>preferred_notifications=(value)</tt> - The same as calling <tt>record.set_preference(:notifications, value)</tt>
+      # * <tt>prefers_notifications?</tt> - Whether a value has been specified, i.e. <tt>record.prefers?(:notifications)</tt>
+      # * <tt>prefers_notifications</tt> - The actual value stored, i.e. <tt>record.prefers(:notifications)</tt>
+      # * <tt>prefers_notifications=(value)</tt> - Sets a new value, i.e. <tt>record.set_preference(:notifications, value)</tt>
+      # * <tt>preferred_notifications?</tt> - Whether a value has been specified, i.e. <tt>record.preferred?(:notifications)</tt>
+      # * <tt>preferred_notifications</tt> - The actual value stored, i.e. <tt>record.preferred(:notifications)</tt>
+      # * <tt>preferred_notifications=(value)</tt> - Sets a new value, i.e. <tt>record.set_preference(:notifications, value)</tt>
       # 
       # Notice that there are two tenses used depending on the context of the
       # preference.  Conventionally, <tt>prefers_notifications?</tt> is better
-      # for boolean preferences, while +preferred_color+ is better for non-boolean
-      # preferences.
+      # for accessing boolean preferences, while +preferred_color+ is better for
+      # accessing non-boolean preferences.
       # 
       # Example:
       # 
       #   user = User.find(:first)
       #   user.prefers_notifications?         # => false
-      #   user.prefers_color?                 # => true
+      #   user.prefers_notifications          # => false
+      #   user.preferred_color?               # => true
       #   user.preferred_color                # => 'red'
       #   user.preferred_color = 'blue'       # => 'blue'
       #   
@@ -83,7 +110,7 @@ module PluginAWeek #:nodoc:
       #   car = Car.find(:first)
       #   user.preferred_color = 'red', car   # => 'red'
       #   user.preferred_color(car)           # => 'red'
-      #   user.prefers_color?(car)            # => true
+      #   user.preferred_color?(car)          # => true
       #   
       #   user.save!  # => true
       def preference(attribute, *args)
@@ -109,25 +136,27 @@ module PluginAWeek #:nodoc:
         self.preference_definitions[attribute] = definition
         self.default_preferences[attribute] = definition.default_value
         
-        # Create short-hand helper methods, making sure that the attribute
+        # Create short-hand accessor methods, making sure that the attribute
         # is method-safe in terms of what characters are allowed
         attribute = attribute.gsub(/[^A-Za-z0-9_-]/, '').underscore
         
         # Query lookup
-        define_method("prefers_#{attribute}?") do |*group|
-          prefers?(attribute, group.first)
+        define_method("preferred_#{attribute}?") do |*group|
+          preferred?(attribute, group.first)
         end
-        
-        # Writer
-        define_method("prefers_#{attribute}=") do |*args|
-          set_preference(*([attribute] + [args].flatten))
-        end
-        alias_method "preferred_#{attribute}=", "prefers_#{attribute}="
+        alias_method "prefers_#{attribute}?", "preferred_#{attribute}?"
         
         # Reader
         define_method("preferred_#{attribute}") do |*group|
           preferred(attribute, group.first)
         end
+        alias_method "prefers_#{attribute}", "preferred_#{attribute}"
+        
+        # Writer
+        define_method("preferred_#{attribute}=") do |*args|
+          set_preference(*([attribute] + [args].flatten))
+        end
+        alias_method "prefers_#{attribute}=", "preferred_#{attribute}="
         
         definition
       end
@@ -156,7 +185,7 @@ module PluginAWeek #:nodoc:
       #   user.preferences
       #   => {"language"=>"English", "color"=>nil, "cars"=>{"language=>"English", "color"=>"red"}}
       #   
-      # Getting preference values for the owning record:
+      # Getting preference values *just* for the owning record (i.e. excluding groups):
       #   user.preferences(nil)
       #   => {"language"=>"English", "color"=>nil}
       #   
@@ -169,6 +198,9 @@ module PluginAWeek #:nodoc:
           conditions = {}
         else
           group = args.first
+          
+          # Split the actual group into its different parts (id/type) in case
+          # a record is passed in
           group_id, group_type = Preference.split_group(group)
           conditions = {:group_id => group_id, :group_type => group_type}
         end
@@ -189,61 +221,81 @@ module PluginAWeek #:nodoc:
         end
       end
       
-      # Queries whether or not a value has been specified for the given attribute.
-      # This is dependent on how the value is type-casted.
+      # Queries whether or not a value is present for the given attribute.  This
+      # is dependent on how the value is type-casted.
       # 
       # == Examples
       # 
-      #   user = User.find(:first)
-      #   user.prefers?(:notifications)             # => true
+      #   class User < ActiveRecord::Base
+      #     preference :color, :string, :default => 'red'
+      #   end
       #   
-      #   user.prefers(:notifications, 'error')     # => true
+      #   user = User.create
+      #   user.preferred(:color)              # => "red"
+      #   user.preferred?(:color)             # => true
+      #   user.preferred?(:color, 'cars')     # => true
+      #   user.preferred?(:color, Car.first)  # => true
       #   
-      #   newsgroup = Newsgroup.find(:first)
-      #   user.prefers?(:notifications, newsgroup)  # => false
-      def prefers?(attribute, group = nil)
+      #   user.set_preference(:color, nil)
+      #   user.preferred(:color)              # => nil
+      #   user.preferred?(:color)             # => false
+      def preferred?(attribute, group = nil)
         attribute = attribute.to_s
         
         value = preferred(attribute, group)
         preference_definitions[attribute].query(value)
       end
+      alias_method :prefers?, :preferred?
       
-      # Gets the preferred value for the given attribute.
+      # Gets the actual value stored for the given attribute, or the default
+      # value if nothing is present.
       # 
       # == Examples
       # 
-      #   user = User.find(:first)
-      #   user.preferred(:color)          # => 'red'
+      #   class User < ActiveRecord::Base
+      #     preference :color, :string, :default => 'red'
+      #   end
       #   
-      #   user.preferred(:color, 'cars')  # => 'blue'
+      #   user = User.create
+      #   user.preferred(:color)            # => "red"
+      #   user.preferred(:color, 'cars')    # => "red"
+      #   user.preferred(:color, Car.first) # => "red"
       #   
-      #   car = Car.find(:first)
-      #   user.preferred(:color, car)     # => 'black'
+      #   user.set_preference(:color, 'blue')
+      #   user.preferred(:color)            # => "blue"
       def preferred(attribute, group = nil)
         attribute = attribute.to_s
         
         if @preference_values && @preference_values[attribute] && @preference_values[attribute].include?(group)
+          # Value for this attribute/group has been written, but not saved yet:
+          # grab from the pending values
           value = @preference_values[attribute][group]
         else
+          # Split the group being filtered
           group_id, group_type = Preference.split_group(group)
+          
+          # Grab the first preference; if it doesn't exist, use the default value
           preference = stored_preferences.find(:first, :conditions => {:attribute => attribute, :group_id => group_id, :group_type => group_type})
           value = preference ? preference.value : preference_definitions[attribute].default_value
         end
         
         value
       end
+      alias_method :prefers, :preferred
       
       # Sets a new value for the given attribute.  The actual Preference record
-      # is *not* created until the actual record is saved.
+      # is *not* created until this record is saved.  In this way, preferences
+      # act *exactly* the same as attributes.  They can be written to and
+      # validated against, but won't actually be written to the database until
+      # the record is saved.
       # 
       # == Examples
       # 
       #   user = User.find(:first)
-      #   user.set_preference(:notifications, false) # => false
+      #   user.set_preference(:color, 'red')              # => "red"
       #   user.save!
       #   
-      #   newsgroup = Newsgroup.find(:first)
-      #   user.set_preference(:notifications, true, newsgroup)  # => true
+      #   user.set_preference(:color, 'blue', Car.first)  # => "blue"
       #   user.save!
       def set_preference(attribute, value, group = nil)
         attribute = attribute.to_s

data/lib/preferences/preference_definition.rb

@@ -24,25 +24,20 @@ module PluginAWeek #:nodoc:
       end
       
       # Typecasts the value based on the type of preference that was defined.
-      # This uses ActiveRecord's typecast functionality.
+      # This uses ActiveRecord's typecast functionality so the same rules for
+      # typecasting a model's columns apply here.
       def type_cast(value)
-        if @type == 'any'
-          value
-        else
-          @column.type_cast(value)
-        end
+        @type == 'any' ? value : @column.type_cast(value)
       end
       
       # Typecasts the value to true/false depending on the type of preference
       def query(value)
-        unless value = type_cast(value)
+        if !(value = type_cast(value))
           false
+        elsif @column.number?
+          !value.zero?
         else
-          if @column.number?
-            !value.zero?
-          else
-            !value.blank?
-          end
+          !value.blank?
         end
       end
     end

data/test/app_root/app/models/employee.rb

@@ -0,0 +1,2 @@
+class Employee < ActiveRecord::Base
+end

data/test/app_root/app/models/manager.rb

@@ -0,0 +1,3 @@
+class Manager < Employee
+  preference :health_insurance
+end

data/test/app_root/db/migrate/003_create_employees.rb

@@ -0,0 +1,12 @@
+class CreateEmployees < ActiveRecord::Migration
+  def self.up
+    create_table :employees do |t|
+      t.string :name, :null => false
+      t.string :type
+    end
+  end
+  
+  def self.down
+    drop_table :employees
+  end
+end

data/test/factory.rb

@@ -39,6 +39,16 @@ module Factory
     )
   end
   
+  build Employee do |attributes|
+    attributes.reverse_merge!(
+      :name => 'John Smith'
+    )
+  end
+  
+  build Manager do |attributes|
+    valid_employee_attributes(attributes)
+  end
+  
   build Preference do |attributes|
     attributes[:owner] = create_user unless attributes.include?(:owner)
     attributes.reverse_merge!(

data/test/functional/preferences_test.rb

@@ -12,22 +12,30 @@ class PreferencesTest < Test::Unit::TestCase
     assert_raise(ArgumentError) {User.preference :notifications, :boolean, :invalid => true}
   end
   
-  def test_should_create_prefers_query_method
-    assert @user.respond_to?(:prefers_notifications?)
+  def test_should_create_preferred_query_method
+    assert @user.respond_to?(:preferred_notifications?)
   end
   
-  def test_should_create_prefers_writer
-    assert @user.respond_to?(:prefers_notifications=)
+  def test_should_create_prefers_query_method
+    assert @user.respond_to?(:prefers_notifications?)
   end
   
   def test_should_create_preferred_reader
     assert @user.respond_to?(:preferred_notifications)
   end
   
+  def test_should_create_prefers_reader
+    assert @user.respond_to?(:prefers_notifications)
+  end
+  
   def test_should_create_preferred_writer
     assert @user.respond_to?(:preferred_notifications=)
   end
   
+  def test_should_create_prefers_writer
+    assert @user.respond_to?(:prefers_notifications=)
+  end
+  
   def test_should_create_preference_definitions
     assert User.respond_to?(:preference_definitions)
   end
@@ -53,10 +61,12 @@ class UserByDefaultTest < Test::Unit::TestCase
   
   def test_should_not_prefer_hot_salsa
     assert_nil @user.preferred_hot_salsa
+    assert_nil @user.prefers_hot_salsa
   end
   
   def test_should_prefer_dark_chocolate
     assert_equal true, @user.preferred_dark_chocolate
+    assert_equal true, @user.prefers_dark_chocolate
   end
   
   def test_should_not_have_a_preferred_color
@@ -120,6 +130,11 @@ class UserTest < Test::Unit::TestCase
     assert_equal 'Latin', @user.preferred_language
   end
   
+  def test_should_be_able_to_use_generic_preferred_query_method
+    @user.prefers_hot_salsa = true
+    assert @user.preferred?(:hot_salsa)
+  end
+  
   def test_should_be_able_to_use_generic_prefers_query_method
     @user.prefers_hot_salsa = true
     assert @user.prefers?(:hot_salsa)
@@ -130,6 +145,11 @@ class UserTest < Test::Unit::TestCase
     assert_equal 'blue', @user.preferred(:color)
   end
   
+  def test_should_be_able_to_use_generic_prefers_method
+    @user.preferred_color = 'blue'
+    assert_equal 'blue', @user.prefers(:color)
+  end
+  
   def test_should_be_able_to_use_generic_set_preference_method
     @user.set_preference(:color, 'blue')
     assert_equal 'blue', @user.preferred(:color)

data/test/unit/preference_definition_test.rb

@@ -95,8 +95,8 @@ class PreferenceDefinitionWithBooleanTypeTest < Test::Unit::TestCase
     assert_equal true, @definition.type_cast('true')
   end
   
-  def test_should_type_cast_to_false_if_value_is_not_true_string
-    assert_equal false, @definition.type_cast('')
+  def test_should_type_cast_to_nil_if_value_is_not_true_string
+    assert_nil @definition.type_cast('')
   end
   
   def test_should_query_false_if_value_is_nil

data/test/unit/preference_test.rb

@@ -43,19 +43,19 @@ class PreferenceTest < Test::Unit::TestCase
   def test_should_require_an_attribute
     preference = new_preference(:attribute => nil)
     assert !preference.valid?
-    assert_equal 1, Array(preference.errors.on(:attribute)).size
+    assert preference.errors.invalid?(:attribute)
   end
   
   def test_should_require_an_owner_id
     preference = new_preference(:owner => nil)
     assert !preference.valid?
-    assert_equal 1, Array(preference.errors.on(:owner_id)).size
+    assert preference.errors.invalid?(:owner_id)
   end
   
   def test_should_require_an_owner_type
     preference = new_preference(:owner => nil)
     assert !preference.valid?
-    assert_equal 1, Array(preference.errors.on(:owner_type)).size
+    assert preference.errors.invalid?(:owner_type)
   end
   
   def test_should_not_require_a_group_id
@@ -78,7 +78,7 @@ class PreferenceTest < Test::Unit::TestCase
     preference = new_preference(:group => nil)
     preference.group_id = 1
     assert !preference.valid?
-    assert_equal 1, Array(preference.errors.on(:group_type)).size
+    assert preference.errors.invalid?(:group_type)
   end
   
   def test_should_protect_attributes_from_mass_assignment
@@ -209,3 +209,26 @@ class PreferenceWithBooleanAttributeTest < Test::Unit::TestCase
     User.default_preferences.delete('notifications')
   end
 end
+
+class PreferenceWithSTIOwnerTest < Test::Unit::TestCase
+  def setup
+    @manager = create_manager
+    @preference = create_preference(:owner => @manager, :attribute => 'health_insurance', :value => true)
+  end
+  
+  def test_should_have_an_owner
+    assert_equal @manager, @preference.owner
+  end
+  
+  def test_should_have_an_owner_type
+    assert_equal 'Employee', @preference.owner_type
+  end
+  
+  def test_should_have_a_definition
+    assert_not_nil @preference.definition
+  end
+  
+  def test_should_have_a_value
+    assert_equal true, @preference.value
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: preferences
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Aaron Pfeifer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-26 00:00:00 -04:00
+date: 2008-12-04 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -27,25 +27,28 @@ files:
 - lib/preferences
 - lib/preferences/preference_definition.rb
 - lib/preferences.rb
-- test/app_root
-- test/app_root/app
-- test/app_root/app/models
-- test/app_root/app/models/car.rb
-- test/app_root/app/models/user.rb
-- test/app_root/config
-- test/app_root/config/environment.rb
-- test/app_root/db
-- test/app_root/db/migrate
-- test/app_root/db/migrate/001_create_users.rb
-- test/app_root/db/migrate/003_migrate_preferences_to_version_1.rb
-- test/app_root/db/migrate/002_create_cars.rb
+- test/factory.rb
+- test/test_helper.rb
 - test/functional
 - test/functional/preferences_test.rb
-- test/test_helper.rb
-- test/factory.rb
 - test/unit
 - test/unit/preference_test.rb
 - test/unit/preference_definition_test.rb
+- test/app_root
+- test/app_root/db
+- test/app_root/db/migrate
+- test/app_root/db/migrate/004_migrate_preferences_to_version_1.rb
+- test/app_root/db/migrate/002_create_cars.rb
+- test/app_root/db/migrate/001_create_users.rb
+- test/app_root/db/migrate/003_create_employees.rb
+- test/app_root/config
+- test/app_root/config/environment.rb
+- test/app_root/app
+- test/app_root/app/models
+- test/app_root/app/models/car.rb
+- test/app_root/app/models/manager.rb
+- test/app_root/app/models/user.rb
+- test/app_root/app/models/employee.rb
 - CHANGELOG.rdoc
 - init.rb
 - LICENSE