basic_assumption 0.3.11 → 0.4.0

data/HISTORY.rdoc

@@ -1,3 +1,10 @@
+== 0.4.0 / 2010-07-16
+* Feature Addition
+  * Add simple rspec matcher
+  * Default assumptions can now be passed a context hash from #assume
+  * Rails defaults support an :as option in the context that will specify a model name different from the name passed to #assume
+* Test Enhancement
+  * Development dependencies now managed with Bundler
 == 0.3.11 / 2010-06-28
 * Test Enhancement
   * Cucumber features covering most of the basic functionality within a Rails 2.3 app (not included in gem)

data/README.rdoc

@@ -116,6 +116,20 @@ In this case, the +show_mine+ action overrides the value of widget so that it
 may reuse the view template for the regular +show+ action. Overriding the
 assumed resource should be the exception, not the rule.
 
+==== Using an alternative model name
+
+BasicAssumption tends to assume a lot of things, including the name of the model
+class a default +assume+ call should try to load. If you want the name given to
++assume+ to differ from the name of the model, use the optional context hash to
+pass an +as+ option:
+
+    class WidgetController < ApplicationController
+      assume :sprocket, :as => :widget
+    end
+
+This will create a +sprocket+ method in your actions and views that will use the
+Widget model for its lookup.
+
 For more details on how BasicAssumption is wired into your Rails
 app, please see the BasicAssumption::Railtie documentation.
 
@@ -207,6 +221,29 @@ calls as well.
 
     assume :luigi, :using => :luigi_strategy
 
+=== Passing context to defaults
+
+BasicAssumption supports passing a hash of arbitrary context information when
++assume+ is called without a block. This allows configuration or optional data
+to be made available in default blocks. The built-in Rails defaults use this
+to override the name of the model that is being worked with via the :as option.
+
+Here is an example:
+
+    class Widget < ActiveRecord::Base
+      named_scope :shiny, :conditions => {:glossy => true}
+    end
+
+    class WidgetController < ActionController::Base
+      default_assumption do |name, context|
+        name.to_s.classify.constantize.send(context[:type]).find(params[:id])
+      end
+
+      assume :widget, :type => :shiny
+    end
+
+In this case, the lookups for +widget+ are scoped to ones that are shiny.
+
 === In Rails
 
 In Rails, a useful default is already active out of the box. It attempts to
@@ -216,7 +253,7 @@ following two constructs would be equivalent in your controllers:
 
     assume(:film) { Film.find(params[:film_id] || params[:id]) }
     # The above line is exactly the same as:
-    assume(:film)
+    assume :film
 
 Please see +Rails+ for implementation details . Because finding on :id
 could be considered dangerous, there is another default available for use,
@@ -259,7 +296,7 @@ that is active by default within Rails.
 
           def block
             klass = self.class
-            Proc.new do |name|
+            Proc.new do |name, context|
               klass.new(name, params).result
             end
           end
@@ -277,10 +314,11 @@ that is active by default within Rails.
     end
 
 The only method that BasicAssumption depends on in the interface of custom
-default classes is the +block+ method. Note the hoops that have to be jumped
+default classes is the +block+ method. It should return a Proc that accepts a
+a symbol/string name and a context hash. Note the hoops that have to be jumped
 through inside the implementation of +block+ in this example. Keep in mind the
 implications of evaluating the +Proc+ returned by +block+ using +instance_eval+
-(or +instance_exec+).
+(or +instance_exec+), and enclose any data the block may need at runtime.
 
 == Configuration
 
