responder_controller 0.2.0 → 0.3.0

data/lib/responder_controller/instance_methods.rb

@@ -0,0 +1,118 @@
+require 'active_support/core_ext/module/delegation'
+
+module ResponderController
+  # Instance methods that support the Actions module.
+  module InstanceMethods
+    delegate :model_class_name, :model_class, :scopes, :responds_within, :serves_scopes,
+      :to => "self.class"
+
+    # Apply scopes to the given query.
+    #
+    # Applicable scopes come from two places.  They are either declared at the class level with
+    # <tt>ClassMethods#scope</tt>, or named in the request itself.  The former is good for
+    # defining topics or enforcing security, while the latter is free slicing and dicing for
+    # clients.
+    #
+    # Class-level scopes are applied first.  Request scopes come after, and are discovered by
+    # examining +params+.  If any +params+ key matches a name found in
+    # <tt>ClassMethods#model_class.scopes.keys</tt>, then it is taken to be a scope and is
+    # applied.  The values under that +params+ key are passed along as arguments.
+    def scope(query)
+      query = (scopes || []).inject(query) do |query, scope|
+        if Symbol === scope and model_class.scopes.key? scope
+          query.send scope
+        elsif Proc === scope
+          instance_exec query, &scope
+        else
+          raise ArgumentError.new "Unknown scope #{model_class}.#{scope}"
+        end
+      end
+
+      requested = (model_class.scopes.keys & params.keys.collect { |k| k.to_sym })
+      raise ForbiddenScope if serves_scopes[:only] && (requested - serves_scopes[:only]).any?
+      raise ForbiddenScope if serves_scopes[:except] && (requested & serves_scopes[:except]).any?
+
+      query = requested.inject(query) do |query, scope|
+        query.send scope, *params[scope.to_s] rescue raise BadScope
+      end
+
+      query
+    end
+
+    # Find all models in #scope.
+    #
+    # The initial query is <tt>ClassMethods#model_class.scoped</tt>.
+    def find_models
+      scope model_class.scoped
+    end
+
+    # Find a particular model.
+    #
+    # #find_models is asked to find a model with <tt>params[:id]</tt>.  This ensures that
+    # class-level scopes are enforced (potentially for security.)
+    def find_model
+      find_models.find(params[:id])
+    end
+
+    # The underscored model class name, as a symbol.
+    #
+    # Model modules are omitted.
+    def model_slug
+      model_class_name.split('/').last.to_sym
+    end
+
+    # Like #model_slug, but plural.
+    def models_slug
+      model_slug.to_s.pluralize.to_sym
+    end
+
+    # The name of the instance variable holding a single model instance.
+    def model_ivar
+      "@#{model_slug}"
+    end
+
+    # The name of the instance variable holding a collection of models.
+    def models_ivar
+      model_ivar.pluralize
+    end
+
+    # Retrive #models_ivar
+    def models
+      instance_variable_get models_ivar
+    end
+
+    # Assign #models_ivar
+    def models=(models)
+      instance_variable_set models_ivar, models
+    end
+
+    # Retrive #model_ivar
+    def model
+      instance_variable_get model_ivar
+    end
+
+    # Assign #model_ivar
+    def model=(model)
+      instance_variable_set model_ivar, model
+    end
+
+    # Apply ClassMethods#responds_within to the given model (or symbol.)
+    #
+    # "Apply" just means turning +responds_within+ into an array and appending +model+ to the
+    # end.  If +responds_within+ is an array, it used directly.
+    #
+    # If it is a proc, it is called with +instance_exec+, passing +model+ in.  It should return an
+    # array, which +model+ will be appended to.  (So, don't include it in the return value.)
+    def responder_context(model)
+      context = responds_within.collect do |o|
+        o = instance_exec model, &o if o.is_a? Proc
+        o
+      end.flatten + [model]
+    end
+
+    # Pass +model+ through InstanceMethods#responder_context, and pass that to #respond_with.
+    def respond_with_contextual(model)
+      respond_with *responder_context(model)
+    end
+  end
+end

data/responder_controller.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{responder_controller}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Phil Smith"]
@@ -25,7 +25,13 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "lib/responder_controller.rb",
+     "lib/responder_controller/actions.rb",
+     "lib/responder_controller/class_methods.rb",
+     "lib/responder_controller/instance_methods.rb",
      "responder_controller.gemspec",
