thumblemonks-load_model 0.1.0 → 0.2.0

data/README.markdown

@@ -2,8 +2,6 @@
 
 A glorified before_filter that loads an instance of an `ActiveRecord` object as the result of searching for said object against a model defined by a given model name. The value of the HTTP request parameter `:id` will be used as the default lookup value. `LoadModel` will give you the ability to require an instance be found and/or override several other default behaviors.
 
-Example
-
     class SillyFellowController < Application
       load_model :silly_fellow
       def action
@@ -15,20 +13,14 @@ You can require that a model instance be found for all actions or given actions.
 
 To turn require on for all actions, simply pass *true* to a provided `:require` attribute, like so:
 
-Example
-
     load_model :silly_fellow, :require => true
 
 To turn require on for specific actions, pass an array of action names to  `:require`. The model will be loaded for all actions, regardless of whether or not required is provided, but the exception will only be raised when an record is not found for the provided actions.
 
-Example
-
     load_model :silly_fellow, :require => [:show, :update]
 
 To use a different parameter key and model than the default, you can provide the values in the `:paramater_key` and `:class` options (though not necessary to provide them together), like the following:
 
-Example
-
     load_model :foo, :class => :user, :parameter_key => :bar_id
 
 In the above example, `load_model` will assume the parameter_key and the model's primary/foreign key are both the same. For instance, the above example would result in a call like the following:
@@ -37,8 +29,6 @@ In the above example, `load_model` will assume the parameter_key and the model's
 
 If you want to use a different lookup/foreign key than the default, you can also provide that key name using the `:foreign_key` parameter; like so:
 
-Example
-
     load_model :foo, :class => :user, :parameter_key => :bar_id,
       :foreign_key => :baz_id
 
@@ -48,14 +38,12 @@ Which would result in a call similar to the following:
 
 If you want to only use `load_model` for some actions, you can still name them as you would with a `before_filter` using `:only` or `:except`. If you provide an `:only` and an `:except` value. `:only` will always win out over `:except` when there are collisions (i.e. you provide both in the same call)
 
-Example
-
     load_model :foo, :only => [:show]
     load_model :bar, :except => [:create]
 
-Finally, load_model supports a :through option. With :through, you can load a model via the association of an existing loaded model. This is especially useful for RESTful controllers.
+### Through
 
-Example
+Load Model supports a :through option. With :through, you can load a model via the association of an existing loaded model. This is especially useful for RESTful controllers.
 
     load_model :user, :require => true, :parameter_key => :user_id
     load_model :post, :through => :user
@@ -66,8 +54,6 @@ In this example, a @post record will be loaded through the @user record with ess
 
 All of the previously mentioned options still apply (:parameter_key, :foreign_key, :require, :only, and :except) except for the :class option. Meaning you could really mess around!
 
-Example
-
     load_model :user, :require => true, :parameter_key => :user_id
     load_model :post, :through => :person, :parameter_key => :foo_id, 
       :foreign_key => :baz_id
@@ -78,7 +64,33 @@ Would result in a call similar to the following:
 
 Require works as you would expect.
 
-The only current caveat is that load_model assumes a has_many association exists on the :through model and is named in the pluralized form. In essence, in the above example, there is no way to tell load_model not look for the "posts" association. Perhaps a future change.
+If you would like load_model to not assume a pluralized association name, you can provide the association name with the :association option. Like so:
+
+    class Person < ActiveRecord::Base
+      has_many :blog_postings
+    end
+    
+    class PostController < ActionController::Base
+      load_model :post, :through => :person, :assocation => :blog_postings
+    end
+
+### From
+
+Perhaps you don't need to do a subquery on a model's association and you just need to load a model from another's `belongs_to` or `has_one` association. This would be impossible in the above example. Instead, will want to use the :from option. Like so:
+
+    class Post < ActiveRecord::Base
+      belongs_to :user
+    end
+    
+    class PostController < ActionController::Base
+      load_model :post
+      load_model :user, :from => :post
+    end
+
+The example is contrived, but you get the point. Essentially, this would do the same as writing the following code:
+
+    @post = Post.find_by_id(params[:id])
+    @user = @post.user
 
 ## Installation
 

