load_model 0.2.2

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,114 @@
+# 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.
+
+    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:
+
+    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.
+
+    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:
+
+    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:
+
+    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)
+
+    load_model :foo, :only => [:show]
+    load_model :bar, :except => [:create]
+
+### 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.
+
+    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!
+
+    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.
+
+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
+
+    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,176 @@
+require 'thumblemonks/model_loader'
+
+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]
+      #
+      # == 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.
+      #
+      # 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.
+      #
+      # 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
+      #
+      # 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 << loader_class(opts).new(name, opts)
+      end
+
+      def loaders; self.read_inheritable_attribute(:loaders); end
+    private
+      def loader_class(opts)
+        return ThumbleMonks::ThroughModelLoader if opts[:through]
+        return ThumbleMonks::FromModelLoader if opts[:from]
+        ThumbleMonks::AssociativeModelLoader
+      end
+    end # ClassMethods
+  private
+    def load_specified_models
+      self.class.loaders.each do |loader|
+        if loader.action_allowed?(action_name)
+          obj = loader.load_model(self)
+          raise RequiredRecordNotFound if obj.nil? && loader.action_required?(action_name)
+          instance_variable_set(loader.assigns_to, obj)
+        end
+      end
+    end # load_specified_models
+  end # LoadModel
+end # ThumbleMonks
+
+ActionController::Base.send(:include, ThumbleMonks::LoadModel)

data/lib/thumblemonks/model_loader.rb

@@ -0,0 +1,90 @@
+module ThumbleMonks #:nodoc:
+  class NoModelLoaderFound < Exception; end
+
+  class ModelLoader #:nodoc
+    attr_reader :assigns_to, :except, :only, :requires
+
+    def initialize(name, opts={})
+      config = {:require => false}.merge(opts)
+      @assigns_to = "@#{name}".to_sym
+      @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)
+      raise NoModelLoaderFound
+    end
+  private
+    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
+    
+    def retrieve_association_through(controller, instance_variable_name)
+      controller.instance_variable_get(instance_variable_name).send(@association)
+    end
+  end # ModelLoader
+
+  class AssociativeModelLoader < ModelLoader #:nodoc
+    attr_reader :load_through, :parameter_key, :foreign_key
+
+    def initialize(name, opts={})
+      super
+      config = {:parameter_key => :id, :foreign_key => :id, :class => name}.merge(opts)
+      @load_through = config[:class].to_s.classify.constantize
+      @parameter_key = config[:parameter_key].to_s
+      @foreign_key = config[:foreign_key].to_s
+    end
+
+    def load_model(controller)
+      begin
+        lookup = parameter_value(controller)
+        source(controller).send("find_by_#{foreign_key}", lookup) unless lookup.blank?
+      rescue ActiveRecord::StatementInvalid
+        nil
+      end
+    end
+  private
+    def source(controller)
+      load_through
+    end
+  end # AssociativeModelLoader
+
+  class ThroughModelLoader < AssociativeModelLoader #:nodoc
+    def initialize(name, opts={})
+      super
+      @load_through = "@#{opts[:through]}".to_sym
+      @association = opts[:association] || name.to_s.pluralize
+    end
+  private
+    def source(controller)
+      retrieve_association_through(controller, load_through)
+    end
+  end # ThroughModelLoader
+
+  class FromModelLoader < ModelLoader #:nodoc
+    def initialize(name, opts={})
+      super
+      @load_from = "@#{opts[:from]}".to_sym
+      @association = name.to_s
+    end
+
+    def load_model(controller)
+      retrieve_association_through(controller, @load_from)
+    end
+  end # FromModelLoader
+
+end # ThumbleMonks

data/load_model.gemspec

@@ -0,0 +1,51 @@
+Gem::Specification.new do |s|
+  s.name     = "load_model"
+  s.version  = "0.2.2"
+  s.date     = "2009-06-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 Dan\ Hodos]
+
+  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
+    lib/thumblemonks/model_loader.rb
+    load_model.gemspec
+  ]
+  
+  s.test_files = %w[
+    test/functional/basic_controller_test.rb
+    test/functional/from_controller_test.rb
+    test/functional/keys_controller_test.rb
+    test/functional/require_model_controller_test.rb
+    test/functional/restrict_options_controller_test.rb
+    test/functional/string_key_controller_test.rb
+    test/functional/through_controller_test.rb
+    test/rails/app/controllers/application.rb
+    test/rails/config/boot.rb
+    test/rails/config/database.yml
+    test/rails/config/environment.rb
+    test/rails/config/environments/test.rb
+    test/rails/config/routes.rb
+    test/rails/db/schema.rb
+    test/test_helper.rb
+  ]
+
+  s.post_install_message = %q{Choosy prima donnas choose Thumble Monks}
+end

