thumblemonks-load_model 0.1.0

data/HISTORY.markdown

@@ -0,0 +1,4 @@
+## v0.1
+
+* Turned load_model from a plugin into a gem
+* Moved all rails test support code into a rails sub-dir

data/MIT-LICENSE

@@ -0,0 +1,24 @@
+MIT License
+--------------------------------------------------------------------------------
+Copyright (c) 2007 Thumble Monks, Justin Knowlden
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,102 @@
+# Load Model
+
+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
+        @silly_fellow.do_something
+      end
+    end
+
+You can require that a model instance be found for all actions or given actions. Default behavior is to not require that a model instance be found. When require is on and a record is not found, a `ThumbleMonks::RequiredRecordNotFound` Exception is thrown; which extends from ActiveRecord::RecordNotFound, for your convenience.
+
+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:
+
+    @foo = User.find_by_bar_id(params[:bar_id])
+
+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
+
+Which would result in a call similar to the following:
+
+    @foo = User.find_by_baz_id(params[:bar_id])
+
+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.
+
+Example
+
+    load_model :user, :require => true, :parameter_key => :user_id
+    load_model :post, :through => :user
+
+In this example, a @post record will be loaded through the @user record with essentially the following code:
+
+    @user.posts.find_by_id(params[:id])
+
+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
+
+Would result in a call similar to the following:
+
+    @person.posts.find_by_baz_id(params[:foo_id])
+
+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.
+
+## Installation
+
+    sudo gem install thumblemonks-load_model
+
+## Requirements
+
+1. Ruby 1.8.6 or higher
+2. Rails 2.x or higher
+
+## Acknowledgements
+
+Anyone who developed, discussed, or any other way participated in HTTP, REST, and Rails.
+
+## Contact
+
+Justin Knowlden <gus@gusg.us>
+
+## License
+
+See MIT-LICENSE

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the load_model plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the load_model plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'LoadModel'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/load_model.rb

@@ -0,0 +1,202 @@
+module ThumbleMonks #:nodoc:
+  module LoadModel
+
+    class RequiredRecordNotFound < ActiveRecord::RecordNotFound; end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    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 
+      # 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
+      #       @silly_fellow.do_something
+      #     end
+      #   ens
+      # 
+      # You can require that a model instance be found for all actions or given 
+      # actions. Default behavior is to not require that a model instance be 
+      # found. When require is on and a record is not found, a 
+      # ThumbleMonks::RequiredRecordNotFound Exception is thrown; which does
+      # conveniently extend ActiveRecord::RecordNotFound.
+      # 
+      # To turn require on for all actions, simply pass _true_ to a provided
+      # <em>:require</em> attribute, like so:
+      # 
+      # Example
+      #   load_model :silly_fellow, :require => true
+      # 
+      # To turn require on for specific actions, pass an array of action names 
+      # to <em>:require</em>. 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 is 
+      # :bar_id while assuming the model's primary/foreign is still :id. For 
+      # instance, the above example would result in a call like the following:
+      # 
+      #  @foo = User.find_by_id(params[:bar_id])
+      # 
+      # 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
+      # 
+      # Which would result in a call similar to the following:
+      # 
+      #   @foo = User.find_by_baz_id(params[:bar_id])
+      # 
+      # 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. :except will always win out over 
+      # :only in the event of a collision.
+      # 
+      # 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.
+      #
+      # Example
+      #   load_model :user, :require => true, :parameter_key => :user_id
+      #   load_model :post, :through => :user
+      #
+      # In this example, a @post record will be loaded through the @user record
+      # with essentially the following code:
+      #
+      #   @user.posts.find_by_id(params[:id])
+      #
+      # 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
+      #
+      # Would result in a call similar to the following:
+      #
+      #   @person.posts.find_by_baz_id(params[:foo_id])
+      #
+      # 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.
+      #
+      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)
+      end
+
+      def loaders; self.read_inheritable_attribute(:loaders); end
+
+      class ModelLoader #:nodoc
+        attr_reader :assigns_to, :load_through, :parameter_key, :foreign_key,
+          :except, :only, :requires
+
+        def initialize(name, opts={})
+          config = {:require => false, :parameter_key => :id,
+            :foreign_key => :id, :class => name}.merge(opts)
+          @assigns_to = "@#{name}".to_sym
+          @load_through = config[:class].to_s.classify.constantize
+          @parameter_key = config[:parameter_key].to_s
+          @foreign_key = config[:foreign_key].to_s
+          @requires = parse_required_actions(config[:require])
+          @except = stringify_array(config[:except])
+          @only = stringify_array(config[:only])
+        end
+
+        def action_allowed?(action)
+          return false if except.include?(action)
+          only.empty? ? true : only.include?(action)
+        end
+
+        def action_required?(action)
+          requires == true || requires.include?(action)
+        end
+        
+        def load_model(controller)
+          begin
+            lookup = parameter_value(controller)
+            source(controller).send("find_by_#{foreign_key}", lookup)
+          rescue ActiveRecord::StatementInvalid
+            nil
+          end
+        end
+      private
+        def source(controller) load_through; end
+
+        def parse_required_actions(actions)
+          actions == true ? true : stringify_array(actions)
+        end
+
+        def parameter_value(controller) controller.params[parameter_key]; end
+
+        def stringify_array(value) Array(value).map(&:to_s); end
+      end # ModelLoader
+
+      class ThroughModelLoader < ModelLoader #:nodoc
+        attr_reader :load_through, :association
+        def initialize(name, opts={})
+          super(name, opts)
+          @load_through = "@#{opts[:through]}".to_sym
+          @association = opts[:association] || name.to_s.pluralize
+        end
+      private
+        def source(controller)
+          controller.instance_variable_get(load_through).send(association)
+        end
+      end # ThroughModelLoader
+
+    end # ClassMethods
+
+  private
+
+    def load_specified_models
+      self.class.loaders.each do |loader|
+        if loader.action_allowed?(action_name)
+          obj = loader.load_model(self)
+          if obj.nil? && loader.action_required?(action_name)
+            raise RequiredRecordNotFound
+          end
+          instance_variable_set(loader.assigns_to, obj)
+        end
+      end
+    end
+
+  end # LoadModel
+end # ThumbleMonks
+
+ActionController::Base.send(:include, ThumbleMonks::LoadModel)