data/lib/load_model.rb

@@ -9,7 +9,7 @@ module ThumbleMonks #:nodoc:
 
     module ClassMethods #:nodoc
       # A glorified before_filter that loads an instance of an ActiveRecord 
-      # object as# the result of searching for said object against a model 
+      # object as the result of searching for said object against a model 
       # defined by a given model name. The value of the HTTP request parameter 
       # :id will be used as the default lookup value. LoadModel will give you 
       # the ability to require an instance be found and/or override several 
@@ -78,7 +78,9 @@ module ThumbleMonks #:nodoc:
       #   load_model :foo, :only => [:show]
       #   load_model :bar, :except => [:create]
       #
-      # Finally, load_model supports a :through option. With :through, you can 
+      # == Through
+      #
+      # Load Model supports a :through option. With :through, you can 
       # load a model via the association of an existing loaded model. This is
       # especially useful for RESTful controllers.
       #
@@ -104,20 +106,48 @@ module ThumbleMonks #:nodoc:
       #
       #   @person.posts.find_by_baz_id(params[:foo_id])
       #
-      # Require works as you would expect
+      # Require works as you would expect.
+      #
+      # If you would like load_model to not assume a pluralized association
+      # name, you can provide the association name with the :association
+      # option. Like so:
+      #
+      # Example
+      #   class Person < ActiveRecord::Base
+      #     has_many :blog_postings
+      #   end
+      #   class PostController < ActionController::Base
+      #     load_model :post, :through => :person, :assocation => :blog_postings
+      #   end
+      #
+      # == From
       #
-      # The only current caveat is that load_model assumes a has_many 
-      # association exists on the :through model and is named in the pluralized 
-      # form. In essence, in the above example, there is no way to tell 
-      # load_model not look for the "posts" association. Perhaps a future 
-      # change.
+      # Perhaps you don't need to do a subquery on a model's association and
+      # you just need to load a model from another's belongs_to or has_one
+      # association. This would be impossible in the above example. Instead,
+      # will want to use the :from option. Like so:
       #
+      # Example
+      #   class Post < ActiveRecord::Base
+      #     belongs_to :user
+      #   end
+      #   class PostController < ActionController::Base
+      #     load_model :post
+      #     load_model :user, :from => :post
+      #   end
+      #
+      # The example is contrived, but you get the point. Essentially, this
+      # would do the same as writing the following code:
+      #
+      # Example
+      #   @post = Post.find_by_id(params[:id])
+      #   @user = @post.user
       def load_model(name, opts={})
         unless loaders
           self.class_eval { before_filter :load_specified_models }
           write_inheritable_attribute(:loaders, [])
         end
-        loaders << (opts[:through] ? ThroughModelLoader : ModelLoader).new(name, opts)
+        loaders << loader_class(opts).new(name, opts)
       end
 
       def loaders; self.read_inheritable_attribute(:loaders); end
@@ -180,10 +210,27 @@ module ThumbleMonks #:nodoc:
         end
       end # ThroughModelLoader
 
+      class FromModelLoader < ModelLoader #:nodoc
+        attr_reader :load_from, :association
+        def initialize(name, opts={})
+          super(name, opts)
+          @load_from = "@#{opts[:from]}".to_sym
+          @association = name.to_s
+        end
+
+        def load_model(controller)
+          controller.instance_variable_get(load_from).send(association)
+        end
+      end # FromModelLoader
+    private
+      def loader_class(opts)
+        return ThroughModelLoader if opts[:through]
+        return FromModelLoader if opts[:from]
+        ModelLoader
+      end
     end # ClassMethods
 
   private
-
     def load_specified_models
       self.class.loaders.each do |loader|
         if loader.action_allowed?(action_name)
@@ -194,8 +241,7 @@ module ThumbleMonks #:nodoc:
           instance_variable_set(loader.assigns_to, obj)
         end
       end
