hookercookerman-merb-resource-scope 0.1.0

data/lib/merb-resource-scope/controller/singleton_actions.rb

@@ -0,0 +1,25 @@
+module MerbResourceScope
+  module Controller
+    module SingletonActions
+ 
+      include Actions
+      
+      def self.included(base)
+        base.show_action(:show, :new, :edit, :update, :create, :destroy)
+      end
+  
+      undef index
+      
+       def destroy
+        self.current_resource = find_resource
+         raise Merb::ControllerExceptions::NotFound unless current_resource
+         if current_resource.destroy
+           redirect_to current_resources_url if enclosing_resource
+         else
+           raise Merb::ControllerExceptions::BadRequest
+         end
+      end
+
+    end
+  end
+end

data/lib/merb-resource-scope/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :merb_resource_scope do
+  desc "Do something for merb-resource-scope"
+  task :default do
+    puts "merb-resources-scope doesn't do anything"
+  end
+end

data/lib/merb-resource-scope/router/resource_specification.rb

@@ -0,0 +1,144 @@
+module Merb
+  class Request    
+    attr_accessor :resource_specifications
+  end
+end
+
+  # Adds a specification to a route behaviour, using defered blocks
+  #
+  # Each specification added in a block will be added to the request 
+  # therefore all specifications within the behaviour block will be 
+  # added to the request.
+  #
+  # So what does that mean? when a route is matched, the request will
+  # have a list of resource specficiation for that particular route matched 
+  # which can be used to determine the enclosing resource, which then can
+  # used to generate urls like enclosing_resource_url enclosing_resources_url
+  #
+  # @examples
+  # resources_with_specification :comments 
+  #
+  # resource_with_specification :myhome, :spec => {:singleton => true, :find_method => Proc.new{ session.authentication.user}} do
+  #    resources_with_specification :posts
+  # end
+  #  
+  # so what the above just said was this resource is a singleton and I am going to use the proc which is used at the 
+  # controller to determine how to find that resource
+  # @see test-stack/config/routes.rb for more examples
+  #
+  # options for Specification MUST have the key :spec => {}
+  # =======================================================
+  #
+  #
+  # @param options<Hash>
+  #   :association_method<Symbol>
+  #
+  #       This does what is says, its used to find associations, it is also used for Singleton creations, erh??
+  #       Well if you have singleton say users/1/profile_image/new, the users specification would be used to create
+  #       the singleton, ie ProfileImage.new :user => @user, so the association name will be used in this instance!
+  #      
+  #       All the deafaults can be set inferred from this, therefore this will be used to set the
+  #       the resource_name, which is then used to set the class. So setting an association_method :posts
+  #       would mean resource_name == :post, :klass == Post.
+  #       
+  #   :class_name<String>:
+  #
+  #        Used to create resource, simple.
+  #        This can be inferred from the resource_name therefore if we have a resource_name of :user
+  #        the class_name would be "User", if you have a class that cannot be inferred from the the resource_name
+  #        then you need to set this
+  #
+  #   :resource_name<Symbol>: 
+  #          
+  #         Will be used to create|new resource from the params, i.e  :post => {:title => "hello there"}
+  #         This will be used to create the class_name if not set.
+  #         NB NB NB NB - This will also be used when generating the url helpers
+  #         what I mean is that if we have a resource_name "post" the post will be used
+  #         to generate a named_url i.e admin_post  or myhome_post  or comment_post OR 
+  #         posts or comment_posts etc  actucallly or new_post edit_post etc etc
+  #
+  #   :singelton<TrueClass>: basically says I am not a collection!
+  #
+  #   :find<Symbol, Proc>: 
+  #
+  #       A resoure can be found via a specified method or a Proc, the method would need to be 
+  #       accessiable to the controller ie. :current_user
+  #
+  #   :key<Symbol> 
+  #
+  #      this is used to find a resource through the params, this will 
+  #      can be inferred from the resource_name ie 'post_id' if a permalink is set
+  #      then the key is set with that i.e 'login' or 'display_name' etc
+  #
+  #   :permalink<Symbol>
+  #
+  #      is you want to find a resource other then using :id or resource_name_id i.e post_id
+  #      then you can set a permalink
+Merb::Router.extensions do
+  def resources_with_specification(name, *args, &block)
+    raise ArgumentError, "you need specifify at least the  name" unless name
+    options = args.pop
+    spec_options = options && options[:spec] || {}
+    spec_options[:name_prefix] = name_prefix_from_options(self)
+    options.delete(:spec) if options
+    defer(lambda{|request, params| 
+      request.resource_specifications ||= []
+      if scoped_class_name = spec_options[:scoped_class_name]
+        spec_options[:class_name] = request.resource_specifications.last.klass_name + scoped_class_name
+      end
+      request.resource_specifications << MerbResourceScope::Specification.create(name, spec_options)
+      params
+      }).resources(name, *(args << options), &block)
+  end
+  alias_method :resources_with_spec, :resources_with_specification
+  
+  
+  def resource_with_specification(name, *args, &block)
+    raise ArgumentError, "you need specifify at least the  name" unless name
+    options = args.pop || {}
+    spec_options = options && options[:spec] || {}
+    spec_options[:name_prefix] = name_prefix_from_options(self)
+    options.delete(:spec) if options
+    spec_options.merge!(:singleton => true)  
+    defer(lambda{|request, params| 
+      raise ArgumentError, "you need specifify at least the resource name" unless name
+      request.resource_specifications ||= []
+      if scoped_class_name = spec_options[:scoped_class_name]
+        spec_options[:class_name] = request.resource_specifications.last.klass_name + scoped_class_name
+      end
+      request.resource_specifications << MerbResourceScope::Specification.create(name, spec_options)
+      params
+      }).resource(name, *(args << options), &block)
+  end
+  alias_method :resource_with_spec, :resource_with_specification
+  
+
+  # this means that a specification can be added to any route, and they can be chanined together
+  # to form a none restful specification
+  #
+  def specification(association_method, options = {}, &block)
+    options[:name_prefix] = name_prefix_from_options(self)
+    defer(lambda{|request, params| 
+      raise ArgumentError, "you need specifify at least the association method" unless association_method
+      request.resource_specifications ||= []
+      if scoped_class_name = spec_options[:scoped_class_name]
+        spec_options[:class_name] = request.resource_specifications.last.klass_name + scoped_class_name
+      end
+      request.resource_specifications << MerbResourceScope::Specification.create(association_method, options)
+      params
+      }, &block)
+  end
+  alias_method :spec, :specification
+  
+  private
+  # get the name_prefixes of behaviour so route genentation can happen easily and
+  # it does not have to be decleared in the options 
+  #
+  # @param behaviour<Merb::Router::Behavior>
+  #
+  # @return<Array<String>>
+  def name_prefix_from_options(behaviour)
+    options = behaviour.instance_variable_get("@options")
+    options[:name_prefix] || []
+  end
+end