data/load_model.gemspec

@@ -0,0 +1,52 @@
+Gem::Specification.new do |s|
+  s.name     = "load_model"
+  s.version  = "0.1.0"
+  s.date     = "2009-01-03"
+  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"
+  s.description = "Rails Controller plugin that provides easy and useful macros for tying models and requests together"
+  s.authors  = %w[Justin\ Knowlden Gabriel\ Gironda]
+
+  s.rubyforge_project = %q{load_model}
+
+  s.has_rdoc = true
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Load Model", "--main", "README.markdown"]
+  s.extra_rdoc_files = ["HISTORY.markdown", "README.markdown"]
+  
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to?(:required_rubygems_version=)
+  s.rubygems_version = "1.3.1"
+  s.require_paths = ["lib"]
+
+  # run git ls-files to get an updated list
+  s.files = %w[
+    HISTORY.markdown
+    MIT-LICENSE
+    README.markdown
+    Rakefile
+    lib/load_model.rb
+    load_model.gemspec
+  ]
+  
+  s.test_files = %w[
+    rails/app/controllers/application.rb
+    rails/config/boot.rb
+    rails/config/database.yml
+    rails/config/environment.rb
+    rails/config/environments/test.rb
+    rails/config/routes.rb
+    rails/db/schema.rb
+    rails/db/test.db
+    rails/log/test.log
+    test/functional/controller_helper.rb
+    test/functional/keys_controller_test.rb
+    test/functional/load_model_test.rb
+    test/functional/require_model_controller_test.rb
+    test/functional/restrict_options_controller_test.rb
+    test/functional/string_key_load_model_test.rb
+    test/functional/through_controller_test.rb
+    test/test_helper.rb
+  ]
+
+  s.post_install_message = %q{Choosy prima donnas choose Thumble Monks}
+end

data/rails/app/controllers/application.rb

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

data/rails/config/boot.rb

@@ -0,0 +1,109 @@
+# 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

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

data/rails/config/environment.rb

@@ -0,0 +1,71 @@
+# 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

@@ -0,0 +1,19 @@
+# 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

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

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

@@ -0,0 +1,82 @@
+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/keys_controller_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class KeysControllerTest < Test::Unit::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
+
+  def test_should_find_user_using_fuzzle_id_as_param_key
+    get :index, :fuzzle_id => @user.id
+    assert_equal @user.id, assigns(:user).id
+    assert_nil assigns(:fuzzler)
+  end
+
+  def test_should_find_fuzzler_using_fuzzle_id_as_param_and_foreign_key
+    get :index, :fuzzle_id => @fuzzler.fuzzle_id
+    assert_equal @fuzzler.id, assigns(:fuzzler).id
+    assert_nil assigns(:user)
+  end
+
+end

data/test/functional/load_model_test.rb

@@ -0,0 +1,85 @@
+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/require_model_controller_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/controller_helper'
+
+class RequireModelControllerTest < Test::Unit::TestCase
+
+  def setup
+    super
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @controller = RequireModelController.new
+    @foo = User.create!(:name => 'Foo')
+  end
+
+  def test_should_find_record_if_required_to_find_record_and_record_is_found
+    get :index, :id => @foo.id
+    assert_equal @foo.id, assigns(:user).id
+  end
+
+  def test_should_not_require_value_if_required_is_nil
+    get :new, :id => @foo.id
+    assert_equal @foo.id, assigns(:user).id
+  end
+
+  def test_should_not_require_value_if_required_is_for_different_action
+    fuzz = Fuzzle.create!(:name => 'Fuzzy', :fuzzle_id => 200)
+    get :new, :id => @foo.id, :fuzzle_id => fuzz.id
+    assert_equal @foo.id, assigns(:user).id
+    assert_nil assigns(:stuser)
+    assert_nil assigns(:fuzzle)
+  end
+
+  def test_should_raise_error_if_required_is_scoped_and_record_not_found
+    fuzz = Fuzzle.create!(:name => 'Fuzzy', :fuzzle_id => 200)
+    assert_raise(ThumbleMonks::LoadModel::RequiredRecordNotFound) do
+      get :newer, :id => @foo.id, :fuzzle_id => (fuzz.id + 1)
+    end
+  end
+
+  def test_should_raise_error_if_required_is_true_and_record_not_found
+    assert_raise(ThumbleMonks::LoadModel::RequiredRecordNotFound) do
+      get :new, :id => (@foo.id + 1)
+    end
+  end
+
+end