-    end
-
+    end # load_specified_models
   end # LoadModel
 end # ThumbleMonks
 

data/load_model.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "load_model"
-  s.version  = "0.1.0"
-  s.date     = "2009-01-03"
+  s.version  = "0.2.0"
+  s.date     = "2009-03-24"
   s.summary  = "Rails Controller plugin that provides easy and useful macros for tying models and requests together"
   s.email    = %w[gus@gusg.us gabriel.gironda@gmail.com]
   s.homepage = "http://github.com/thumblemonks/load_model"

data/test/functional/keys_controller_test.rb

@@ -1,12 +1,19 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
-class KeysControllerTest < Test::Unit::TestCase
+class KeysController < ActionController::Base
+  # Expects to use fuzzle_id as parameter key against User class with FK of :id
+  load_model :user, :parameter_key => :fuzzle_id
 
+  # Expects to use :fuzzle_id as FK and parameter key against Fuzzle class 
+  # (normal operation)
+  load_model :fuzzler, :parameter_key => :fuzzle_id, :foreign_key => :fuzzle_id,
+    :class => :fuzzle
+
+  def index; render :text => 'hello'; end
+end
+
+class KeysControllerTest < ActionController::TestCase
   def setup
-    super
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = KeysController.new
     @user = User.create!(:name => 'Foo')
     @fuzzler = Fuzzle.create!(:name => 'Bar', :fuzzle_id => 300)
   end
@@ -22,5 +29,4 @@ class KeysControllerTest < Test::Unit::TestCase
     assert_equal @fuzzler.id, assigns(:fuzzler).id
     assert_nil assigns(:user)
   end
-
 end

data/test/functional/require_model_controller_test.rb

@@ -1,13 +1,19 @@
 require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/controller_helper'
 
-class RequireModelControllerTest < Test::Unit::TestCase
+class RequireModelController < ActionController::Base
+  load_model :stuser, :class => :alternate, :parameter_key => :alternate_id,
+    :foreign_key => :alternate_id, :require => nil # never required
+  load_model :fuzzle, :parameter_key => :fuzzle_id, :foreign_key => :fuzzle_id,
+    :require => [:newer] # required for newer action
+  load_model :user, :require => true # required for all actions
 
+  def index; render :text => 'whatever'; end
+  def new; render :text => 'whatever 2'; end
+  def newer; render :text => 'whatever 3'; end
+end
+
+class RequireModelControllerTest < ActionController::TestCase
   def setup
-    super
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = RequireModelController.new
     @foo = User.create!(:name => 'Foo')
   end
 
@@ -41,5 +47,4 @@ class RequireModelControllerTest < Test::Unit::TestCase
       get :new, :id => (@foo.id + 1)
     end
   end
-
 end

data/test/functional/restrict_options_controller_test.rb

@@ -1,12 +1,16 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
-class RestrictOptionsControllerTest < Test::Unit::TestCase
+class RestrictOptionsController < ActionController::Base
+  load_model :user, :only => [:index]
+  load_model :alternate, :except => [:index], :parameter_key => :alternate_id,
+    :foreign_key => :alternate_id
 
+  def index; render :text => 'ran index'; end
+  def show; render :text => 'ran show'; end
+end
+
+class RestrictOptionsControllerTest < ActionController::TestCase
   def setup
-    super
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = RestrictOptionsController.new
     @foo = User.create!(:name => 'Foo')
     @alt = Alternate.create!(:name => 'Bar', :alternate_id => 100)
   end
@@ -30,5 +34,4 @@ class RestrictOptionsControllerTest < Test::Unit::TestCase
     get :show, :id => @foo.id, :alternate_id => @alt.alternate_id
     assert_nil assigns(:user)
   end
-
 end

data/test/functional/through_controller_test.rb

@@ -1,12 +1,22 @@
 require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/controller_helper'
 
