basic_assumption 0.3.5 → 0.3.6

data/README.rdoc

@@ -6,7 +6,7 @@ methods that is useful in Rails applications.
 
 === What is DecentExposure?
 
-It's a plugin written by {Stephen Cuadill}[http://voxdolo.me/] that provides a way of
+It's a plugin written by {Stephen Caudill}[http://voxdolo.me/] that provides a way of
 cleaning up Rails controller and view code. Find it at
 {its GitHub repository}[http://github.com/voxdolo/decent_exposure].
 
@@ -52,7 +52,7 @@ available inside your controllers.
 The most important (of the few) methods made available in controller classes is
 +assume+, which is used to declaratively define a resource of some kind in
 controller instances and to make that resource available inside corresponding
-views. For all the verbiage of the description, it's a simple concept, as
+views. For all the wordiness of the description, it's a simple concept, as
 illustrated below. First, we will use +assume+ to expose a resource inside our
 controller actions that will take the value resulting from the block passed to
 +assume+. In this case, the resource will be called 'widget':
@@ -96,15 +96,34 @@ probably use an assumption instead. Because BasicAssumption is written to use
 lazy evaluation, there's no need to worry about avoiding calls on actions that
 don't need some particular setup.
 
+For example, this:
+
+    class RecordController < ActionController::Base
+      before_filter :find_record, :only => [:show, :edit, :update, :destroy]
+
+      ...
+
+      protected
+      def find_record
+        @record = Record.find(params[:record_id] || params[:id])
+      end
+    end
+
+would become this:
+
+    class RecordController < ActionController::Base
+      assume :record
+    end
+
+and would have the added benefit of not tossing instance variables around.
 If a controller has protected or hidden methods that find or create instance
 variables used in actions and/or views, it might be cleaner to use an
 assumption instead.
 
 BasicAssumption allows for a simple, declarative, and very lightweight approach
-to RESTful controllers.
-
-It also can make for a cleaner, more testable interface for controller or view
-testing. There may even be uses outside of Rails apps. Give it a shot.
+to RESTful controllers.  It also can make for a cleaner, more testable interface
+for controller or view testing. There may even be uses outside of Rails apps.
+Give it a shot.
 
 === Defaults
 
@@ -145,6 +164,10 @@ this would be :film_id.) Enable that for one of your controllers like so:
       default_assumption :cautious_rails
     end
 
+Another option is :restful_rails, which attempts to provide appropriate
+behavior for the basic RESTful actions. Please see +RestfulRails+ for a
+description of how it works.
+
 Default assumptions are inherited by derived classes.
 
 === Supplying custom default behavior classes

data/lib/basic_assumption/default_assumption/restful_rails.rb