+     "spec/responder_controller/actions_spec.rb",
+     "spec/responder_controller/class_methods_spec.rb",
+     "spec/responder_controller/instance_methods_spec.rb",
      "spec/responder_controller_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
@@ -36,7 +42,10 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{like resources_controller, but for rails 3 responders}
   s.test_files = [
-    "spec/responder_controller_spec.rb",
+    "spec/responder_controller/actions_spec.rb",
+     "spec/responder_controller/class_methods_spec.rb",
+     "spec/responder_controller/instance_methods_spec.rb",
+     "spec/responder_controller_spec.rb",
      "spec/spec_helper.rb"
   ]
 
@@ -45,14 +54,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0.beta2"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0.beta3"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
     else
-      s.add_dependency(%q<activesupport>, [">= 3.0.0.beta2"])
+      s.add_dependency(%q<activesupport>, [">= 3.0.0.beta3"])
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
     end
   else
-    s.add_dependency(%q<activesupport>, [">= 3.0.0.beta2"])
+    s.add_dependency(%q<activesupport>, [">= 3.0.0.beta3"])
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
   end
 end

data/spec/responder_controller/actions_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe ResponderController do
+
+  class ApplicationController
+    include ResponderController
+
+    def params
+      @params ||= { :user_id => 'me', :id => 7 }
+    end
+  end
+
+  class PostsController < ApplicationController
+  end
+
+  describe ResponderController::Actions do
+    before :each do
+      @controller = PostsController.new
+      @controller.stub!(:find_models).and_return(@posts = mock("some posts"))
+      @controller.stub!(:find_model).and_return(@post = mock("a post"))
+      @controller.stub!(:respond_with)
+
+      @posts.stub!(:build).and_return(@post)
+      @posts.stub!(:to_a).and_return([])
+    end
+
+    describe '#index' do
+      it 'assigns #find_models to #models=' do
+        @controller.should_receive(:find_models).and_return(@posts)
+        @controller.index
+        @controller.instance_variable_get('@posts').should == @posts
+      end
+
+      it '#respond_with_contextual @models.to_a' do
+        @posts.should_receive(:to_a).and_return(:posts_array)
+        @controller.should_receive(:respond_with_contextual).with(:posts_array)
+        @controller.index
+      end
+    end
+
+    [:show, :edit].each do |verb|
+      describe "##{verb}" do
+        it 'assigns #find_model to #model=' do
+          @controller.should_receive(:find_model).and_return(@post)
+          @controller.send verb
+          @controller.instance_variable_get('@post').should == @post
+        end
+
+        it '#respond_with_contextual @model' do
+          @controller.should_receive(:respond_with_contextual).with(@post)
+          @controller.send verb
+        end
+      end
+    end
+
+    describe '#new' do
+      it 'assigns #find_models.new to #model=' do
+        @posts.should_receive(:build).and_return(@post)
+        @controller.new
+        @controller.instance_variable_get('@post').should == @post
+      end
+
+      it '#respond_with_contextual @model' do
+        @controller.should_receive(:respond_with_contextual).with(@post)
+        @controller.new
+      end
+    end
+
+    describe '#create' do
+      before :each do
+        @post.stub!(:save)
+      end
+
+      it 'passes params[model_slug] to #find_models.new' do
+        @controller.params[:post] = :params_to_new
+        @posts.should_receive(:build).with(:params_to_new)
+        @controller.create
+      end
+
+      it 'assigns #find_models.new to #model=' do
+        @controller.create
+        @controller.instance_variable_get('@post').should == @post
+      end
+
+      it 'saves the model' do
+        @post.should_receive(:save)
+        @controller.create
+      end
+
+      it '#respond_with_contextual @model' do
+        @controller.should_receive(:respond_with_contextual).with(@post)
+        @controller.create
+      end
+    end
+
+    describe '#update' do
+      before :each do
+        @post.stub!(:update_attributes)
+      end
+
+      it 'assigns #find_model to #model=' do
+        @controller.should_receive(:find_model).and_return(@post)
+        @controller.update
+        @controller.instance_variable_get('@post').should == @post
+      end
+
+      it "updates the model's attributes" do
+        @controller.params[:post] = :params_to_update
+        @post.should_receive(:update_attributes).with(:params_to_update)
+        @controller.update
+      end
+
+      it '#respond_with_contextual @model' do
+        @controller.should_receive(:respond_with_contextual).with(@post)
+        @controller.update
+      end
+    end
+
+    describe '#destroy' do
+      before :each do
+        @post.stub!(:destroy)
+      end
+
+      it 'finds the model' do
+        @controller.should_receive(:find_model).and_return(@post)
+        @controller.destroy
+      end
+
+      it 'destroys the model' do
+        @post.should_receive(:destroy)
+        @controller.destroy
+      end
+
+      it '#respond_with_contextual #models_slug' do
+        @controller.should_receive(:respond_with_contextual).with(:posts)
+        @controller.destroy
+      end
+    end
+  end
+end