data/lib/merb-resource-scope/specification.rb

@@ -0,0 +1,36 @@
+# specification for a route
+# the idea of this just to give enough information onto a 
+# specified route that enables to know more information 
+# about the request then would be normaly be available
+#
+# i.e users/1/posts
+# via attaching specifications to this route
+# we can automagically know "HOW" posts can be found
+# in this case via finding the user and then calling
+# posts on the found user, you know what mean!
+
+module MerbResourceScope
+  class Specification
+    attr_accessor :klass, :resource_name, :find_method, :singleton, :association_method, :foreign_key, :scope_depth, :permalink, :name_prefix, :klass_name
+  
+    def initialize(association_method, options = {})
+      @association_method = options[:association_method] && options[:association_method].to_s || association_method.to_s 
+      @resource_name = options[:resource_name] && options[:resource_name].to_s || Extlib::Inflection.singularize(@association_method) 
+      @singleton = options[:singleton] || false 
+      @klass_name = options[:class_name] || Extlib::Inflection.classify(@resource_name) 
+      @klass = Object.full_const_get(@klass_name) rescue nil
+      @find_method = options[:find_method] 
+      @scope_depth = options[:scope_depth] 
+      @permalink = options[:permalink] || :id 
+      @name_prefix = options[:name_prefix] 
+      @foreign_key = options[:foreign_key] || @permalink == :id ? Extlib::Inflection.foreign_key(@resource_name).to_sym : @permalink 
+    end
+  
+    # create a specification instance
+    # @return <Specification>
+    def self.create(association_method, options = {})
+      options = options.only(:association_method, :class_name, :singleton, :find_method, :resource_name, :foreign_key, :scope_depth, :permalink, :name_prefix)
+      new(association_method, options)
+    end
+  end
+end

