david-merb_resourceful 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 David Leal
+
+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.textile

@@ -0,0 +1,67 @@
+h1. merb_resourceful
+
+merb_resourceful is a plugin similar to resource_controller or make_resourceful for rails.
+
+h2. Usage
+
+Generate a new resource (this will change in the future)
+
+  merb-gen resource my_resource
+
+Edit app/controllers/my_resources.rb and leave the class declaration only
+
+  class MyResources < Merb::Controller
+    resourceful
+  end
+
+This gives you a basic controller with a few defaults (destroy isn't implemented yet).
+
+h3. Nested resources
+
+  class MyResources < Merb::Controller
+    resourceful :belongs_to => :my_parent
+    # The children will be accessed through parent.[children association]
+    # E.g. my_parent.my_resources
+    # this will be configurable in the future
+    def my_parent
+      @foo ||= session.user.parents.get(params[:foo_id])
+    end
+  end
+
+h3. Scoped resources
+
+  class MyResources < Merb::Controller
+    resourceful :scope => :scope_method 
+    # works just like :parent, but doesn't use @bar for routing
+    def scope_method
+      @bar ||= session.user.parents.get(params[:bar_id])
+    end
+  end
+
+h3. Per-action settings
+
+  class MyResources < Merb::Controller
+    resourceful do
+      index :layout => 'my_special_layout'
+      create :scope => :scope_for_create
+    end
+    def scope_for_create
+      @baz = get_me!
+    end
+  end
+
+h3. Param injection
+
+Merb already supports this with the defer_to method in the router, but I think this is way more explicit.
+
+  class MyResources < Merb::Controller
+    resourceful do
+      index :params => lambda {{ :creator => session.user }} # passes :creator as a param to MyResource.new
+      create :params => lambda {{ :creator => session.user }} # passes :creator as a param to the resource's update method
+    end
+  end
+
+h2. Lots more to come
+
+* More docs
+* Implement destroy

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+require 'merb-core'
+require 'merb-core/tasks/merb'
+
+GEM_NAME = "merb_resourceful"
+GEM_VERSION = "0.0.1"
+AUTHOR = "David Leal"
+EMAIL = "dgleal@gmail.com"
+HOMEPAGE = "http://github.com/david/merb_resourceful"
+SUMMARY = "merb_resourceful lends a little magic to common resource actions."
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = 'merb'
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.textile", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb', '>= 1.0')
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.textile Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+  
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the plugin as a gem"
+task :install do
+  Merb::RakeHelper.install(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Uninstall the gem"
+task :uninstall do
+  Merb::RakeHelper.uninstall(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/TODO

@@ -0,0 +1,7 @@
+TODO:
+* Rewrite the tests using a sample merb app.
+* Validate options
+* Cleanup internal methods, so they can be overriden by the user
+* Make sure all options make sense. 
+* Add passing a symbol to some options, besides lambdas, and that will call the corresponding method
+* Documentation.

data/lib/merb_resourceful/builder.rb

@@ -0,0 +1,280 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'controller'))
+
+
+module Merb
+  module Plugins
+    module Resourceful
+      class Builder
+        ALL_ACTIONS = %w(index show new create edit update destroy)
+        
+        def initialize(controller_class, options) 
+          @controller_class = controller_class
+          @options          = options
+          @resource_class   = @controller_class.name.demodulize.singularize
+          @resource_plural  = @controller_class.name.demodulize.underscore
+          @resource_name    = @resource_plural.singularize
+          
+        end
+        
+        def build(&block)
+          @controller_class.send :include, ::Merb::Plugins::Resourceful::Controller
+          @controller_class.const_set('RESOURCE_NAME', @resource_name)
+          @controller_class.const_set('RESOURCES_NAME', @resource_plural)
+          
+          def_source
+
+          ALL_ACTIONS.each { |action| send(action) }
+          
+          @controller_class.class_eval <<-EOF
+            def resources_set(r)
+              @#{@resource_plural} = r
+            end
+            
+            def resource_set(r)
+              @#{@resource_name} = r
+            end
+            
+            def resource_ivar
+              @#{@resource_name}
+            end
+          EOF
+            
+          if block_given? then instance_eval(&block) end
+        end
+          
+        def index(options = {})
+          def_source(options, :index)
+
+          filter = options[:filter] && ".#{options[:filter]}"
+          params = options[:params] && "(resource_params_for_index)"
+          @controller_class.class_eval <<-EOF
+            def resource_index
+              resources_set(resource_list(resource_source_for_index)#{filter}#{params})
+            end
+          EOF
+
+          @controller_class.class_eval do
+            def index
+              display resource_index, render_options_for_index
+            end
+          end
+          
+          inject_render_options(options, :index)
+          inject_params(options, :index)
+        end
+        
+        def show(options = {})
+          def_source(options, :show)
+
+          @controller_class.class_eval do
+            def show
+              r = resource_get_for_show(params[:id]) or raise Merb::Controller::NotFound
+              display r, render_options_for_show
+            end
+
+            protected
+
+            def resource_get_for_show(id)
+              resource_get(resource_source_for_show, id)
+            end
+          end
+
+          inject_render_options(options, :show)
+        end
+        
+        def new(options = {})
+          def_source(options, :new)
+
+          @controller_class.class_eval do
+            def new
+              only_provides :html
+              display resource_new, render_options_for_new
+            end
+
+            protected
+
+            def resource_new
+              resource_initialize(resource_source_for_new)
+            end
+          end
+          
+          inject_render_options(options, :new)
+        end
+        
+        def create(options = {})
+          def_source(options, :create)
+
+          @controller_class.class_eval do
+            def create
+              r = resource_initialize(resource_source_for_create, 
+                                      params[self.class::RESOURCE_NAME].merge!(resource_params_for_create))
+              if r.save
+                resource_created(r)
+              else
+                message[:error] = "#{self.class::RESOURCE_NAME.humanize} failed to be created"
+                render :new, render_options_for_create
+              end
+            end
+
+            protected
+
+            def resource_created(resrc)
+              redirect resource_created_route, :message => { :notice => resource_created_message(resrc) }
+            end
+
+            def resource_created_message(resrc)
+              "#{self.class::RESOURCE_NAME.singularize} created successfully."
+            end
+          end
+
+          inject_route(options, :create)
+          inject_params(options, :create)
+          inject_render_options(options, :create)
+        end
+        
+        def edit(options = {})
+          def_source(options, :edit)
+
+          @controller_class.class_eval do
+            def edit
+              only_provides :html
+              r = resource_get(resource_source_for_edit, params[:id]) or raise ::Merb::Controller::NotFound
+              display r, render_options_for_edit
+            end
+          end
+          
+          inject_render_options(options, :edit)
+        end
+        
+        def update(options = {})
+          def_source(options, :update)
+
+          @controller_class.class_eval do
+            def update
+              r = resource_get(resource_source_for_update, params[:id]) or raise ::Merb::Controller::NotFound
+              if r.update(params[self.class::RESOURCE_NAME].merge!(resource_params_for_update))
+                resource_updated(r)
+              else
+                message[:error] = "#{RESOURCE_NAME.humanize} failed to be updated"
+                render :edit, render_options_for_update
+              end
+            end
+
+            protected
+
+            def resource_updated(resrc)
+              redirect resource_updated_route, :message => {:notice => resource_updated_message(resrc)}
+            end
+
+            def resource_updated_message(resrc)
+              "#{self.class::RESOURCE_NAME.humanize} updated successfully."
+            end
+          end
+
+          inject_route(options, :update)
+          inject_params(options, :update)
+          inject_render_options(options, :update)
+        end
+        
+        def destroy
+        end
+        
+        private
+        
+        def has_parent?(options)
+          !! (options[:belongs_to] || @options[:belongs_to])
+        end
+        
+        def inject_route(options, method_name)
+          to = (options[:to] && options[:to].inspect) || "resource_ivar"
+
+          if has_parent?(options)
+            @controller_class.class_eval <<-EOF
+              protected
+              def resource_#{method_name}d_route
+                resource(resource_parent_get_for_#{method_name}, #{to})
+              end
+            EOF
+          else
+            @controller_class.class_eval <<-EOF
+              protected
+              def resource_#{method_name}d_route
+                resource(#{to})
+              end
+            EOF
+          end
+        end
+        
+        def inject_render_options(options, method_name)
+          if options[:layout]
+            @controller_class.class_eval do 
+              protected
+              define_method "render_options_for_#{method_name}" do
+                { :layout => options[:layout] }
+              end
+            end
+          else
+            @controller_class.class_eval <<-EOF
+              protected
+              def render_options_for_#{method_name}() {} end
+            EOF
+          end
+        end
+        
+        def inject_params(options, method_name)
+          case options[:params]
+          when Proc
+            @controller_class.class_eval do
+              protected
+              define_method "resource_params_for_#{method_name}", &options[:params]
+            end
+          else
+            @controller_class.class_eval <<-EOF
+              protected
+              def resource_params_for_#{method_name}() {} end
+            EOF
+          end
+        end
+        
+        def def_source(options = {}, method_name = nil)
+          source = options[:belongs_to] || options[:scope] || @options[:belongs_to] || @options[:scope]
+          
+          case source
+          when Symbol
+            def_source_with_scope(source, method_name)
+          else
+            if method_name.nil?
+              @controller_class.class_eval <<-EOF
+                protected
+                def resource_source
+                  #{@resource_class}
+                end
+              EOF
+            else
+              @controller_class.class_eval do
+                alias_method "resource_source_for_#{method_name}", :resource_source
+              end
+            end
+          end
+        end
+        
+        def def_source_with_scope(source, method_name = nil)
+          suffix = method_name && "_for_#{method_name}"
+          
+          s = <<-EOF
+            protected
+            def resource_source#{suffix}
+              #{source}.#{@resource_plural}
+            end
+
+            def resource_parent_get#{suffix}
+              #{source}
+            end
+          EOF
+
+          @controller_class.class_eval s
+        end
+      end
+    end
+  end
+end

data/lib/merb_resourceful/controller.rb

@@ -0,0 +1,8 @@
+module Merb
+  module Plugins
+    module Resourceful
+      module Controller
+      end
+    end
+  end
+end

data/lib/merb_resourceful/orms/datamapper_resource.rb

@@ -0,0 +1,27 @@
+if Merb.orm == :datamapper
+  module Merb
+    module Plugins
+      module Resourceful
+        module ORMS
+          module DataMapperResource
+            def resource_list(source)
+              resources_set(source.all)
+            end
+
+            def resource_initialize(source, attrs = {})
+              resource_set(source.new(attrs))
+            end
+            
+            def resource_get(source, id)
+              resource_set(source.get(id))
+            end
+          end
+        end
+        
+        module Controller
+          include ::Merb::Plugins::Resourceful::ORMS::DataMapperResource
+        end
+      end
+    end
+  end
+end

data/lib/merb_resourceful.rb

@@ -0,0 +1,21 @@
+require 'english/style_orm'
+require File.join(File.dirname(__FILE__), 'merb_resourceful/builder')
+require File.join(File.dirname(__FILE__), 'merb_resourceful/orms/datamapper_resource')
+
+if defined?(Merb)
+  module Merb
+    module Plugins
+      module Resourceful
+        module ClassMethods
+          def resourceful(options = {}, &block)
+            ::Merb::Plugins::Resourceful::Builder.new(self, options).build(&block)
+          end
+        end # ClassMethods
+      end # Resourceful
+    end # Plugins
+      
+    class Controller
+      extend ::Merb::Plugins::Resourceful::ClassMethods
+    end
+  end
+end

data/spec/config/init.rb

@@ -0,0 +1,9 @@
+Merb::Config.use do |c|
+  c[:default_cookie_domain] = "resourceful.davidleal.com"
+  c[:session_id_key] = "key"
+  c[:session_secret_key] = "shhhhhh"
+  c[:session_expiry] = Merb::Const::WEEK * 4
+  c[:log_auto_flush ] = true
+  c[:log_level] = :debug
+  c[:log_file]   = File.join(File.dirname(__FILE__), '..', '..', 'log', 'test.log')
+end

data/spec/merb_resourceful/datamapper_resourceful_controller_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), 'resourceful_controller_spec')
+
+if Merb.orm == :datamapper
+  given "a book exists" do
+    Book.all.destroy!
+    
+    @book = (@shelf ? @shelf.books : Book).create(:title => 'Code Complete')
+  end
+
+  given "a shelf exists" do
+    Shelf.all.destroy!
+    
+    @shelf = Shelf.create
+  end
+  
+  given "2 books exist" do
+    @book = (@shelf ? @shelf.books : Book).create(:title => 'Code Complete')
+    @shelf2 = Shelf.create
+    @book2 = @shelf2.books.create(:title => 'The Practice of Programming')
+  end
+
+  describe "DataMapper resourceful controller" do
+    before :all do
+      DataMapper.setup(:default, "sqlite3::memory:")
+      
+      class Book
+        include DataMapper::Resource
+        
+        property :id, Serial
+        property :title, String, :length => 1..255
+        property :optional, String
+        
+        def self.zee_filter(*args)
+          if param = args.pop
+            [Book.new(:title => param)]
+          else
+            [Book.new(:title => "no params")]
+          end
+        end
+      end
+      
+      class Shelf
+        include DataMapper::Resource
+
+        property :id, Serial
+        
+        has n, :books
+      end
+    end
+    
+    after :all do
+      Object.send(:remove_const, :Book)
+    end
+
+    before do
+      Shelf.auto_migrate!
+      Book.auto_migrate!
+    end
+
+    it_should_behave_like "resourceful controller"
+    
+    def find_single_book
+      Book.first
+    end
+    
+    def find_book_in_shelf
+      @shelf.books.last
+    end
+  end
+end

data/spec/merb_resourceful/resourceful_controller_spec.rb

@@ -0,0 +1,441 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+
+describe "resourceful controller", :shared => true do
+  
+  before :all do
+    Merb.push_path(:view, File.join(File.dirname(__FILE__), '..', 'views'))
+  end
+  
+  before do
+    class AbstractBooks < Merb::Controller
+      def _template_location(action, type = nil, controller = controller_name)
+        controller == "layout" ? "layout.#{action}.#{type}" : "#{action}.#{type}"
+      end
+    end
+    
+    class ShelvedBooks < AbstractBooks
+      def shelf
+        @shelf ||= Shelf.all.last
+      end
+    end
+
+  end
+  
+  after do
+    Object.send(:remove_const, :Books)
+  end
+
+  describe "common behavior", :shared => true do
+    describe "resource(*, :books)" do
+      describe "GET" do
+        before(:each) do
+          with_resourceful
+          
+          @response = request(resource(*request_for_books))
+        end
+        
+        it "responds successfully" do
+          @response.should be_successful
+        end
+
+        it "has a list of books" do
+          @response.should have_xpath("//ul")
+        end
+      end
+      
+      describe "GET", :given => "a book exists" do
+        before(:each) do
+          with_resourceful
+          
+          @response = request(resource(*request_for_books))
+        end
+        
+        it "has a list of books" do
+          @response.should have_xpath("//ul/li")
+        end
+      end
+      
+      describe "a successful POST" do
+        before(:each) do
+          with_resourceful
+          
+          @response = request(resource(*request_for_books), :method => "POST", 
+                              :params => { :book => { :title => "The C Programming Language" }})
+        end
+        
+        it "redirects to resource(*, @book)" do
+          @response.should redirect_to(resource(*request_for_book), 
+                                       :message => {:notice => "book successfully created"})
+        end
+        
+        it "creates the resource" do
+          find_book.should_not be_nil
+        end
+      end
+      
+      describe "GET", "with :filter", :given => "a book exists" do
+        before(:each) do
+          with_resourceful do
+            index :filter => :zee_filter
+          end
+          
+          @response = request(resource(*request_for_books))
+        end
+        
+        it "has a list of filtered books" do
+          @response.should have_xpath("//ul/li[. = 'no params']")
+        end
+      end
+      
+      describe "GET", "with :filter and :params", :given => "a book exists" do
+        before(:each) do
+          with_resourceful do
+            index :filter => :zee_filter, :params => lambda { "whoa" }
+          end
+          
+          @response = request(resource(*request_for_books))
+        end
+        
+        it "has a list of filtered books" do
+          @response.should have_xpath("//ul/li[. = 'whoa']")
+        end
+      end
+      
+      describe "a successful POST", "with :params" do
+        before(:each) do
+          with_resourceful do
+            create :params => lambda {{ :optional => "is not null!" }}
+          end
+          
+          @response = request(resource(*request_for_books), :method => "POST", 
+                              :params => { :book => { :title => "The C Programming Language" }})
+        end
+        
+        it "redirects to resource(*, @book)" do
+          @response.should redirect_to(resource(*request_for_book), 
+                                       :message => {:notice => "book successfully created"})
+        end
+        
+        it "adds the value of optional to the book" do
+          find_book.optional.should_not be_nil
+        end
+      end
+      
+      describe "a successful POST", "with :to" do
+        before(:each) do
+          with_resourceful do
+            create :to => :books
+          end
+          
+          @response = request(resource(*request_for_books), :method => "POST", 
+                              :params => { :book => { :title => "The C Programming Language" }})
+        end
+        
+        it "redirects to resource(*, :books)" do
+          @response.should redirect_to(resource(*request_for_books), 
+                                       :message => {:notice => "book successfully created"})
+        end
+      end
+    end
+
+    describe "resource(*, :books, :new)" do
+      before(:each) do
+        with_resourceful
+          
+        @response = request(resource(*request_for_new_book))
+      end
+      
+      it "responds successfully" do
+        @response.should be_successful
+      end
+    end
+
+    describe "resource(*, @book, :edit)", :given => "a book exists" do
+      before(:each) do
+        with_resourceful
+          
+        @response = request(resource(*request_for_edit_book))
+      end
+      
+      it "responds successfully" do
+        @response.should be_successful
+      end
+      
+      it "presents the resource being edited" do
+        @response.should have_xpath("//*[contains(., 'Edit Code Complete')]")
+      end
+    end
+
+    describe "resource(*, @book)", :given => "a book exists" do
+      describe "GET" do
+        before(:each) do
+          with_resourceful
+          
+          @response = request(resource(*request_for_book))
+        end
+        
+        it "responds successfully" do
+          @response.should be_successful
+        end
+        
+        it "shows the right book" do
+          @response.should have_xpath("//*[contains(., 'Code Complete')]")
+        end
+      end
+      
+      describe "PUT" do
+        before(:each) do
+          with_resourceful
+          
+          @response = request(resource(*request_for_book), :method => "PUT", 
+                              :params => { :book => {:id => @book.id, :title => "Code Complete 2nd Edition."} })
+        end
+        
+        it "redirect to the book show action" do
+          @response.should redirect_to(resource(*request_for_book))
+        end
+        
+        it "updates the book" do
+          Book.first.title.should == "Code Complete 2nd Edition."
+        end
+      end
+      
+      describe "PUT", "with :params" do
+        before(:each) do
+          with_resourceful do
+            update :params => lambda {{ :optional => "is not null!" }}
+          end
+          
+          @response = request(resource(*request_for_book), :method => "PUT", 
+                              :params => { :book => {:id => @book.id, :title => "Code Complete 2nd Edition."} })
+        end
+        
+        it "redirect to the book show action" do
+          @response.should redirect_to(resource(*request_for_book))
+        end
+        
+        it "updates the book with the extra param" do
+          Book.first.optional.should_not be_nil
+        end
+      end
+      
+      describe "a successful DELETE" do
+        before(:each) do
+          pending do 
+            @response = request(resource(*request_delete), :method => "DELETE")
+          end
+        end
+
+        it "should redirect to the index action" do
+          pending do
+            @response.should redirect_to(resource(*request_for_books))
+          end
+        end
+      end
+      
+      describe "GET" do
+        before(:each) do
+          with_resourceful do
+            show :layout => :another
+          end
+          
+          @response = request(resource(*request_for_book))
+        end
+        
+        it "has a different layout" do
+          @response.should have_xpath("//*[contains(., 'Another Layout')]")
+        end
+      end
+    end
+  end
+  
+  describe "action-specific scopes", :shared => true do
+    before do
+      Books.class_eval do
+        def shelf
+          @shelf ||= Shelf.all.last
+        end
+      end
+    end
+    
+    describe "resource(*, @book)", :given => "a book exists" do
+      describe "GET", "using :scope", :given => "2 books exist" do
+        before(:each) do
+          with_resourceful do
+            show :scope => :shelf
+          end
+          
+          @response = request(resource(*request_for_book))
+        end
+          
+        it "responds successfully" do
+          @response.should be_successful
+        end
+        
+        it "shows the right book" do
+          @response.should have_xpath("//*[contains(., 'The Practice of Programming')]")
+        end
+        
+        def request_for_book
+          @book2
+        end
+      end
+    
+      describe "a successful POST", "using :scope", :given => "a shelf exists" do
+        before(:each) do
+          with_resourceful do
+            create :scope => :shelf
+          end
+          
+          @response = request(resource(*request_for_books), :method => "POST", 
+                              :params => { :book => { :title => "The C Programming Language" }})
+        end
+        
+        it "redirects to resource(*, @book)" do
+          @response.should redirect_to(resource(*find_book), 
+                                       :message => {:notice => "book successfully created"})
+        end
+        
+        it "creates the book" do
+          find_book.title.should == "The C Programming Language"
+        end
+        
+        def find_book
+          find_book_in_shelf
+        end
+      end
+    end
+  end
+  
+  describe "single resource" do
+    before :all do
+      Merb::Router.prepare do |r|
+        identify :id do
+          r.resources :books
+        end
+      end
+    end
+    
+    before do
+      class Books < AbstractBooks
+      end
+    end
+    
+    def request_for_books
+      :books
+    end
+    
+    def request_for_book
+      @book || find_book
+    end
+    
+    def request_for_new_book
+      [:books, :new]
+    end
+    
+    def request_for_edit_book
+      [@book, :edit]
+    end
+    
+    it_should_behave_like "common behavior"
+    it_should_behave_like "action-specific scopes"
+    
+    def find_book
+      find_single_book
+    end
+    
+    def with_resourceful(&block)
+      Books.class_eval do
+        resourceful &block
+      end
+    end
+  end
+  
+  describe "single resource", "using :scope", :given => "a shelf exists" do
+    before :all do
+      Merb::Router.prepare do |r|
+        identify :id do
+          r.resources :books
+        end
+      end
+    end
+    
+    before do
+      class Books < ShelvedBooks; end
+    end
+    
+    def request_for_books
+      :books
+    end
+    
+    def request_for_book
+      @book || find_book
+    end
+    
+    def request_for_new_book
+      [:books, :new]
+    end
+    
+    def request_for_edit_book
+      [@book, :edit]
+    end
+    
+    it_should_behave_like "common behavior"
+    it_should_behave_like "action-specific scopes"
+    
+    def find_book
+      find_book_in_shelf
+    end
+    
+    def with_resourceful(&block)
+      Books.class_eval do
+        resourceful :scope => :shelf, &block
+      end
+    end
+  end
+  
+  describe "nested resource", "through method", :given => "a shelf exists" do
+    before :all do
+      Merb::Router.prepare do |r|
+        identify :id do
+          r.resources :shelves do
+            r.resources :books
+          end
+        end
+      end
+    end
+    
+    before do
+      class Books < ShelvedBooks; end
+    end
+    
+    def request_for_books
+      [@shelf, :books]
+    end
+    
+    def request_for_book
+      [@shelf, @book || find_book]
+    end
+    
+    def request_for_new_book
+      [@shelf, :books, :new]
+    end
+    
+    def request_for_edit_book
+      [@shelf, @book, :edit]
+    end
+    
+    it_should_behave_like "common behavior"
+    
+    def find_book
+      find_book_in_shelf
+    end
+    
+    def with_resourceful(&block)
+      Books.class_eval do
+        resourceful :belongs_to => :shelf, &block
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'spec'
+require 'merb-core'
+
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+Spec::Runner.configure do |config|
+  config.include(Merb::Test::ViewHelper)
+  config.include(Merb::Test::RouteHelper)
+  config.include(Merb::Test::ControllerHelper)
+end
+
+Merb.start :environment => 'test', :init_file => File.join(File.dirname(__FILE__), 'config', 'init.rb')
+
+use_orm (ENV['ORM'] || :datamapper).to_sym
+
+require 'merb_resourceful'
+require 'ruby-debug'
+

data/spec/views/create.html.erb

@@ -0,0 +1 @@
+<%= @book.title %>

data/spec/views/edit.html.erb

@@ -0,0 +1 @@
+Edit <%= @book.title %>

data/spec/views/index.html.erb

@@ -0,0 +1,5 @@
+<ul>
+<% for b in @books %>
+  <li><%= b.title %></li>
+<% end -%>
+</ul>

data/spec/views/layout.another.html.erb

@@ -0,0 +1 @@
+Another Layout

data/spec/views/new.html.erb

@@ -0,0 +1 @@
+<%= @book.title %>

data/spec/views/show.html.erb

@@ -0,0 +1 @@
+<%= @book.title %>

data/spec/views/update.html.erb

@@ -0,0 +1 @@
+<%= @book.title %>

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: david-merb_resourceful
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- David Leal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-01 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: merb_resourceful lends a little magic to common resource actions.
+email: dgleal@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README.textile
+- Rakefile
+- TODO
+- lib/merb_resourceful
+- lib/merb_resourceful/controller.rb
+- lib/merb_resourceful/orms
+- lib/merb_resourceful/orms/datamapper_resource.rb
+- lib/merb_resourceful/builder.rb
+- lib/merb_resourceful.rb
+- spec/merb_resourceful
+- spec/merb_resourceful/datamapper_resourceful_controller_spec.rb
+- spec/merb_resourceful/resourceful_controller_spec.rb
+- spec/merb_resourceful/log
+- spec/merb_resourceful/log/merb_test.log
+- spec/merb_resourceful/log/merb.main.pid
+- spec/spec_helper.rb
+- spec/views
+- spec/views/create.html.erb
+- spec/views/edit.html.erb
+- spec/views/new.html.erb
+- spec/views/layout.another.html.erb
+- spec/views/update.html.erb
+- spec/views/show.html.erb
+- spec/views/index.html.erb
+- spec/config
+- spec/config/init.rb
+has_rdoc: true
+homepage: http://github.com/david/merb_resourceful
+post_install_message: 
+rdoc_options: []
+
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: merb
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: merb_resourceful lends a little magic to common resource actions.
+test_files: []
+