data/spec/responder_controller/class_methods_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+class Post
+  class <<self
+    def scopes
+      {
+        :recent => "a scope",
+        :unpublished => "another",
+        :authored_by => "and another",
+        :commented_on_by => "even one more",
+        :published_after => "man they just keep coming"
+      }
+    end
+  end
+end
+
+module Accounts
+  class User
+  end
+end
+
+module Admin
+  class Setting
+  end
+end
+
+describe ResponderController::ClassMethods do
+
+  class ApplicationController
+    include ResponderController
+
+    def params
+      @params ||= { :user_id => 'me', :id => 7 }
+    end
+  end
+
+  class PostsController < ApplicationController
+  end
+
+  class Admin::SettingsController < ApplicationController
+  end
+
+  before :each do
+    @query = mock("the scoped query")
+    @query.stub!(:unpublished).and_return(@query)
+    @query.stub!(:recent).and_return(@query)
+    @query.stub!(:owned_by).with('me').and_return(@query)
+  end
+
+  describe '.model_class_name', 'by default' do
+    it 'is taken from the controller class name' do
+      PostsController.model_class_name.should == 'post'
+    end
+
+    it "includes the controller's modules divided by whacks" do
+      Admin::SettingsController.model_class_name.should == 'admin/setting'
+    end
+  end
+
+  describe '.serves_model' do
+    it 'sets the model class name to the passed value' do
+      PostsController.serves_model 'some_other_model'
+      PostsController.model_class_name.should == 'some_other_model'
+    end
+
+    it 'accepts symbols as well as strings' do
+      PostsController.serves_model :some_other_model
+      PostsController.model_class_name.should == 'some_other_model'
+    end
+
+    it 'raises ArgumentError for other values' do
+      lambda do
+        PostsController.serves_model [:not_a, :string_or_symbol]
+      end.should raise_error ArgumentError
+    end
+
+    after :each do
+      PostsController.serves_model :post
+    end
+  end
+
+  describe '.model_class' do
+    it 'is the constant named by model_class_name' do
+      PostsController.model_class.should == Post
+    end
+
+    it 'handles modules in the name' do
+      Admin::SettingsController.model_class.should == Admin::Setting
+    end
+  end
+
+  describe '.scope' do
+    it 'takes a string naming a scope on model_class' do
+      PostsController.scope 'unpublished'
+    end
+
+    it 'can take a symbol' do
+      PostsController.scope :recent
+    end
+  end
+
+  describe '.scopes' do
+    it 'is an array of scopes in order, as symbols' do
+      PostsController.scopes.should == [:unpublished, :recent]
+    end
+  end
+
+  describe '.scope', 'with a block' do
+    it 'omits the name and can reference params' do
+      PostsController.scope do |posts|
+        posts.owned_by(params[:user_id])
+      end
+    end
+
+    it 'puts a lambda on .scopes' do
+      PostsController.scopes.last.should be_a Proc
+    end
+  end
+
+  describe '.scope', 'with something that is not a string, symbol or block' do
+    it 'explodes' do
+      lambda do
+        PostsController.scope [:not_a, :string_symbol_or_block]
+      end.should raise_error ArgumentError
+    end
+  end
+
+  describe '.serves_scopes' do
+    before :each do
+      @controller = PostsController.new
+      @controller.params['commented_on_by'] = 'you'
+    end
+
+    it 'can specify a white list of active record scopes to serve' do
+      PostsController.serves_scopes :only => [:recent, :authored_by, :published_after]
+      lambda do
+        @controller.scope @query
+      end.should raise_error(ResponderController::ForbiddenScope)
+    end
+
+    it 'can specify just one scope to white list' do
+      PostsController.serves_scopes :only => :recent
+      lambda do
+        @controller.scope @query
+      end.should raise_error(ResponderController::ForbiddenScope)
+    end
+
+    it 'can specify a black list of active record scopes to deny' do
+      PostsController.serves_scopes :except => [:commented_on_by, :unpublished]
+      lambda do
+        @controller.scope @query
+      end.should raise_error(ResponderController::ForbiddenScope)
+    end
+
+    it 'can specify just one scope to black list' do
+      PostsController.serves_scopes :except => :commented_on_by
+      lambda do
+        @controller.scope @query
+      end.should raise_error(ResponderController::ForbiddenScope)
+    end
+
+    it 'whines if passed anything other than a hash' do
+      lambda do
+        PostsController.serves_scopes 'cupcakes!'
+      end.should raise_error TypeError
+    end
+
+    it 'whines about keys other than :only and :except' do
+      lambda do
+        PostsController.serves_scopes 'only' => :recent
+      end.should raise_error ArgumentError
+    end
+
+    it 'whines when both :only and :except are passed' do
+      lambda do
+        PostsController.serves_scopes :only => :recent, :except => :commented_on_by
+      end.should raise_error ArgumentError
+    end
+
+    it 'whines if both :only and :except are passed between different calls' do
+      PostsController.serves_scopes :only => :recent
+      lambda do
+        PostsController.serves_scopes :except => :commented_on_by
+      end.should raise_error ArgumentError
+    end
+
+    it 'accumulates scopes passed over multiple calls' do
+      PostsController.serves_scopes :only => :recent
+      PostsController.serves_scopes :only => :authored_by
+      PostsController.serves_scopes[:only].should == [:recent, :authored_by]
+    end
+
+    after :each do
+      PostsController.serves_scopes.clear # clean up
+    end
+  end
+
+  describe '.responds_within' do
+    it "contains the model's enclosing module names as symbols by default" do
+      PostsController.responds_within.should == []
+      Admin::SettingsController.responds_within.should == [:admin]
+    end
+
+    it "takes, saves and returns a varargs" do
+      PostsController.responds_within(:foo, :bar, :baz).should == [:foo, :bar, :baz]
+      PostsController.responds_within.should == [:foo, :bar, :baz]
+    end
+
+    it "accumulates between calls" do
+      PostsController.responds_within(:foo).should == [:foo]
+      PostsController.responds_within(:bar, :baz).should == [:foo, :bar, :baz]
+      PostsController.responds_within.should == [:foo, :bar, :baz]
+    end
+
+    it "can take a block instead" do
+      block = lambda {}
+      PostsController.responds_within(&block).should == [block]
+      PostsController.responds_within.should == [block]
+    end
+
+    it "whines if both positional arguments and a block are passed" do
+      lambda do
+        PostsController.responds_within(:foo, :bar, :baz) {}
+      end.should raise_error ArgumentError
+    end
+
+    after :each do
+      PostsController.instance_variable_set "@responds_within", nil # clear out the garbage
+    end
+  end
+
+  describe '.children_of' do
+    it 'takes a underscored model class name' do
+      PostsController.children_of 'accounts/user'
+    end
+
+    it "can take symbols" do
+      PostsController.children_of 'accounts/user'.to_sym
+    end
+
+    it "creates a scope filtering by the parent model's foreign key as passed in params" do
+      PostsController.children_of 'accounts/user'
+      controller = PostsController.new
+      controller.params[:user_id] = :the_user_id
+
+      user_query = mock("user-restricted query")
+      @query.should_receive(:where).with(:user_id => :the_user_id).and_return(user_query)
+      controller.scope(@query).should == user_query
+    end
+
+    it "adds a responds_within context, of the parent modules followed by the parent itself" do
+      PostsController.children_of 'accounts/user'
+      controller = PostsController.new
+      controller.params[:user_id] = :the_user_id
+
+      Accounts::User.should_receive(:find).with(:the_user_id).and_return(user = mock("the user"))
+
+      controller.responder_context(:argument).should == [:accounts, user, :argument]
+    end
+
+    after :each do
+      PostsController.instance_variable_set "@responds_within", nil # clear out the garbage
+      PostsController.scopes.clear
+    end
+  end
+end