data/spec/app.rb

@@ -0,0 +1,7 @@
+
+# setup application
+
+20.times {User.gen}
+22.times {Campaign.gen}
+20.times {Post.gen}
+20.times {PostImage.gen}

data/spec/controller/_build_enclosing_scope_spec.rb

@@ -0,0 +1,107 @@
+# require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+# 
+# given "specifications for [campaign, posts, comments] are available to the controller" do
+#   DataMapper.auto_migrate!
+#   @campagin_spec = MerbResourceScope::Specification.create(:campaigns)
+#   @posts_spec = MerbResourceScope::Specification.create(:posts)
+#   @comments_spec = MerbResourceScope::Specification.create(:comments)
+#   @specifications = [@campagin_spec, @posts_spec, @comments_spec]
+#   
+#   @user = User.gen
+#   @campaign = Campaign.gen
+#   @post = Post.gen :campaign => @campaign, :user => @user
+#   @comments = 10.times {Comment.gen :post => @post }
+#   
+#   @controller = Comments.new(build_request({:campaign_id => "#{@campaign.id}", :post_id => "#{@post.id}"}), 200)
+#   
+#   @controller.request.resource_specifications = @specifications
+#   @controller._call_filters(@controller._before_filters)
+# end
+# 
+# 
+# describe "ResourceScope", :given =>  "specifications for [campaign, posts, comments] are available to the controller" do
+#   
+#   it "should have an enclosing resource of Campaign.get(:id)" do
+#     @controller.enclosing_resource.should == Campaign.get(@campaign.id).posts.get(@post.id)
+#   end
+# 
+#   it "should have current_scope of Campaign.get(:id).posts.get(:id).comments" do
+#     @controller.resource_scope.current_scope.should == Campaign.get(@campaign.id).posts.get(@post.id).comments
+#   end
+#   
+#   it "should have a new comment when ussng the scope of a campaign " do
+#     @controller.resource_scope.current_scope.should == Campaign.get(@campaign.id).posts.get(@post.id).comments
+#   end
+# end
+# # 
+# given "specifications for [myhome, posts] are available with a controller" do
+#   DataMapper.auto_migrate!
+#   @myhome_spec = MerbResourceScope::Specification.create(:myhome, :class => User, :find_method => :current_user, :singleton => true)
+#   @posts_spec = MerbResourceScope::Specification.create(:posts)
+#   @specifications = [@myhome_spec, @posts_spec]
+#   
+#   @user = User.gen
+#   @campaign = Campaign.gen
+#   @posts = 10.times {Post.gen :campaign => @campaign, :user => @user}
+#   
+#   @controller = Comments.new(build_request, 200)
+#   
+#   @controller.request.resource_specifications = @specifications
+#   @controller._call_filters(@controller._before_filters)
+# end
+# 
+# describe "ResourceScope", :given =>  "specifications for [myhome, posts] are available with a controller" do
+#   it "should have an enclosing resource of current_user which is User.first for us" do
+#     @controller.enclosing_resource.should ==  User.first
+#   end
+#   
+#   it "should have current_scope of User.first.posts" do
+#     @controller.resource_scope.current_scope.should == User.first.posts
+#   end
+# end
+# # 
+# given "specifications for [myhome, post, :image] are available with a controller" do
+#   DataMapper.auto_migrate!
+#   @myhome_spec = MerbResourceScope::Specification.create(:myhome, :class => User, :find_method => :current_user, :singleton => true)
+#   @posts_spec = MerbResourceScope::Specification.create(:posts)
+#   @image_spec = MerbResourceScope::Specification.create(:image, :class => PostImage, :singleton => true)
+#   @specifications = [@myhome_spec, @posts_spec, @image_spec]
+#   
+#   @user = User.gen
+#   @campaign = Campaign.gen
+#   @post = Post.gen :campaign => @campaign, :user => @user
+#   @post_image = PostImage.gen :post => @post, :user => @user
+#   
+#   @controller = Comments.new(build_request(:post_id => "#{@post.id}"), 200)
+#   @controller.request.resource_specifications = @specifications
+#   @controller._call_filters(@controller._before_filters)
+# end
+# 
+# describe "ResourceScope", :given =>  "specifications for [myhome, post, :image] are available with a controller" do  
+#   it "should have an enclosing resource of User.first.posts.get(:id)" do
+#     @controller.enclosing_resource.should ==   User.first.posts.get(@post.id)
+#   end
+#   
+#   it "should have current_scope of User.first.posts.image" do
+#     @controller.resource_scope.current_scope.should == User.first.posts.get(@post.id).image
+#   end
+# end
+# 
+# 
+# given "specifications for [:campaigns] are available with a controller" do
+#   DataMapper.auto_migrate!
+#   @campaigns_spec = MerbResourceScope::Specification.create(:campaigns)
+#   @specifications = [@campaigns_spec]
+# 
+#   @campaign = Campaign.gen
+#   
+#   @controller = Comments.new(build_request, 200)
+#   @controller.request.resource_specifications = @specifications
+#   @controller._call_filters(@controller._before_filters)
+# end
+# 
+# describe "ResourceScope", :given =>  "specifications for [:campaigns] are available with a controller" do
+#   it "should have current_scope of Campaign" do
+#     @controller.resource_scope.current_scope.should == Campaign
+#   end
+# end