-class ThroughControllerTest < Test::Unit::TestCase
+class ThroughController < ActionController::Base
+  load_model :user, :parameter_key => :user_id
+  load_model :post, :through => :user, :except => [:show]
+  # proving that except and only work
+  load_model :post, :through => :user, :parameter_key => 'weird_id',
+    :require => true, :only => [:show]
+
+  load_model :post, :through => :user, :association => :unpublished_posts,
+    :require => true, :only => [:show_unpublished]
+      
+  def index; render :text => 'index'; end
+  def show; render :text => 'show'; end
+  def show_unpublished; render :text => 'unpublished'; end
+end
+
+class ThroughControllerTest < ActionController::TestCase
   def setup
-    super
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = ThroughController.new
     @user = User.create!(:name => 'Foo')
     @post = @user.posts.create!(:name => 'Foo post')
   end
@@ -16,8 +26,8 @@ class ThroughControllerTest < Test::Unit::TestCase
       get :index, :user_id => @user.id, :id => @post.id
     end
     
-    should_assign_to :user, :equals => "@user"
-    should_assign_to :post, :equals => "@post"
+    should_assign_to(:user) { @user }
+    should_assign_to(:post) { @post }
   end # with valid ids
 
   context "show_unpublished with valid id" do
@@ -26,8 +36,8 @@ class ThroughControllerTest < Test::Unit::TestCase
       get :show_unpublished, :user_id => @user.id, :id => @unpublished_post.id
     end
     
-    should_assign_to :user, :equals => "@user"
-    should_assign_to :post, :equals => "@post"
+    should_assign_to(:user) { @user }
+    should_assign_to(:post) { @unpublished_post }
   end
   
   context "index with invalid post id" do
@@ -35,7 +45,7 @@ class ThroughControllerTest < Test::Unit::TestCase
       get :index, :user_id => @user.id, :id => -1
     end
     
-    should_assign_to :user, :equals => "@user"
+    should_assign_to(:user) { @user }
     should_not_assign_to :post
   end # with invalid post id
 
@@ -45,8 +55,8 @@ class ThroughControllerTest < Test::Unit::TestCase
         get :show, :user_id => @user.id, :weird_id => @post.id
       end
     
-      should_assign_to :user, :equals => "@user"
-      should_assign_to :post, :equals => "@post"
+      should_assign_to(:user) { @user }
+      should_assign_to(:post) { @post }
     end # has existing records
 
     context "has nonexistent records for required action" do
@@ -57,5 +67,4 @@ class ThroughControllerTest < Test::Unit::TestCase
       end
     end # has nonexistant records for required action
   end # show with alternative post via weird_id
-
 end

data/test/test_helper.rb

@@ -1,9 +1,15 @@
+def require_local_lib(pattern)
+  Dir.glob(File.join(File.dirname(__FILE__), pattern)).each {|f| require f }
+end
+
 ENV["RAILS_ENV"] = "test"
-ENV["RAILS_ROOT"] = File.expand_path(File.join(File.dirname(__FILE__), '..', 'rails'))
+ENV["RAILS_ROOT"] = File.expand_path(File.join(File.dirname(__FILE__), '..', 'test', 'rails'))
 require File.expand_path(File.join(ENV["RAILS_ROOT"], 'config', 'environment'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'load_model'))
 require 'test_help'
-load(File.dirname(__FILE__) + "/../rails/db/schema.rb")
+load(File.join(ENV["RAILS_ROOT"], "db", "schema.rb"))
+
+# Models
 
 class User < ActiveRecord::Base
   has_many :posts, :conditions => {:published => true}
@@ -13,15 +19,4 @@ class Post < ActiveRecord::Base
   belongs_to :user
 end
 class Alternate < ActiveRecord::Base; end
-class Fuzzle < ActiveRecord::Base; end
-
-class Test::Unit::TestCase
-  def teardown
-    Fuzzle.delete_all
-    Alternate.delete_all
-    Post.delete_all
-    User.delete_all
-  end
-end
-
-require File.dirname(__FILE__) + '/functional/controller_helper'
+class Fuzzle < ActiveRecord::Base; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: thumblemonks-load_model
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Justin Knowlden
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-03 00:00:00 -08:00
+date: 2009-03-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 