@@ -320,24 +358,29 @@ If you're unfamiliar with why this is being done, take a look
 {here for a start}[http://tomayko.com/writings/require-rubygems-antipattern].
 
 There is also a Cucumber suite that can be run to check BasicAssumption against
-an actual Rails app. Until Bundler has been introduced to manage the gem
-dependencies for the development environment, you will need to ensure at least
-the following gems are installed:
-
-* aruba (0.1.9)
-* capybara (0.3.8)
-* cucumber (0.8.3)
-* cucumber-rails (0.3.2)
-* database_cleaner (0.5.2)
-* rails (2.3.5)
-* rake (0.8.7)
-* sqlite3-ruby (1.3.0)
-* will_paginate (2.3.14)
+an actual Rails app.
 
 There is an .rvmrc file in the repository that will require a basic_assumption
 gemset if you're using RVM, which will help to manage the gem dependencies.
 
-Other than that, fork away and send back pull requests! Thanks.
+The test suites are dependent on the Bundler gem. Ensure that it is installed
+with:
+
+    gem install bundler
+
+To run the Cucumber and spec suites for the first time, use these Rake tasks:
+
+    rake init
+    rake
+
+Note that the +init+ task will +bundle+ +install+ the development dependencies,
+which includes +basic_assumption+ itself. Using the RVM gemset is recommended.
+
+This will create an example Rails app in ./tmp and run the suites against it.
+Use +rake+ +spec+ to run BasicAssumption's specs, +rake+ +cucumber+ to run the
+cukes, or +rake+ to run specs and cukes.
+
+Feel free to fork away and send back pull requests, including specs! Thanks.
 
 == But should I use it?
 

data/lib/basic_assumption/default_assumption/base.rb

@@ -6,7 +6,7 @@ module BasicAssumption
       # Returns a proc that accepts an argument (which is, in practice, the
       # name that was passed to BasicAssumption#assume) and returns +nil+.
       def block
-        Proc.new { |name| }
+        Proc.new { |name, context| }
       end
     end
   end

data/lib/basic_assumption/default_assumption/cautious_rails.rb

@@ -17,6 +17,15 @@ module BasicAssumption
       #   class WidgetController < ActionController::Base
       #     assume(:widget) { Widget.find(params[:widget_id]) }
       #   end
+      #
+      # It is possible to specify an alternative model name:
+      #
+      #   class WidgetController < ApplicationController
+      #     assume :sprocket, :as => :widget
+      #   end
+      #
+      # This will create a +sprocket+ method in your actions and view
+      # that will use the Widget model for its lookup.
       def block
         super
       end

data/lib/basic_assumption/default_assumption/rails.rb

@@ -2,10 +2,10 @@ module BasicAssumption
   module DefaultAssumption
     # Custom default behavior in the context of Rails.
     class Rails < BasicAssumption::DefaultAssumption::Base
-      attr_reader :name, :params #:nodoc:
+      attr_reader :name, :context, :params #:nodoc:
 
-      def initialize(name=nil, params={}) #:nodoc:
-        @name, @params = name.to_s, params
+      def initialize(name=nil, context={}, params={}) #:nodoc:
+        @name, @context, @params = name.to_s, context, params
       end
       # Returns a block that will attempt to find an instance of
       # an ActiveRecord model based on the name that was given to
@@ -19,10 +19,19 @@ module BasicAssumption
       #   class WidgetController < ActionController::Base
       #     assume(:widget) { Widget.find(params[:widget_id] || params[:id]) }
       #   end
+      #
+      # It is possible to specify an alternative model name:
+      #
+      #   class WidgetController < ApplicationController
+      #     assume :sprocket, :as => :widget
+      #   end
+      #
+      # This will create a +sprocket+ method in your actions and view
+      # that will use the Widget model for its lookup.
       def block
         klass = self.class
-        Proc.new do |name|
-          klass.new(name, params).result
+        Proc.new do |name, context|
+          klass.new(name, context, params).result
         end
       end
 
@@ -36,7 +45,11 @@ module BasicAssumption
       end
 
       def model_class #:nodoc:
-        @model_class ||= name.classify.constantize
+        @model_class ||= model_name.classify.constantize
+      end
+
+      def model_name #:nodoc:
+        context[:as] ? context[:as].to_s : name
       end
     end
   end

data/lib/basic_assumption/default_assumption/restful_rails.rb

@@ -9,7 +9,7 @@ module BasicAssumption
                   :per_page,
                   :resource_attributes #:nodoc:
 
-      def initialize(name = nil, params = {}) #:nodoc:
+      def initialize(name = nil, context={}, params = {}) #:nodoc:
         super
         @action    = params['action']
         @resource_attributes = params[singular_name]
@@ -47,6 +47,15 @@ module BasicAssumption
       # find all records of the model type paginated based on the +page+
       # value in params and also a +per_page+ value. Otherwise, it returns all
       # # records for the model.
+      #
+      # It is possible to specify an alternative model name:
+      #
+      #   class WidgetController < ApplicationController
+      #     assume :sprocket, :as => :widget
+      #   end
+      #
+      # This will create a +sprocket+ method in your actions and view
+      # that will use the Widget model for its lookup.
       def block
         super
       end

data/lib/basic_assumption/rspec.rb

@@ -0,0 +1,13 @@
+Spec::Matchers.define :assume do |assumption|
+  match do |controller|
+    controller.respond_to?(assumption) && controller.respond_to?(:"#{assumption}=")
+  end
+
+  failure_message_for_should do |controller|
+    "expected #{controller.class.name} to assume '#{assumption}'"
+  end
+
+  failure_message_for_should_not do |controller|
+    "expected #{controller.class.name} not to assume '#{assumption}'"
+  end
+end

data/lib/basic_assumption/version.rb

@@ -1,3 +1,3 @@
 module BasicAssumption
-  VERSION = '0.3.11'
+  VERSION = '0.4.0'
 end

data/lib/basic_assumption.rb

@@ -61,15 +61,15 @@ module BasicAssumption
   # +assume+ will also create an attribute writer method that will allow the
   # value returned by the instance method (the reader, from this point of view)
   # to be overriden.
-  def assume(name, strategy={}, &block)
+  def assume(name, context={}, &block)
     define_method(name) do
       @basic_assumptions       ||= {}
       @basic_assumptions[name] ||= if block_given?
         instance_eval(&block)
       else
-        which = strategy[:using] || self.class
+        which = context.delete(:using) || self.class
         block = DefaultAssumption.resolve(which)
-        instance_exec(name, &block)
+        instance_exec(name, context, &block)
       end
     end
     define_method("#{name}=") do |value|

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

@@ -17,17 +17,24 @@ describe BasicAssumption::DefaultAssumption::CautiousRails do
 
     it "looks for a params[model_id] in its calling context" do
       params.should_receive(:[]).with('model_id').and_return(nil)
-      default.block.call(:model)
+      default.block.call(:model, {})
     end
 
     it "does not look for params[id] in its calling context" do
       params.should_receive(:[]).with('id').never
-      default.block.call(:model)
+      default.block.call(:model, {})
     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)
