model_loader 0.0.1 → 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Adam Vaughan
+
+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.rdoc

@@ -0,0 +1,29 @@
+== Model Loader
+
+ModelLoader abstracts a common (at least for me) pattern in Rails applications.
+When creating controllers that interact with models it is common to have
+methods called <tt>find_<model_name></tt> for your models. This module defines those
+<tt>find_*</tt> methods for you.
+
+When executing the <tt>find_*</tt> methods, if a matching record can not be found, the
+user is redirected to the 404 page.
+
+== Installation
+
+Include the gem using bundler in your Gemfile:
+
+  gem "model_loader"
+
+== Usage
+
+The module is activated by calling the <tt>can_find_models</tt> method:
+
+  class ApplicationController < ActionController::Base
+    can_find_models
+  end
+
+Valid options are <tt>:only</tt> and <tt>:except</tt>:
+
+  class ApplicationController < ActionController
+    can_find_models :only => 'Person'
+  end

data/init.rb

@@ -0,0 +1,3 @@
+require 'model_loader'
+
+ModelLoader::Railtie.insert

data/lib/model_loader/railtie.rb

@@ -0,0 +1,19 @@
+module ModelLoader
+  if defined?(Rails::Railtie)
+    require 'rails'
+
+    class Railtie < Rails::Railtie
+      initializer 'model_loader.extend_action_controller' do
+        ActiveSupport.on_load(:action_controller) do
+          ModelLoader::Railtie.insert
+        end
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      ActionController::Base.send(:include, ModelLoader)
+    end
+  end
+end

data/lib/model_loader/version.rb

@@ -1,3 +1,3 @@
 module ModelLoader
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/model_loader.rb

@@ -1,10 +1,17 @@
 # Abstracts a common (at least for me) pattern in Rails applications. When
 # creating controllers that interact with models it is common to have methods
-# called find_<model_name> for your models. This module defines those find_*
-# methods for you.
+# called <tt>find_<model_name></tt> for your models. This module defines those
+# <tt>find_*</tt> methods for you.
 #
-# When executing the find_* methods, if a matching record can not be found, the
-# user is redirected to the 404 page.
+# When executing the <tt>find_*</tt> methods, if a matching record can not be
+# found, the user is redirected to the 404 page. The find method first tries to
+# find the object using the <tt><model_name>_id</tt> parameter if it exists. If
+# not, it tries to find the object using the <tt>id</tt> parameter.
+#
+# For example, given a model named Post, <tt>find_post</tt> will first check to
+# see if <tt>params[:post_id]</tt> exists. If it does, it will look up the
+# model with the value of that parameter. If it doesn't exist,
+# <tt>params[:id]</tt> will be used insted.
 #
 # The module is activated by calling the +can_find_models+ method:
 #
@@ -26,21 +33,23 @@ module ModelLoader
     def can_find_models(options = {})
       options.symbolize_keys!
 
-      raise ArgumentError, "The :only option to can_find_models must be an array." if options[:only] && !options[:only].is_a?(Array)
-      raise ArgumentError, "The :except option to can_find_models must be an array." if options[:except] && !options[:except].is_a?(Array)
-
       if options[:only]
+        options[:only] = [options[:only]].flatten.compact
         models = options[:only].map &:to_s
       else
         models = Dir["#{::Rails.root.to_s}/app/models/*"].map do |file|
           File.basename(file, ".*").classify 
         end
 
-        models -= options[:except].map &:to_s if options[:except]
+        if options[:except]
+          options[:except] = [options[:except]].flatten.compact
+          models -= options[:except].map &:to_s
+        end
       end
 
       models.each do |model|
         name = model.underscore
