thumblemonks-load_model 0.2.0 → 0.2.2

data/lib/load_model.rb

@@ -1,3 +1,5 @@
+require 'thumblemonks/model_loader'
+
 module ThumbleMonks #:nodoc:
   module LoadModel
 
@@ -151,93 +153,19 @@ module ThumbleMonks #:nodoc:
       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
-
-      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
+        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)
-          if obj.nil? && loader.action_required?(action_name)
-            raise RequiredRecordNotFound
-          end
+          raise RequiredRecordNotFound if obj.nil? && loader.action_required?(action_name)
           instance_variable_set(loader.assigns_to, obj)
         end
       end

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

@@ -1,12 +1,12 @@
 Gem::Specification.new do |s|
   s.name     = "load_model"
-  s.version  = "0.2.0"
-  s.date     = "2009-03-24"
+  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]
+  s.authors  = %w[Justin\ Knowlden Gabriel\ Gironda Dan\ Hodos]
 
   s.rubyforge_project = %q{load_model}
 
@@ -25,26 +25,25 @@ Gem::Specification.new do |s|
     README.markdown
     Rakefile
     lib/load_model.rb
+    lib/thumblemonks/model_loader.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/basic_controller_test.rb
+    test/functional/from_controller_test.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/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
   ]
 

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/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

@@ -67,4 +67,14 @@ class ThroughControllerTest < ActionController::TestCase
       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

@@ -4,9 +4,11 @@ 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
@@ -17,6 +19,8 @@ class User < ActiveRecord::Base
 end
 class Post < ActiveRecord::Base
   belongs_to :user
+  
+  def foo; "bar"; end
 end
 class Alternate < ActiveRecord::Base; end
 class Fuzzle < ActiveRecord::Base; end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification 
 name: thumblemonks-load_model
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors: 
 - Justin Knowlden
 - Gabriel Gironda
+- Dan Hodos
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-03-24 00:00:00 -07:00
+date: 2009-06-03 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +32,7 @@ files:
 - 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
@@ -64,20 +66,18 @@ 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/basic_controller_test.rb
+- test/functional/from_controller_test.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/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