+      default.block.call(:model, {}).should eql(:model)
+    end
+
+    context "when passed an alternative model name" do
+      it "finds a model instance based off the alternative name" do
+        Model.should_receive(:find).with(42).and_return(:model)
+        default.block.call(:my_model, {:as => :model}).should eql(:model)
+      end
     end
   end
 end

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

@@ -18,12 +18,19 @@ describe BasicAssumption::DefaultAssumption::Rails do
     it "looks for a params[model_id] and params[id] in its calling context" do
       params.should_receive(:[]).with('model_id').and_return(nil)
       params.should_receive(:[]).with('id')
-      default.block.call(:model)
+      default.block.call(:model, {})
     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)
+      default.block.call(:model, {}).should eql(:model)
+    end
+
+    context "when passed an alternative model name" do
+      it "finds a model instance based off the alternative name" do
+        Model.should_receive(:find).with(42).and_return(:model)
+        default.block.call(:my_model, {:as => :model}).should eql(:model)
+      end
     end
   end
 end

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

@@ -14,7 +14,7 @@ end
 describe BasicAssumption::DefaultAssumption::RestfulRails do
 
   context "#block" do
-    let(:default) { BasicAssumption::DefaultAssumption::RestfulRails.new(:model, params) }
+    let(:default) { BasicAssumption::DefaultAssumption::RestfulRails.new(:model, {}, params) }
 
     before(:each) do
       Model.stub!(:find)
@@ -35,12 +35,12 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
               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)
+                  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)
+                  default.block.call(name, {})
                 end
               end
             end
@@ -52,12 +52,12 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
               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)
+                  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)
+                  default.block.call(name, {})
                 end
               end
             end
@@ -77,26 +77,26 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
                 before { params[:page] = '5' }
                 it "paginates the records of the model class" do
                   Model.should_receive(:paginate)
-                  default.block.call(name)
+                  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)
+                    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" do
                     Model.should_receive(:paginate).with(:page => '5', :per_page => nil)
-                    default.block.call(name)
+                    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)
+                  default.block.call(name, {})
                 end
               end
             end
@@ -109,26 +109,26 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
                 before { params[:page] = '5' }
                 it "paginates the records of the model class" do
                   Model.should_receive(:paginate)
-                  default.block.call(name)
+                  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)
+                    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" do
                     Model.should_receive(:paginate).with(:page => '5', :per_page => nil)
-                    default.block.call(name)
+                    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)
+                  default.block.call(name, {})
                 end
               end
             end
@@ -145,14 +145,14 @@ describe BasicAssumption::DefaultAssumption::RestfulRails 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(name)
-            default.block.call(name).should eql(name)
+            default.block.call(name, {}).should eql(name)
           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(name)
-            default.block.call(name).should eql(name)
+            default.block.call(name, {}).should eql(name)
           end
         end
       end
@@ -162,7 +162,7 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
 
         it "attempts to find a model instance based off the given name" do
           Model.should_receive(:find).with(42).and_return(name)