data/rails/app/controllers/application.rb

@@ -1,2 +0,0 @@
-class ApplicationController < ActionController::Base
-end

data/rails/config/boot.rb

@@ -1,109 +0,0 @@
-# Don't change this file!
-# Configure your app in config/environment.rb and config/environments/*.rb
-
-RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
-
-module Rails
-  class << self
-    def boot!
-      unless booted?
-        preinitialize
-        pick_boot.run
-      end
-    end
-
-    def booted?
-      defined? Rails::Initializer
-    end
-
-    def pick_boot
-      (vendor_rails? ? VendorBoot : GemBoot).new
-    end
-
-    def vendor_rails?
-      File.exist?("#{RAILS_ROOT}/vendor/rails")
-    end
-
-    def preinitialize
-      load(preinitializer_path) if File.exist?(preinitializer_path)
-    end
-
-    def preinitializer_path
-      "#{RAILS_ROOT}/config/preinitializer.rb"
-    end
-  end
-
-  class Boot
-    def run
-      load_initializer
-      Rails::Initializer.run(:set_load_path)
-    end
-  end
-
-  class VendorBoot < Boot
-    def load_initializer
-      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
-      Rails::Initializer.run(:install_gem_spec_stubs)
-    end
-  end
-
-  class GemBoot < Boot
-    def load_initializer
-      self.class.load_rubygems
-      load_rails_gem
-      require 'initializer'
-    end
-
-    def load_rails_gem
-      if version = self.class.gem_version
-        gem 'rails', version
-      else
-        gem 'rails'
-      end
-    rescue Gem::LoadError => load_error
-      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
-      exit 1
-    end
-
-    class << self
-      def rubygems_version
-        Gem::RubyGemsVersion if defined? Gem::RubyGemsVersion
-      end
-
-      def gem_version
-        if defined? RAILS_GEM_VERSION
-          RAILS_GEM_VERSION
-        elsif ENV.include?('RAILS_GEM_VERSION')
-          ENV['RAILS_GEM_VERSION']
-        else
-          parse_gem_version(read_environment_rb)
-        end
-      end
-
-      def load_rubygems
-        require 'rubygems'
-        min_version = '1.1.1'
-        unless rubygems_version >= min_version
-          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
-          exit 1
-        end
-
-      rescue LoadError
-        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
-        exit 1
-      end
-
-      def parse_gem_version(text)
-        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
-      end
-
-      private
-        def read_environment_rb
-          File.read("#{RAILS_ROOT}/config/environment.rb")
-        end
-    end
-  end
-end
-
-# All that for this:
-Rails.boot!

data/rails/config/database.yml

@@ -1,3 +0,0 @@
-test:
-  :adapter: sqlite3
-  :dbfile: db/test.db

data/rails/config/environment.rb

