responder_controller 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Phil Smith
+
+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,93 @@
+= responder_controller
+
+Rails 3 responders wrap up as much crud controller code as possible without finding or mutating
+models on your behalf.  This is a sensible cut-off for framework support, but it still leaves a
+fair amount of duplicate code in crud controllers.  App developers are free to abstract more.
+
+This is me abstracting more for my own apps.  If it's handy for you, go nuts.
+
+== Example
+
+  # app/models/post.rb
+  class Post < ActiveRecord::Base
+    belongs_to :user
+
+    scope :authored_by, lambda { |user_id| where(:user_id => user_id) }
+    scope :recent, lambda { |count| order("updated_at DESC").limit(limit.to_i) }
+  end
+
+  # app/controllers/posts_controller.rb
+  class PostsController < ApplicationController
+    include ResponderController
+
+    respond_to :html, :xml, :json
+
+    # restrict to just the current user's posts
+    scope { |posts| posts.authored_by current_user.id }
+  end
+
+  # Client-side
+  GET /posts.html             # renders Post.authored_by(your_id)
+  GET /posts.html?recent=10   # renders Post.authored_by(your_id).recent(10)
+  GET /posts/1.html           # renders post 1 if it is authored by you, otherwise 404
+  PUT /posts/1.html           # update same
+  DELETE /posts/1.html        # or delete it
+
+=== Point it at a different model class:
+
+  class ProfilesController < ApplicationController
+    include ResponderController
+    serves_model :user
+  end
+
+=== Serve resources in a namespace:
+
+  class PostsController < ApplicationController
+    include ResponderController
+    responds_within 'my-blog'
+  end
+
+  # Client-side
+  GET /my-blog/posts.html
+
+=== A nested resource, using blocks for dynamic behavior:
+
+  class CommentsController < ApplicationController
+    include ResponderController
+
+    # Only get comments for the identified post
+    scope do |comments|
+      comments.where :post_id => params[:post_id]
+    end
+
+    # Nest the comments under the post
+    responds_within do |comments|
+      Post.find(params[:post_id])
+    end
+  end
+
+=== The same:
+
+  class CommentsController < ApplicationController
+    include ResponderController
+    children_of :post
+  end
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can
+  ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Thanks
+
+Thanks to SEOmoz (http://seomoz.org) for letting me build this at my desk in the afternoons instead of on the couch in the middle of the night ^_^.
+
+== Copyright
+
+Copyright (c) 2010 Phil Smith. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "responder_controller"
+    gem.summary = %Q{like resources_controller, but for rails 3 responders}
+    gem.description = %Q{Responders make crud controllers tiny, this wraps the rest.}
+    gem.email = "phil.h.smith@gmail.com"
+    gem.homepage = "http://github.com/phs/responder_controller"
+    gem.authors = ["Phil Smith"]
+    gem.add_dependency "activesupport", ">= 3.0.0.beta2"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "responder_controller #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/responder_controller.rb

@@ -0,0 +1,278 @@
+require 'active_support/inflector'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/module/delegation'
+
+module ResponderController
+  def self.included(mod)
+    mod.extend ClassMethods
+    mod.send :include, InstanceMethods
+    mod.send :include, Actions
+  end
+
+  # Configure how the controller finds and serves models of what flavor.
+  module ClassMethods
+    # The underscored, fully-qualified name of the served model class.
+    #
+    # By default, it is the underscored controller class name, without +_controller+.
+    def model_class_name
+      @model_class_name || name.underscore.gsub(/_controller$/, '').singularize
+    end
+
+    # Declare the underscored, fully-qualified name of the served model class.
+    #
+    # Modules are declared with separating slashes, such as in <tt>admin/setting</tt>.  Strings
+    # or symbols are accepted, but other values (including actual classes) will raise
+    # <tt>ArgumentError</tt>s.
+    def serves_model(model_class_name)
+      unless model_class_name.is_a? String or model_class_name.is_a? Symbol
+        raise ArgumentError.new "Model must be a string or symbol"
+      end
+
+      @model_class_name = model_class_name.to_s
+    end
+
+    # Declare leading arguments ("responder context") for +respond_with+ calls.
+    #
+    # +respond_with+ creates urls from models.  To avoid strongly coupling models to a url
+    # structure, it can take any number of leading parameters a la +polymorphic_url+.
+    # +responds_within+ declares these leading parameters, to be used on each +respond_with+ call.
+    #
+    # It takes either a varargs or a block, but not both.  In
+    # InstanceMethods#respond_with_contextual, the blocks are called with +instance_exec+, taking
+    # the model (or models) as a parameter.  They should return an array.
+    def responds_within(*args, &block)
+      if block and args.any?
+        raise ArgumentError.new("responds_within can take arguments or a block, but not both")
+      elsif block or args.any?
+        @responds_within ||= []
+        if not args.empty?
+          @responds_within.concat args
+        else
+          @responds_within << block
+        end
+      end
+
+      @responds_within || model_class_name.split('/')[0...-1].collect { |m| m.to_sym }
+    end
+
+    # The served model class, identified by #model_class_name.
+    def model_class
+      model_class_name.camelize.constantize
+    end
+
+    # Declare a class-level scope for model collections.
+    #
+    # The model class is expected to respond to +all+, returning an Enumerable of models.
+    # Declared scopes are applied to (and replace) this collection, suitable for active record
+    # scopes.
+    #
+    # It takes one of a string, symbol or block.  Symbols and strings are called as methods on the
+    # collection without arguments.  Blocks are called with +instance_exec+ taking the current,
+    # accumulated query and returning the new, scoped one.
+    def scope(*args, &block)
+      scope = args.first || block
+
+      scope = scope.to_sym if String === scope
+      unless scope.is_a? Symbol or scope.is_a? Proc
+        raise ArgumentError.new "Scope must be a string, symbol or block"
+      end
+
+      (@scopes ||= []) << scope
+    end
+
+    # The array of declared class-level scopes, as symbols or procs.
+    attr_reader :scopes
+
+    # Declare a (non-singleton) parent resource class.
+    #
+    # <tt>children_of 'accounts/user'</tt> implies a scope and some responder context.  The scope
+    # performs an ActiveRecord <tt>where :user_id => params[:user_id]</tt>.  The responder context
+    # is a call to <tt>#responds_within</tt> declaring the parent model's modules along with the
+    # parent itself, found with <tt>Accounts::User.find(params[:user_id])</tt>.
+    def children_of(parent_model_class_name)
+      parent_model_class_name = parent_model_class_name.to_s.underscore
+
+      parent_name_parts = parent_model_class_name.split('/')
+      parent_modules = parent_name_parts[0...-1].collect(&:to_sym)
+      parent_id = "#{parent_name_parts.last}_id".to_sym
+
+      scope do |query|
+        query.where parent_id => params[parent_id]
+      end
+
+      responds_within do
+        parent = parent_model_class_name.camelize.constantize.find params[parent_id]
+        parent_modules + [parent]
+      end
+    end
+  end
+
+  # Instance methods that support the Actions module.
+  module InstanceMethods
+    delegate :model_class_name, :model_class, :scopes, :responds_within, :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.
+    #
+    # TODO: and if the scope taketh arguments not?
+    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
+
+      scopes_from_request = (model_class.scopes.keys & params.keys.collect { |k| k.to_sym })
+      query = scopes_from_request.inject(query) do |query, scope|
+        query.send scope, *params[scope.to_s]
+      end
+
+      query
+    end
+
+    # Find all models in #scope.
+    #
+    # The initial, unscoped is <tt>ClassMethods#model_class.all</tt>.
+    def find_models
+      scope model_class.all
+    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
+
+  # The seven standard restful actions.
+  module Actions
+    # Find, assign and respond with models.
+    def index
+      self.models = find_models
+      respond_with_contextual models
+    end
+
+    # Find, assign and respond with a single model.
+    def show
+      self.model = find_model
+      respond_with_contextual model
+    end
+
+    # Build (but do not save), assign and respond with a new model.
+    #
+    # The new model is built from the <tt>InstanceMethods#find_models</tt> collection, meaning it
+    # could inherit any properties implied by those scopes.
+    def new
+      self.model = find_models.build
+      respond_with_contextual model
+    end
+
+    # Find, assign and respond with a single model.
+    def edit
+      self.model = find_model
+      respond_with_contextual model
+    end
+
+    # Build, save, assign and respond with a new model.
+    #
+    # The model is created with attributes from the request params, under the
+    # <tt>InstanceMethods#model_slug</tt> key.
+    def create
+      self.model = find_models.build(params[model_slug])
+      model.save
+      respond_with_contextual model
+    end
+
+    # Find, update, assign and respond with a single model.
+    #
+    # The new attributes are taken from the request params, under the
+    # <tt>InstanceMethods#model_slug</tt> key.
+    def update
+      self.model = find_model
+      model.update_attributes(params[model_slug])
+      respond_with_contextual model
+    end
+
+    # Find and destroy a model.  Respond with <tt>InstanceMethods#models_slug</tt>.
+    def destroy
+      find_model.destroy
+      respond_with_contextual models_slug
+    end
+  end
+end

data/responder_controller.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{responder_controller}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Phil Smith"]
+  s.date = %q{2010-05-12}
+  s.description = %q{Responders make crud controllers tiny, this wraps the rest.}
+  s.email = %q{phil.h.smith@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/responder_controller.rb",
+     "responder_controller.gemspec",
+     "spec/responder_controller_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/phs/responder_controller}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  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/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    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_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 3.0.0.beta2"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 3.0.0.beta2"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/spec/responder_controller_spec.rb

@@ -0,0 +1,511 @@
+require File.expand_path(File.dirname(__FILE__) + '/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" 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_name' do
+    it "is .model_class_name" do
+      PostsController.new.model_class_name.should == PostsController.model_class_name
+    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', 'by default' do
+    it "passes its argument out" do
+      PostsController.new.scope(@query).should == @query
+    end
+  end
+
+  describe '#model_class' do
+    it 'is .model_class' do
+      PostsController.new.model_class.should == PostsController.model_class
+    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 '#scopes' do
+    it 'is .scopes' do
+      PostsController.new.scopes.should == PostsController.scopes
+    end
+  end
+
+  describe '#scope', 'with explicit scopes' do
+    it "asks model_class for the declared scopes in order" do
+      @query.should_receive(:unpublished).and_return(@query)
+      @query.should_receive(:recent).and_return(@query)
+      PostsController.new.scope(@query).should == @query
+    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 '#scope', 'with a block scope' do
+    it 'instance_execs the block while passing in the current query' do
+      @query.should_receive(:owned_by).with('me').and_return(@query)
+
+      controller = PostsController.new
+      controller.scope(@query).should == @query
+    end
+  end
+
+  describe '#scope', 'with an unknown scope' do
+    it 'explodes' do
+      PostsController.scope :furst_p0sts
+
+      lambda do
+        PostsController.new.scope
+      end.should raise_error ArgumentError
+
+      PostsController.scopes.pop
+    end
+  end
+
+  describe '#scope', 'with request parameters naming scopes' do
+    before :each do
+      @controller = PostsController.new
+      @controller.params['commented_on_by'] = 'you'
+    end
+
+    it 'applies the requested scopes in order' do
+      @query.should_receive(:commented_on_by).with('you').and_return(@query)
+      @controller.scope @query
+    end
+
+    it 'is applied after class-level scopes' do
+      class_level_query = mock("class-level scoped query")
+      @query.should_receive(:owned_by).and_return(class_level_query) # last class-level scope
+
+      class_level_query.should_receive(:commented_on_by).with('you').and_return(class_level_query)
+      @controller.scope(@query).should == class_level_query
+    end
+  end
+
+  describe '#find_models' do
+    it 'is #scope #model_class.find(:all)' do
+      controller = PostsController.new
+
+      Post.should_receive(:all).and_return(@query)
+      controller.should_receive(:scope).with(@query).and_return(@query)
+
+      controller.find_models.should == @query
+    end
+  end
+
+  describe '#find_model' do
+    it 'is #find_models.find(params[:id])' do
+      controller = PostsController.new
+      controller.should_receive(:find_models).and_return(@query)
+      @query.should_receive(:find).with(controller.params[:id]).and_return(post = mock("the post"))
+
+      controller.find_model.should == post
+    end
+  end
+
+  describe '#model_slug' do
+    it 'is the model class name' do
+      PostsController.new.model_slug.should == :post
+    end
+
+    it 'drops the leading module names, if any' do
+      Admin::SettingsController.new.model_slug.should == :setting
+    end
+  end
+
+  describe '#models_slug' do
+    it 'is ths symbolized plural of #model_slug' do
+      PostsController.new.models_slug.should == :posts
+    end
+  end
+
+  describe '#model_ivar' do
+    it 'is the #model_slug with a leading @' do
+      PostsController.new.model_ivar.should == '@post'
+    end
+  end
+
+  describe '#models_ivar' do
+    it 'is the plural #model_ivar' do
+      (controller = PostsController.new).models_ivar.should == controller.model_ivar.pluralize
+    end
+  end
+
+  describe "#models" do
+    it "gets #models_ivar" do
+      (controller = PostsController.new).instance_variable_set("@posts", :some_posts)
+      controller.models.should == :some_posts
+    end
+  end
+
+  describe "#model" do
+    it "gets #model_ivar" do
+      (controller = PostsController.new).instance_variable_set("@post", :a_post)
+      controller.model.should == :a_post
+    end
+  end
+
+  describe "#models=" do
+    it "assigns to #models_ivar" do
+      assigned = mock("some models")
+      (controller = PostsController.new).models = assigned
+      controller.instance_variable_get("@posts").should == assigned
+    end
+  end
+
+  describe "#model=" do
+    it "assigns to #model_ivar" do
+      assigned = mock("a model")
+      (controller = PostsController.new).model = assigned
+      controller.instance_variable_get("@post").should == assigned
+    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
+
+  describe '#responds_within' do
+    it 'is .responds_within' do
+      PostsController.new.responds_within.should == PostsController.responds_within
+    end
+  end
+
+  describe '#responder_context' do
+    it "is the argument prepended with responds_within" do
+      Admin::SettingsController.new.responder_context(:argument).should == [:admin, :argument]
+    end
+
+    it "passes the argument to responds_within and prepends the result if it is a lambda" do
+      Admin::SettingsController.responds_within do |model|
+        model.should == :argument
+        [:nested, :namespace]
+      end
+
+      Admin::SettingsController.new.responder_context(:argument).should == [:nested, :namespace, :argument]
+    end
+
+    it "wraps the lambda result in an array if needed" do
+      Admin::SettingsController.responds_within { |model| :namespace }
+      Admin::SettingsController.new.responder_context(:argument).should == [:namespace, :argument]
+    end
+
+    after :each do
+      Admin::SettingsController.instance_variable_set "@responds_within", nil
+    end
+  end
+
+  describe '#respond_with_contextual' do
+    it 'passed #responder_context to #respond_with' do
+      controller = PostsController.new
+      controller.should_receive(:responder_context).with(:argument).and_return([:contextualized_argument])
+      controller.should_receive(:respond_with).with(:contextualized_argument)
+
+      controller.respond_with_contextual :argument
+    end
+  end
+
+  describe '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)
+    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' do
+        @controller.should_receive(:respond_with_contextual).with(@posts)
+        @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/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+gem 'activesupport'
+
+require 'responder_controller'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: responder_controller
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Phil Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta2
+        version: 3.0.0.beta2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id002
+description: Responders make crud controllers tiny, this wraps the rest.
+email: phil.h.smith@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/responder_controller.rb
+- responder_controller.gemspec
+- spec/responder_controller_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/phs/responder_controller
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: like resources_controller, but for rails 3 responders
+test_files: 
+- spec/responder_controller_spec.rb
+- spec/spec_helper.rb