data/test/functional/basic_controller_test.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+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 BasicControllerTest < ActionController::TestCase
+  def setup
+    @foo = User.create!(:name => 'Foo')
+  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
+
+  should "find chameleon in users" do
+    get :index, :id => @foo.id
+    assert_equal @foo.id, assigns(:chameleon).id
+  end
+
+  should "not find chameleon in users with nonexistent id" do
+    get :index, :id => (@foo.id + 1)
+    assert_nil assigns(:chameleon)
+  end
+
+  should "not find record if key value is not an integer" do
+    get :index, :id => 'abc'
+    assert_nil assigns(:user)
+  end
+
+  context "when class name is constant" do
+    should "find flamingo in user table" do
+      get :index, :id => @foo.id
+      assert_equal @foo.id, assigns(:flamingo).id
+    end
+
+    should "not find flamingo in user table" do
+      get :index, :id => (@foo.id + 1)
+      assert_nil assigns(:flamingo)
+    end
+  end # when class name is constant
+
+  context "for alternate" do
+    context "with existing id" do
+      setup do
+        @alt = Alternate.create!(:name => 'Alternate', :alternate_id => 100)
+        get :index, :alternate_id => @alt.alternate_id
+      end
+
+      should_assign_to(:alternate) { @alt }
+      should_assign_to(:tucan) { @alt }
+    end
+
+    context "with non-existant id" do
+      setup { get :index, :alternate_id => 99 }
+      should_not_assign_to(:alternate)
+      should_not_assign_to(:tucan)
+    end
+  end # with alternate class and key
+
+  context "when id is nil for users" do
+    setup do
+      User.expects(:find_by_id).never
+      get :index, :id => ''
+    end
+  
+    should_not_assign_to(:user)
+  end # when parameter value is nil
+end

data/test/functional/from_controller_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class FromController < ActionController::Base
+  load_model :post
+  load_model :user, :from => :post
+  load_model :foo, :from => :post
+
+  def index; render :text => 'index'; end
+end
+
+class FromControllerTest < ActionController::TestCase
+  def setup
+    @user = User.create!(:name => 'Foo')
+    @post = @user.posts.create!(:name => 'Foo post')
+  end
+
+  context "loading from post model" do
+    setup do
+      get :index, :id => @post.id
+    end
+
+    should_assign_to(:post) { @post }
+    should_assign_to(:user) { @user }
+    should_assign_to(:foo) { "bar" }
+  end
+end

data/test/functional/keys_controller_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+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
+    @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/require_model_controller_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+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
+    @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,37 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+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
+    @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_controller_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+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 StringKeyControllerTest < ActionController::TestCase
+  def setup
+    @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,80 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+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
+    @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) { @user }
+    should_assign_to(:post) { @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) { @user }
+    should_assign_to(:post) { @unpublished_post }
+  end
+  
+  context "index with invalid post id" do
+    setup do
+      get :index, :user_id => @user.id, :id => -1
+    end
+    
+    should_assign_to(:user) { @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) { @user }
+      should_assign_to(:post) { @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
+
+  context "when parameter value is nil" do
+    setup do
+      Post.expects(:find_by_id).never
+      get :index, :user_id => @user.id, :id => ''
+    end
+
+    should_assign_to(:user) { @user }
+    should_not_assign_to(:post)
+  end # when parameter value is nil
+end

data/test/rails/app/controllers/application.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  # We don't put any other controllers in this directory because load_model loads too late
+end

data/test/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 rescue nil
+      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.3.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/test/rails/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"

data/test/rails/config/environment.rb

@@ -0,0 +1,15 @@
+# Specifies gem version of Rails to use when vendor/rails is not present
+RAILS_GEM_VERSION = '2.3.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|
+  config.gem 'thoughtbot-shoulda', :lib => 'shoulda/rails', :source => 'http://gems.github.com'
+  config.gem 'mocha'
+
+  config.action_controller.session = {
+    :session_key => '_load_model_session',
+    :secret      => '9908cd9908cd9908cd9908cd9908cd9908cd9908cd9908cd9908cd9908cd9908cd9908cd9908cd'
+  }
+end

data/test/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/test/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/test/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/test_helper.rb

@@ -0,0 +1,26 @@
+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__), '..', '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.join(ENV["RAILS_ROOT"], "db", "schema.rb"))
+
+# Models
+
+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
+  
+  def foo; "bar"; end
+end
+class Alternate < ActiveRecord::Base; end
+class Fuzzle < ActiveRecord::Base; end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: load_model
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: ruby
+authors: 
+- Justin Knowlden
+- Gabriel Gironda
+- Dan Hodos
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-03 00:00:00 -05: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
+- lib/thumblemonks/model_loader.rb
+- load_model.gemspec
+has_rdoc: true
+homepage: http://github.com/thumblemonks/load_model
+licenses: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Rails Controller plugin that provides easy and useful macros for tying models and requests together
+test_files: 
+- test/functional/basic_controller_test.rb
+- test/functional/from_controller_test.rb
+- test/functional/keys_controller_test.rb
+- test/functional/require_model_controller_test.rb
+- test/functional/restrict_options_controller_test.rb
+- test/functional/string_key_controller_test.rb
+- test/functional/through_controller_test.rb
+- test/rails/app/controllers/application.rb
+- test/rails/config/boot.rb
+- test/rails/config/database.yml
+- test/rails/config/environment.rb
+- test/rails/config/environments/test.rb
+- test/rails/config/routes.rb
+- test/rails/db/schema.rb
+- test/test_helper.rb