-          default.block.call(name).should eql(:model)
+          default.block.call(name, {}).should eql(:model)
         end
       end
 
@@ -171,7 +171,7 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
 
         it "attempts to find a model instance based off the given name" do
           Model.should_receive(:find).with(42).and_return(name)
-          default.block.call(name).should eql(:model)
+          default.block.call(name, {}).should eql(:model)
         end
       end
 
@@ -182,7 +182,7 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
 
         it "attempts to find a model instance based off the given name" do
           Model.should_receive(:find).with(42).and_return(name)
-          default.block.call(name).should eql(:model)
+          default.block.call(name, {}).should eql(:model)
         end
       end
 
@@ -191,7 +191,7 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
 
         it "attempts to find a model instance based off the given name" do
           Model.should_receive(:find).with(42).and_return(name)
-          default.block.call(name).should eql(:model)
+          default.block.call(name, {}).should eql(:model)
         end
       end
 
@@ -204,7 +204,7 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
         end
 
         context "the model instance" do
-        subject { default.block.call(name) }
+        subject { default.block.call(name, {}) }
           its(:age)   { should be(27) }
           its(:color) { should eql('blue') }
         end
@@ -219,7 +219,7 @@ describe BasicAssumption::DefaultAssumption::RestfulRails do
         end
 
         context "the model instance" do
-        subject { default.block.call(name) }
+        subject { default.block.call(name, {}) }
           its(:age)   { should be(27) }
           its(:color) { should eql('blue') }
         end

data/spec/lib/basic_assumption_spec.rb

@@ -51,6 +51,16 @@ describe BasicAssumption do
           end
         end
 
+        context "when an arbitrary context hash is passed to #assume" do
+          it "passes the hash to the evaluated block" do
+            extender_class.class_eval do
+              default_assumption { |name, context| context}
+              assume :has_context, :with => :foo, :and => :bar
+            end
+            extender_instance.has_context.should == {:with => :foo, :and => :bar}
+          end
+        end
+
         context "when the default is overridden" do
           it "returns the result of the overriding block" do
             extender_class.class_eval do
@@ -70,7 +80,7 @@ describe BasicAssumption do
 
           it "passes the name into the default block" do
             extender_class.class_eval do
-              default_assumption { |name| name }
+              default_assumption { |name, context| name }
               assume(:given_name)
             end
             extender_instance.given_name.should eql(:given_name)
@@ -152,7 +162,7 @@ describe BasicAssumption do
 
       before(:all) do
         application_controller.class_eval do
-          default_assumption { |name| "#{name}#{name}" }
+          default_assumption { |name, context| "#{name}#{name}" }
         end
       end
 

data/spec/spec_helper.rb

@@ -1 +1,3 @@
+require 'bundler'
+Bundler.setup
 require 'basic_assumption'

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: basic_assumption
 version: !ruby/object:Gem::Version 
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 11
-  version: 0.3.11
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Matt Yoho
@@ -14,51 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-28 00:00:00 -05:00
+date: 2010-07-16 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: bundler
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 15
         segments: 
-        - 1
-        - 3
         - 0
-        version: 1.3.0
+        - 9
+        - 26
+        version: 0.9.26
   type: :development
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: actionpack
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 3
-        - 5
-        version: 2.3.5
-  type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 3
-        - 5
-        version: 2.3.5
-  type: :development
-  version_requirements: *id003
 description: "\n    Allows a simple declarative idiom for accessing resources in controllers and views\n    via a well-defined interface that increases testability and reduces shared state.\n    "
 email: mby@mattyoho.com
 executables: []
@@ -82,8 +57,18 @@ files:
 - lib/basic_assumption/default_assumption/rails.rb
 - lib/basic_assumption/default_assumption/restful_rails.rb
 - lib/basic_assumption/rails.rb
+- lib/basic_assumption/rspec.rb
 - lib/basic_assumption/version.rb
 - rails/init.rb
+- spec/spec_helper.rb
+- spec/lib/basic_assumption_spec.rb
+- spec/lib/basic_assumption/configuration_spec.rb
+- spec/lib/basic_assumption/default_assumption_spec.rb
+- 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/rails_spec.rb
+- spec/lib/basic_assumption/default_assumption/restful_rails_spec.rb
 has_rdoc: true
 homepage: http://github.com/mattyoho/basic_assumption
 licenses: []
@@ -94,23 +79,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Allows a simple declarative idiom for accessing resources in controllers and views, cleaning up controller code and removing the need to explicitly reference instance variables inside views. Custom default behavior can be defined in a pluggable manner.