@@ -0,0 +1,114 @@
+module BasicAssumption
+  module DefaultAssumption
+    # Restful default behavior in the context of Rails
+    class RestfulRails < BasicAssumption::DefaultAssumption::Base
+      attr_reader :action,
+                  :lookup_id,
+                  :name,
+                  :page,
+                  :params,
+                  :per_page,
+                  :resource_attributes #:nodoc:
+
+      def initialize(name = nil, params = {}) #:nodoc:
+        @action    = params['action']
+        @lookup_id = params['id']
+        @name      = name.to_s
+        @params    = params
+        @resource_attributes = params[singular_name]
+
+        if @page = params['page']
+          @per_page = params['per_page'] || '15'
+        end
+      end
+
+      # Returns a block that will attempt to do the correct thing depending
+      # on which action the request is triggering. If the action is 'show',
+      # 'edit', 'update', or 'destroy', then +assume+ will find an instance of
+      # an ActiveRecord model based on the +name+ that it recieved and an id
+      # value in the parameters. If the action is 'new' or 'create', +assume+
+      # will instantiate a new instance of the model class, passing in the
+      # values it finds in the +params+ hash with a key of the singularized
+      # form of the +name+ passed to +assume+. For example:
+      #
+      #    class WidgetController < ApplicationController
+      #      default_assumption :restful_rails
+      #      assume :widget
+      #
+      #      def create
+      #        widget.save!    # widget is: Widget.new(params[:widget])
+      #      end
+      #    end
+      #
+      # Note the object will have been instantiated but not saved, destroyed,
+      # etc. If the action is 'index', there are two possibilities for the
+      # behavior of +assume+. If the +name+ passed is of singular form, then
+      # a find will be performed, just as for a show or edit action. If the
+      # +name+ is a plural word, then +assume+ will find all instances of
+      # the model class.
+      #
+      # However, if the model responds to +paginate+ and there is a +page+
+      # key in the +params+ hash, +assume+ will attempt to paginate the
+      # results, also observing a +per_page+ value in the +params+ hash or
+      # defaulting to 15 if one is not found.
+      def block
+        klass = self.class
+        Proc.new do |name|
+          klass.new(name, params).result
+        end
+      end
+
+      def result #:nodoc:
+        if list?
+          list
+        elsif make?
+          model_class.new(resource_attributes)
+        else
+          model_class.find(lookup_id)
+        end
+      end
+
+      protected
+
+      def find? #:nodoc:
+        %w(show edit update destroy).include? action
+      end
+
+      def list #:nodoc:
+        if page?
+          model_class.paginate('page' => page, 'per_page' => per_page)
+        else
+          model_class.all
+        end
+      end
+
+      def list? #:nodoc:
+        action.eql?('index') && plural_name.eql?(name)
+      end
+
+      def lookup?
+        params['id'].present?
+      end
+
+      def make? #:nodoc:
+        %w(new create).include?(action) || !lookup?
+      end
+
+      def model_class #:nodoc:
+        @model_class ||= name.classify.constantize
+      end
+
+      def page? #:nodoc:
+        page.present? && model_class.respond_to?(:paginate)
+      end
+
+      def plural_name #:nodoc:
+        name.pluralize
+      end
+
+      def singular_name #:nodoc:
+        name.singularize
+      end
+    end
+  end
+end

data/lib/basic_assumption/version.rb

@@ -1,3 +1,3 @@
 module BasicAssumption
-  VERSION = '0.3.5'
+  VERSION = '0.3.6'
 end