data/spec/integration/admin_posts_controller_spec.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+given "requsting admin/posts" do
+  DataMapper.auto_migrate!
+  User.gen
+  10.times {Post.gen}
+  @rack = request_with_controller("/admin/posts")
+end
+describe "Admin::Post controller spec", :given => "requsting admin/posts" do
+  it "should  be cool 'requsting requsting admin/posts'" do
+    @rack.should be_successful  
+  end
+  
+  it "should have a current_resources of 'requsting requsting admin/posts'" do
+    @rack.controller.current_resources.should == Post.all
+  end
+  
+  it "should have content of 'Posts controller, index action'" do
+    @rack.body.should contain("Posts controller, index action")
+  end
+  
+  it "should have instance variable of posts set" do
+    @rack.controller.instance_variable_get("@posts").should_not be_nil
+  end
+  
+  describe "route generation" do
+    it "should have a current_resource_url of 'admin/posts'" do
+      @rack.controller.current_resources_url.should == "/admin/posts"
+    end
+    
+    it "should be able to generate a new post url with the admin" do
+       @rack.controller.new_current_resource_url.should == "/admin/posts/new"
+    end
+
+    it "should be able to generate a 'recent' custom url" do
+      @rack.controller.current_resources_url(:recent).should == "/admin/posts/recent"
+    end
+  end
+end
+
+
+given "requsting admin/post/new" do
+  DataMapper.auto_migrate!
+  User.gen
+  10.times {Post.gen}
+  @rack = request_with_controller("/admin/posts/new")
+end
+
+describe "Admin::Post controller spec", :given => "requsting admin/post/new" do
+  it "should  be cool 'requsting requsting admin/posts/new'" do
+    @rack.should be_successful  
+  end
+  
+  it "should have content 'Posts controller, new action'" do
+    @rack.body.should contain("Posts controller, new action")
+  end
+  
+  it "should have an instance variable of @post"  do
+    @rack.controller.instance_variable_get("@post").should_not be_nil
+  end
+  
+  describe "route generation" do
+    it "should have a current_resources_url of 'admin/posts'" do
+      @rack.controller.current_resources_url.should == "/admin/posts"
+    end
+  end
+end
+# 
+given "requsting admin/post/:id/edit" do
+  DataMapper.auto_migrate!
+  User.gen
+  @post  = Post.gen :user => @user
+  @rack = request_with_controller("/admin/posts/#{@post.id}/edit")
+end
+
+describe "Admin::Post controller spec", :given => "requsting admin/post/:id/edit" do
+  it "should  be cool 'requsting requsting admin/posts/:id/edit'" do
+    @rack.should be_successful  
+  end
+  
+  it "should have content 'Posts controller, edit action'" do
+    @rack.body.should contain("Posts controller, edit action")
+  end
+  
+  it "should have a current_resource of Post.get(:id)" do
+    @rack.controller.current_resource.should == Post.get(@post.id)
+  end
+
+  describe "route generation" do
+    it "should have a current_resource_url of 'admin/posts/:id'" do
+      @rack.controller.current_resource_url(@post).should == "/admin/posts/#{@post.id}"
+    end
+    it "should be able to have a current_resource_url with params if egg='egg'" do
+      @rack.controller.current_resource_url(@post, :egg => "egg").should == "/admin/posts/#{@post.id}?egg=egg"
+    end
+  end
+end
+
+# 
+given "requsting admin/post with POST" do
+  DataMapper.auto_migrate!
+  @rack = request_with_controller("/admin/posts", :method => "POST",
+        :params => {:post => {:title => "cool", :body => "man"}})
+end
+
+describe "Admin::Post controller spec", :given => "requsting admin/post with POST" do
+  it "should  be cool be cool then redirect to admin/posts" do
+    @rack.should redirect_to("/admin/posts")
+  end
+  
+  it "should have a created the new post" do
+    Post.all.size.should == 1
+  end
+  
+  it "should have create a post with a body of 'man'" do
+    Post.first(:conditions => {:body => "man"}).should_not be_nil
+  end
+
+  describe "route generation" do
+    it "should have a current_resources_url of 'admin/posts'" do
+      @rack.controller.current_resources_url.should == "/admin/posts"
+    end
+  end
+end
+
+given "requsting admin/post/:id with PUT" do
+  DataMapper.auto_migrate!
+  @post = Post.gen
+  @rack = request_with_controller("/admin/posts/#{@post.id}", :method => "PUT", :params => {:post => {:title => "whatthe"}})
+end
+
+describe "Admin::Post controller spec", :given => "requsting admin/post/:id with PUT" do
+  it "should  be cool and then 'redirect to admin/posts/:id'" do
+    @rack.should redirect_to("/admin/posts/#{@post.id}")
+  end
+  
+  it "should have updated the post with its new title" do
+    @post.reload.title.should == "whatthe"
+  end
+end
+# 
+# 
+given "requsting admin/post/:id with DELETE" do
+  DataMapper.auto_migrate!
+  @post = Post.gen
+  @rack = request_with_controller("/admin/posts/#{@post.id}", :method => "DELETE")
+end
+
+describe "Admin::Post controller spec", :given => "requsting admin/post/:id with DELETE" do
+  it "should  be cool and then 'redirect to admin/posts'" do
+    @rack.should redirect_to("/admin/posts")
+  end
+  
+  it "should have deleted the post" do
+    Post.all.should be_empty
+  end
+
+end