@@ -1,71 +0,0 @@
-# Be sure to restart your server when you modify this file
-
-# Uncomment below to force Rails into production mode when
-# you don't control web/app server and can't set it the proper way
-# ENV['RAILS_ENV'] ||= 'production'
-
-# Specifies gem version of Rails to use when vendor/rails is not present
-RAILS_GEM_VERSION = '2.2.2' unless defined? RAILS_GEM_VERSION
-
-# Bootstrap the Rails environment, frameworks, and default configuration
-require File.join(File.dirname(__FILE__), 'boot')
-
-Rails::Initializer.run do |config|
-  # Settings in config/environments/* take precedence over those specified here.
-  # Application configuration should go into files in config/initializers
-  # -- all .rb files in that directory are automatically loaded.
-  # See Rails::Configuration for more options.
-
-  # Skip frameworks you're not going to use. To use Rails without a database
-  # you must remove the Active Record framework.
-  # config.frameworks -= [ :active_record, :active_resource, :action_mailer ]
-
-  # Specify gems that this application depends on. 
-  # They can then be installed with "rake gems:install" on new installations.
-  # config.gem "bj"
-  # config.gem "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
-  # config.gem "aws-s3", :lib => "aws/s3"
-  config.gem 'thoughtbot-shoulda', :lib => 'shoulda/rails',
-    :source => 'http://gems.github.com'
-
-  # Only load the plugins named here, in the order given. By default, all plugins 
-  # in vendor/plugins are loaded in alphabetical order.
-  # :all can be used as a placeholder for all plugins not explicitly named
-  # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
-
-  # Add additional load paths for your own custom dirs
-  # config.load_paths += %W( #{RAILS_ROOT}/extras )
-
-  # Force all environments to use the same logger level
-  # (by default production uses :info, the others :debug)
-  # config.log_level = :debug
-
-  # Make Time.zone default to the specified zone, and make Active Record store time values
-  # in the database in UTC, and return them converted to the specified local zone.
-  # Run "rake -D time" for a list of tasks for finding time zone names. Comment line to use default local time.
-  # config.time_zone = ENV['TZ'] = 'UTC'
-
-  # Your secret key for verifying cookie session data integrity.
-  # If you change this key, all old sessions will become invalid!
-  # Make sure the secret is at least 30 characters and all random, 
-  # no regular words or you'll be exposed to dictionary attacks.
-  # config.action_controller.session = {
-  #   :session_key => '_load_model_session',
-  #   :secret      => '731d6426b38a848657211af3650ea99dc064a830ec15fd20565d71ba62498382132872b2d9b549eeb5a016025c119eb821d8e66794cd380888120aa0b857386d'
-  # }
-
-  # Use the database for sessions instead of the cookie-based default,
-  # which shouldn't be used to store highly confidential information
-  # (create the session table with "rake db:sessions:create")
-  # config.action_controller.session_store = :active_record_store
-
-  # Use SQL instead of Active Record's schema dumper when creating the test database.
-  # This is necessary if your schema can't be completely dumped by the schema dumper,
-  # like if you have constraints or database-specific column types
-  # config.active_record.schema_format = :sql
-
-  # Activate observers that should always be running
-  # config.active_record.observers = :cacher, :garbage_collector
-end
-
-require 'ruby-debug'

data/rails/config/environments/test.rb

@@ -1,19 +0,0 @@
-# Settings specified here will take precedence over those in config/environment.rb
-
-# The test environment is used exclusively to run your application's
-# test suite.  You never need to work with it otherwise.  Remember that
-# your test database is "scratch space" for the test suite and is wiped
-# and recreated between test runs.  Don't rely on the data there!
-config.cache_classes = true
-
-# Log error messages when you accidentally call methods on nil.
-config.whiny_nils = true
-
-# Show full error reports and disable caching
-config.action_controller.consider_all_requests_local = true
-config.action_controller.perform_caching             = false
-
-# Tell ActionMailer not to deliver emails to the real world.
-# The :test delivery method accumulates sent emails in the
-# ActionMailer::Base.deliveries array.
-config.action_mailer.delivery_method = :test

data/rails/config/routes.rb

@@ -1,5 +0,0 @@
-ActionController::Routing::Routes.draw do |map|
-  map.connect ':controller/service.wsdl', :action => 'wsdl'
-  map.connect ':controller/:action/:id.:format'
-  map.connect ':controller/:action/:id'
-end

data/rails/db/schema.rb

@@ -1,21 +0,0 @@
-ActiveRecord::Schema.define(:version => 1) do
-  create_table 'users', :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table 'posts', :force => true do |t|
-    t.column :user_id, :integer
-    t.column :published, :boolean, :default => true
-    t.column :name, :string
-  end
-  
-  create_table 'alternates', :force => true do |t|
-    t.column :alternate_id, :integer
-    t.column :name, :string
-  end
-
-  create_table 'fuzzles', :force => true do |t|
-    t.column :fuzzle_id, :integer
-    t.column :name, :string
-  end
-end

data/test/functional/controller_helper.rb