data/spec/lib/basic_assumption/default_assumption/restful_rails_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require 'active_support'
+require 'basic_assumption/default_assumption/restful_rails'
+
+describe BasicAssumption::DefaultAssumption::RestfulRails do
+  class Model
+    attr_accessor :age, :color
+    def initialize(hash = {})
+      hash.each do |k, v|
+        self.send("#{k}=", v)
+      end
+    end
+  end
+
+  it { should be }
+
+  context "#block" do
+    let(:default) { BasicAssumption::DefaultAssumption::RestfulRails.new(:model, params) }
+
+    before(:each) do
+      Model.stub!(:find)
+      default.stub!(:params).and_return(params)
+    end
+
+    context "in the show action" do
+      let(:params)  { { 'id' => 42, 'action' => 'show' } }
+
+      it "attempts to find a model instance based off the given name" do
+        Model.should_receive(:find).with(42).and_return(:model)
+        default.block.call(:model).should eql(:model)
+      end
+    end
+
+    context "in the edit action" do
+      let(:params)  { { 'id' => 42, 'action' => 'edit' } }
+
+      it "attempts to find a model instance based off the given name" do
+        Model.should_receive(:find).with(42).and_return(:model)
+        default.block.call(:model).should eql(:model)
+      end
+    end
+
+    context "in the update action" do
+      let(:params)  do
+        { 'id' => 42 }
+      end
+
+      it "attempts to find a model instance based off the given name" do
+        Model.should_receive(:find).with(42).and_return(:model)
+        default.block.call(:model).should eql(:model)
+      end
+    end
+
+    context "in the destroy action" do
+      let(:params)  { { 'id' => 42, 'action' => 'destroy' } }
+
+      it "attempts to find a model instance based off the given name" do
+        Model.should_receive(:find).with(42).and_return(:model)
+        default.block.call(:model).should eql(:model)
+      end
+    end
+
+    context "in the create action" do
+      let(:params) do
+        {
+          'action' => 'create',
+          'model'  => { 'age' => 27, 'color' => 'blue' }
+        }
+      end
+
+      context "the model instance" do
+      subject { default.block.call(:model) }
+        its(:age)   { should be(27) }
+        its(:color) { should eql('blue') }
+      end
+    end
+
+    context "in the new action" do
+      let(:params) do
+        {
+          'action' => 'new',
+          'model'  => { 'age' => 27, 'color' => 'blue' }
+        }
+      end
+
+      context "the model instance" do
+      subject { default.block.call(:model) }
+        its(:age)   { should be(27) }
+        its(:color) { should eql('blue') }
+      end
+    end
+
+    context "in the index action" do
+      let(:params)  { { 'action' => 'index' } }
+      context "when the name given to assume is plural" do
+        let(:name) { :models }
+        context "without pagination" do
+          before { Model.should_receive(:all) }
+          context "when 'page' exists in the request params" do
+            before { params['page'] = '5' }
+            it "finds all the records of the model class" do
+              default.block.call(name)
+            end
+          end
+          context "when 'page' does not exist in the request params" do
+            it "finds all the records of the model class" do
+              default.block.call(name)
+            end
+          end
+        end
+        context "with pagination" do
+          before { Model.stub! :paginate }
+          context "when 'page' exists in the request params" do
+            before { params['page'] = '5' }
+            it "paginates the records of the model class" do
+              Model.should_receive(:paginate)
+              default.block.call(name)
+            end
+            context "when 'per_page' exists in the request params" do
+              it "paginates using 'page' and 'per_page' from the params" do
+                params['per_page'] = '10'
+                Model.should_receive(:paginate).with('page' => '5', 'per_page' => '10')
+                default.block.call(name)
+              end
+            end
+            context "when 'per_page' does not exist in the request params" do
+              it "paginates using 'page' from the params and a default 'per_page' of 15" do
+                Model.should_receive(:paginate).with('page' => '5', 'per_page' => '15')
+                default.block.call(name)
+              end
+            end
+          end
+          context "when 'page' does not exist in the request params" do
+            it "finds all the records of the model class" do
+              Model.should_receive(:all)
+              default.block.call(name)
+            end
+          end
+        end
+      end
+      context "when the name given to assume is singular" do
+        let(:name) { :model }
+        context "and there is an id in params" do
+          before { params['id'] = 1 }
+          it "attempts to find a model instance based off the given name" do
+            Model.should_receive(:find).with(1).and_return(:model)
+            default.block.call(name).should eql(:model)
+          end
+        end
+        context "and there is no id in params" do
+          before { params['model'] = :initializers }
+          it "creates a new model instance and passes in appropriate params" do
+            Model.should_receive(:new).with(:initializers).and_return(:model)
+            default.block.call(name).should eql(:model)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 5
-  version: 0.3.5
+  - 6
+  version: 0.3.6
 platform: ruby
 authors: 
 - Matt Yoho
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-26 00:00:00 -05:00
+date: 2010-05-27 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,6 +78,7 @@ files:
 - lib/basic_assumption/default_assumption/cautious_rails.rb
 - lib/basic_assumption/default_assumption/class_resolver.rb
 - lib/basic_assumption/default_assumption/rails.rb
+- lib/basic_assumption/default_assumption/restful_rails.rb
 - lib/basic_assumption/default_assumption/simple_rails.rb
 - lib/basic_assumption/rails.rb
 - lib/basic_assumption/version.rb
@@ -120,4 +121,5 @@ test_files:
 - spec/lib/basic_assumption/default_assumption/base_spec.rb
 - spec/lib/basic_assumption/default_assumption/cautious_rails_spec.rb
 - spec/lib/basic_assumption/default_assumption/class_resolver_spec.rb
+- spec/lib/basic_assumption/default_assumption/restful_rails_spec.rb
 - spec/lib/basic_assumption/default_assumption/simple_rails_spec.rb