+        next if self.respond_to? "find_#{name}"
         self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
           def find_#{name}
             if params[:#{name}_id]
@@ -49,15 +58,12 @@ module ModelLoader
               @#{name} = #{name.capitalize}.find(params[:id])
             end
           rescue
-            resource_not_found
+            render :file => "#{::Rails.root.to_s}/public/404.html", :layout => false, :status => 404
           end
         METHOD
       end
     end
-
-    # Renders the application's 404 page.
-    def resource_not_found
-      render :file => "#{::Rails.root.to_s}/public/404.html", :layout => false, :status => 404
-    end
   end
 end
+
+require 'model_loader/railtie'

data/test/app/models/post.rb

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

data/test/app/models/user.rb

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

data/test/db/database.yml

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

data/test/model_loader_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+require 'app/models/post'
+
+class TestController < ApplicationController
+  can_find_models
+end
+
+class TestOnlyController < ApplicationController
+  can_find_models :only => 'Post'
+end
+
+class TestExceptController < ApplicationController
+  can_find_models :except => 'Post'
+end
+
+class TestExistingMethodController < ApplicationController
+  can_find_models
+
+  def find_post
+    "Test passed"
+  end
+end
+
+class ModelLoaderTest < Test::Unit::TestCase
+  def setup
+    reset_database
+  end
+
+  def test_should_have_can_find_models_method
+    assert ApplicationController.respond_to?(:can_find_models)
+  end
+
+  def test_should_create_find_methods
+    assert TestController.new.respond_to?(:find_post)
+    assert TestController.new.respond_to?(:find_user)
+  end
+
+  def test_should_create_find_methods_with_only
+    assert TestOnlyController.new.respond_to?(:find_post)
+    assert !TestOnlyController.new.respond_to?(:find_user)
+  end
+
+  def test_should_create_find_methods_with_except
+    assert !TestExceptController.new.respond_to?(:find_post)
+    assert TestExceptController.new.respond_to?(:find_user)
+  end
+
+  def test_should_find_model
+    post = Post.create(:title => 'Test')
+    controller = TestController.new
+    controller.params = { :id => post.id }
+    assert_equal post, controller.find_post
+  end
+
+  def test_should_not_find_model
+    controller = TestController.new
+    controller.response = ActionController::TestResponse.new
+    controller.params = { :id => 1 }
+    controller.find_post
+    assert_equal 404, controller.response.status
+  end
+
+  def test_should_find_associated_model
+    post = Post.create(:title => 'Test')
+    controller = TestController.new
+    controller.params = { :post_id => post.id }
+    assert_equal post, controller.find_post
+  end
+
+  def test_should_not_find_associated_model
+    controller = TestController.new
+    controller.response = ActionController::TestResponse.new
+    controller.params = { :post_id => 1 }
+    controller.find_post
+    assert_equal 404, controller.response.status
+  end
+
+  def test_should_not_overwrite_existing_method
+    controller = TestExistingMethodController.new
+    assert_equal "Test passed", controller.find_post
+  end
+end

data/test/public/404.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The page you were looking for doesn't exist (404)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/404.html -->
+  <div class="dialog">
+    <h1>The page you were looking for doesn't exist.</h1>
+    <p>You may have mistyped the address or the page may have moved.</p>
+  </div>
+</body>
+</html>

data/test/test_helper.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'rubygems'
+require 'active_support'
+require 'active_support/deprecation'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'active_record'
+require 'rails'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require File.join(File.dirname(__FILE__), '..', 'init')
+
+config = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'db', 'database.yml')))
+ActiveRecord::Base.configurations = { 'test' => config['sqlite3'] }
+ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+
+class MockApplication
+  def config
+    MockConfig.new
+  end
+end
+
+class MockConfig
+  def root
+    File.dirname(__FILE__)
+  end
+
+  def cache_classes
+    false
+  end
+end
+
+Rails.application = MockApplication.new
+
+class ApplicationController < ActionController::Base
+end
+
+class Test::Unit::TestCase
+  def reset_database
+    silence_stream(STDOUT) do
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :posts, :force => true do |t|
+          t.string :title
+        end
+
+        create_table :users, :force => true do |t|
+          t.string :name
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: model_loader
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Adam Vaughan
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-17 00:00:00 -07:00
+date: 2011-02-18 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,10 +31,22 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- MIT-LICENSE
+- README.rdoc
 - Rakefile
+- init.rb
 - lib/model_loader.rb
+- lib/model_loader/railtie.rb
 - lib/model_loader/version.rb
 - model_loader.gemspec
+- rails/init.rb
+- test/app/models/post.rb
+- test/app/models/user.rb
+- test/db/database.yml
+- test/db/test.sqlite3
+- test/model_loader_test.rb
+- test/public/404.html
+- test/test_helper.rb
 has_rdoc: true
 homepage: https://github.com/adamvaughan/model_loader
 licenses: []
@@ -69,5 +81,11 @@ rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: Automatically generate find method for models.
-test_files: []
-
+test_files: 
+- test/app/models/post.rb
+- test/app/models/user.rb
+- test/db/database.yml
+- test/db/test.sqlite3
+- test/model_loader_test.rb
+- test/public/404.html
+- test/test_helper.rb