@@ -1,82 +0,0 @@
-class BasicController < ActionController::Base
-  load_model :user
-  load_model :alternate, :parameter_key => :alternate_id,
-    :foreign_key => :alternate_id
-  load_model :chameleon, :class => :user
-  load_model :flamingo, :class => User
-  load_model :tucan, :class => :alternate, :parameter_key => :alternate_id,
-    :foreign_key => :alternate_id
-
-  def index; render :text => 'hello'; end
-end
-class BasicController; def rescue_action(e) raise e end; end
-
-# Has strings for values
-
-class StringKeyController < ActionController::Base
-  load_model 'user'
-  load_model 'alternate', :parameter_key => 'alternate_id',
-    :foreign_key => 'alternate_id'
-  load_model 'chameleon', :class => 'user'
-
-  def index; render :text => 'goodbye'; end
-end
-class StringKeyController; def rescue_action(e) raise e end; end
-
-# Requires values
-
-class RequireModelController < ActionController::Base
-  load_model :stuser, :class => :alternate, :parameter_key => :alternate_id,
-    :foreign_key => :alternate_id, :require => nil # never required
-  load_model :fuzzle, :parameter_key => :fuzzle_id, :foreign_key => :fuzzle_id,
-    :require => [:newer] # required for newer action
-  load_model :user, :require => true # required for all actions
-
-  def index; render :text => 'whatever'; end
-  def new; render :text => 'whatever 2'; end
-  def newer; render :text => 'whatever 3'; end
-end
-class RequireModelController; def rescue_action(e) raise e end; end
-
-# Restriction options
-
-class RestrictOptionsController < ActionController::Base
-  load_model :user, :only => [:index]
-  load_model :alternate, :except => [:index], :parameter_key => :alternate_id,
-    :foreign_key => :alternate_id
-
-  def index; render :text => 'ran index'; end
-  def show; render :text => 'ran show'; end
-end
-class RequireModelController; def rescue_action(e) raise e end; end
-
-class KeysController < ActionController::Base
-  # Expects to use fuzzle_id as parameter key against User class with FK of :id
-  load_model :user, :parameter_key => :fuzzle_id
-
-  # Expects to use :fuzzle_id as FK and parameter key against Fuzzle class 
-  # (normal operation)
-  load_model :fuzzler, :parameter_key => :fuzzle_id, :foreign_key => :fuzzle_id,
-    :class => :fuzzle
-
-  def index; render :text => 'hello'; end
-end
-class KeysController; def rescue_action(e) raise e end; end
-
-# Load model through existing model
-class ThroughController < ActionController::Base
-  load_model :user, :parameter_key => :user_id
-  load_model :post, :through => :user, :except => [:show]
-  # proving that except and only work
-  load_model :post, :through => :user, :parameter_key => 'weird_id',
-    :require => true, :only => [:show]
-
-  load_model :post, :through => :user, :association => :unpublished_posts,
-    :require => true, :only => [:show_unpublished]
-      
-  def index; render :text => 'index'; end
-  def show; render :text => 'show'; end
-  def show_unpublished; render :text => 'unpublished'; end
-  
-end
-class ThroughController; def rescue_action(e) raise e end; end

data/test/functional/load_model_test.rb