data/test/functional/restrict_options_controller_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RestrictOptionsControllerTest < Test::Unit::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
+
+  def test_should_load_user_for_index
+    get :index, :id => @foo.id, :alternate_id => @alt.id
+    assert_equal @foo.id, assigns(:user).id
+  end
+
+  def test_should_not_load_alternate_for_index
+    get :index, :id => @foo.id, :alternate_id => @alt.alternate_id
+    assert_nil assigns(:alternate)
+  end
+
+  def test_should_load_alternate_for_show
+    get :show, :id => @foo.id, :alternate_id => @alt.alternate_id
+    assert_equal @alt, assigns(:alternate)
+  end
+
+  def test_should_not_load_user_for_show
+    get :show, :id => @foo.id, :alternate_id => @alt.alternate_id
+    assert_nil assigns(:user)
+  end
+
+end

data/test/functional/string_key_load_model_test.rb

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

data/test/functional/through_controller_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/controller_helper'
+
+class ThroughControllerTest < Test::Unit::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
+
+  context "index with valid ids" do
+    setup do
+      get :index, :user_id => @user.id, :id => @post.id
+    end
+    
+    should_assign_to :user, :equals => "@user"
+    should_assign_to :post, :equals => "@post"
+  end # with valid ids
+
+  context "show_unpublished with valid id" do
+    setup do
+      @unpublished_post = @user.posts.create!{ |p| p.published = false }
+      get :show_unpublished, :user_id => @user.id, :id => @unpublished_post.id
+    end
+    
+    should_assign_to :user, :equals => "@user"
+    should_assign_to :post, :equals => "@post"
+  end
+  
+  context "index with invalid post id" do
+    setup do
+      get :index, :user_id => @user.id, :id => -1
+    end
+    
+    should_assign_to :user, :equals => "@user"
+    should_not_assign_to :post
+  end # with invalid post id
+
+  context "show with alternative post via weird_id" do
+    context "has exisiting records" do
+      setup do
+        get :show, :user_id => @user.id, :weird_id => @post.id
+      end
+    
+      should_assign_to :user, :equals => "@user"
+      should_assign_to :post, :equals => "@post"
+    end # has existing records
+
+    context "has nonexistent records for required action" do
+      should "flail with exception" do
+        assert_raise(ThumbleMonks::LoadModel::RequiredRecordNotFound) do
+          get :show, :user_id => @user.id, :weird_id => -1
+        end
+      end
+    end # has nonexistant records for required action
+  end # show with alternative post via weird_id
+
+end

data/test/test_helper.rb

@@ -0,0 +1,27 @@
+ENV["RAILS_ENV"] = "test"
+ENV["RAILS_ROOT"] = File.expand_path(File.join(File.dirname(__FILE__), '..', '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")
+
+class User < ActiveRecord::Base
+  has_many :posts, :conditions => {:published => true}
+  has_many :unpublished_posts, :conditions => {:published => false}, :class_name => 'Post'
+end
+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'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: thumblemonks-load_model
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Justin Knowlden
+- Gabriel Gironda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-03 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Rails Controller plugin that provides easy and useful macros for tying models and requests together
+email: 
+- gus@gusg.us
+- gabriel.gironda@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- HISTORY.markdown
+- README.markdown
+files: 
+- HISTORY.markdown
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- lib/load_model.rb
+- load_model.gemspec
+has_rdoc: true
+homepage: http://github.com/thumblemonks/load_model
+post_install_message: Choosy prima donnas choose Thumble Monks
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Load Model
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: load_model
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Rails Controller plugin that provides easy and useful macros for tying models and requests together
+test_files: 
+- rails/app/controllers/application.rb
+- rails/config/boot.rb
+- rails/config/database.yml
+- rails/config/environment.rb
+- rails/config/environments/test.rb
+- rails/config/routes.rb
+- rails/db/schema.rb
+- rails/db/test.db
+- rails/log/test.log
+- test/functional/controller_helper.rb
+- test/functional/keys_controller_test.rb
+- test/functional/load_model_test.rb
+- test/functional/require_model_controller_test.rb
+- test/functional/restrict_options_controller_test.rb
+- test/functional/string_key_load_model_test.rb
+- test/functional/through_controller_test.rb
+- test/test_helper.rb