@@ -1,85 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class LoadModelTest < Test::Unit::TestCase
-
-  def setup
-    super
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = BasicController.new
-    @foo = User.create!(:name => 'Foo')
-  end
-
-  def teardown
-    Alternate.delete_all
-    User.delete_all
-  end
-
-  context "when parameter" do
-    context "is provided" do
-      setup { get :index, :id => @foo.id }
-      should("find record") { assert_equal @foo.id, assigns(:user).id }
-    end # is provided
-
-    context "is not provided" do
-      setup { get :index }
-      should("not assign any record") { assert_nil assigns(:user) }
-    end # is not provided
-
-    context "does not match existing record" do
-      setup { get :index, :id => (@foo.id + 1) }
-      should("not assign any record") { assert_nil assigns(:user) }
-    end # does not match existing record
-  end # when parameter
-
-  def test_should_find_record_with_alternate_id_as_expected_param_key
-    alt = Alternate.create!(:name => 'Alternate', :alternate_id => 100)
-    get :index, :alternate_id => alt.alternate_id
-    assert_equal alt.id, assigns(:alternate).id
-    assert_equal alt.alternate_id, assigns(:alternate).alternate_id
-  end
-
-  def test_should_find_nothing_when_alternate_id_does_not_match_record
-    alt = Alternate.create!(:name => 'Alternate', :alternate_id => 99)
-    get :index, :alternate_id => 100
-    assert_nil assigns(:alternate)
-  end
-
-  def test_should_find_chameleon_in_user_table
-    get :index, :id => @foo.id
-    assert_equal @foo.id, assigns(:chameleon).id
-  end
-
-  def test_should_not_find_chameleon_in_user_table_with_nonexistent_id
-    get :index, :id => (@foo.id + 1)
-    assert_nil assigns(:chameleon)
-  end
-
-  def test_should_find_flamingo_in_user_table_even_when_class_name_is_constant
-    get :index, :id => @foo.id
-    assert_equal @foo.id, assigns(:flamingo).id
-  end
-
-  def test_should_not_find_flamingo_in_user_table_when_class_name_is_constant
-    get :index, :id => (@foo.id + 1)
-    assert_nil assigns(:flamingo)
-  end
-
-  def test_should_find_tucan_in_users_with_alternate_class_and_key
-    alt = Alternate.create!(:name => 'Alternate', :alternate_id => 100)
-    get :index, :alternate_id => alt.alternate_id
-    assert_equal alt.id, assigns(:tucan).id
-  end
-
-  def test_should_not_find_tucan_in_users_with_alternate_class_and_key
-    alt = Alternate.create!(:name => 'Alternate', :alternate_id => 100)
-    get :index, :alternate_id => (alt.alternate_id + 1)
-    assert_nil assigns(:tucan)
-  end
-
-  def test_should_not_find_record_if_key_value_is_not_an_integer
-    get :index, :id => 'abc'
-    assert_nil assigns(:user)
-  end
-
-end

data/test/functional/string_key_load_model_test.rb

@@ -1,52 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/controller_helper'
-
-class StringKeyLoadModelTest < Test::Unit::TestCase
-
-  def setup
-    super
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = StringKeyController.new
-    @foo = User.create!(:name => 'Foo')
-  end
-
-  def test_should_find_record_and_assign_to_instance_variable_if_param_provided
-    get :index, :id => @foo.id
-    assert_equal @foo.id, assigns(:user).id
-  end
-
-  def test_should_return_nil_if_expected_param_not_provided
-    get :index
-    assert_nil assigns(:user)
-  end
-
-  def test_should_return_nil_if_expected_param_does_not_match_record
-    get :index, :id => (@foo.id + 1) # Should not belong to an existing user
-    assert_nil assigns(:user)
-  end
-
-  def test_should_find_record_with_alternate_id_as_expected_param_key
-    alt = Alternate.create!(:name => 'Alternate', :alternate_id => 100)
-    get :index, :alternate_id => alt.alternate_id
-    assert_equal alt.id, assigns(:alternate).id
-    assert_equal alt.alternate_id, assigns(:alternate).alternate_id
-  end
-
-  def test_should_find_nothing_when_alternate_id_does_not_match_record
-    alt = Alternate.create!(:name => 'Alternate', :alternate_id => 99)
-    get :index, :alternate_id => 100
-    assert_nil assigns(:alternate)
-  end
-
-  def test_should_find_chameleon_in_user_table
-    get :index, :id => @foo.id
-    assert_equal @foo.id, assigns(:chameleon).id
-  end
-
-  def test_should_not_find_chameleon_in_user_table_with_nonexistent_id
-    get :index, :id => (@foo.id + 1)
-    assert_nil assigns(:chameleon)
-  end
-
-end