basic_assumption 0.4.1 → 0.5.1

data/HISTORY.rdoc

@@ -1,3 +1,16 @@
+== 0.5.1 / 2011-10-05
+* Bug Fix
+  * Included missing file in gem package
+== 0.5.0 / 2011-10-04 - YANKED, incorrectly published as 5.0.0
+* Feature Change
+  * Default Rails assumption is now "cautious"; use find_on_id and/or raise_error for previous behavior
+  * emulate_exposure! has been removed and replaced by alias_assume_to, which only partially stands in
+* Bug Fix
+  * Assumptions can be overridden by nil (such as within a controller action)
+  * Reloading classes that include BasicAssumption (a la Rails controllers in dev mode) doesn't cause a leak
+== 0.4.1 / 2010-07-16
+* Feature Change
+  * No longer necessary to require 'basic_assumption/rails' in Gemfile
 == 0.4.0 / 2010-07-16
 * Feature Addition
   * Add simple rspec matcher

data/README.rdoc

@@ -1,21 +1,9 @@
 == BasicAssumption
 
 BasicAssumption is a gem that lets you declare resources inside of a class
-in a concise manner. It is meant to make Rails controllers and views cleaner.
-
-It is a clone of DecentExposure that adds a psuedo-modular interface for
-providing custom defaults and some useful defaults out of the box.
-
-=== What is DecentExposure?
-
-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].
-
-DecentExposure coins an idiom for writing certain kinds of code in a declarative
-way. Particularly for your Rails apps, it's worth checking out. BasicAssumption
-is another implementation of the idiom. Check the BasicAssumption::Configuration
-options for enabling compatibility with the DecentExposure API.
+in a concise manner.  It implements an idiom for writing certain kinds of code
+in a declarative way. In particular, it's meant to make Rails controllers and
+views cleaner.
 
 == Install BasicAssumption
 
@@ -31,12 +19,7 @@ For Rails 2, in environment.rb:
 
 For Rails 3, in your Gemfile:
 
-    gem 'basic_assumption', :require => ['basic_assumption', 'basic_assumption/rails']
-
-It's possible to use BasicAssumption in your Rails 3 app without requiring
-'basic_assumption/rails', and will in fact allow more flexibility if you don't,
-but will incur the cost of additional setup. See the file
-'lib/basic_assumption/rails.rb' for guidance.
+    gem 'basic_assumption'
 
 To use the library in another context, it is enough to extend the
 BasicAssumption module inside the class you would like it available.
@@ -148,7 +131,7 @@ For example, this:
 
       protected
       def find_record
-        @record = Record.find(params[:record_id] || params[:id])
+        @record = Record.find(params[:record_id])
       end
     end
 
@@ -231,7 +214,7 @@ 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}
+      named_scope :shiny, where(:glossy => true)
     end
 
     class WidgetController < ActionController::Base
@@ -255,15 +238,22 @@ following two constructs would be equivalent in your controllers:
     # The above line is exactly the same as:
     assume :film
 
-Please see +Rails+ for implementation details . Because finding on :id
-could be considered dangerous, there is another default available for use,
-+CautiousRails+, that will only find on :name_id. (In the example above,
-this would be :film_id.) Enable that for one of your controllers like so:
+Please see +Rails+ for implementation details. Though it could be considered
+a bit more dangerous to do, this standard Rails default will accept an option
+:find_on_id, that will find on params[:id] as well as params[:name_id].
+Enable that for one of your controllers like so:
 
     class FilmController < ActionController::Base
-      default_assumption :cautious_rails
+      assume :film, :find_on_id => true
     end
 
+It's also possible to have this behavior turned on by default via a
+configuration setting, which may be convenient for backwards compatibility
+with versions of BasicAssumption prior to 0.5.0. Similarly, there is a
+raise_error setting that will cause any errors that result from the attempt
+to find the record to bubble up; otherwise, they will be swallowed and the
+assumption method will return nil.
+
 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.
@@ -324,9 +314,16 @@ implications of evaluating the +Proc+ returned by +block+ using +instance_eval+
 
 There are a couple of configuration settings that can be set inside of
 a configuration block that can be used in places such as Rails initializer
-blocks. #emulate_exposure! will alias +assume+ and +default_assumption+ to
-+expose+ and +default_exposure+, respectively. You can also set the app-wide
-default behavior. For more information, see BasicAssumption::Configuration.
+blocks. #alias_assume_to will alias +assume+ to other names. The example
+below would alias it to +expose+ and +reveal+.  You can also set the
+app-wide default behavior. For more information, see
+BasicAssumption::Configuration.
+
+    BasicAssumption::Configuration.configure do |conf|
+      conf.default_assumption = Proc.new { "I <3 GitHub." }
+
+      conf.alias_assume_to :expose, :reveal
+    end
 
 == Issues to note
 
@@ -366,11 +363,18 @@ gemset if you're using RVM, which will help to manage the gem dependencies.
 The test suites are dependent on the Bundler gem. Ensure that it is installed
 with:
 
-    gem install bundler
+    gem install bundler --version="~> 1.0.3"
+
+It is highly recommended to use RVM to manage development BasicAssumption against
+various Rails and Ruby versions. Run the following command to create an
+appropriate RVM gemset and receive a command to run manually that selects that
+gemset:
+
+    rake rvm:gemset
 
 To run the Cucumber and spec suites for the first time, use these Rake tasks:
 
-    rake init
+    rake init:rails2 #or rake init:rails3
     rake
 
 Note that the +init+ task will +bundle+ +install+ the development dependencies,
@@ -385,9 +389,9 @@ Feel free to fork away and send back pull requests, including specs! Thanks.
 == But should I use it?
 
 Sure! Absolutely. I think it's a cool idea that lets you cut down on line
-noise, particularly in your Rails controllers. You may want to consider going
-with {DecentExposure}[http://github.com/voxdolo/decent_exposure] instead, simply
-because it's used by much of {Hashrocket}[http://www.hashrocket.com/].
-But so far as I know, BasicAssumption is pretty solid. Feel free to let me know
+noise, particularly in your Rails controllers. You may also want to look at
+{DecentExposure}[http://github.com/voxdolo/decent_exposure], the
+project BasicAssumption is based on, written by {Stephen Caudill}[http://voxdolo.me/]
+of {Hashrocket}[http://www.hashrocket.com/]. Feel free to let me know
 if you use it! Email mby [at] mattyoho [dot] com with questions, comments, or
 non-sequiters.

data/lib/basic_assumption.rb

@@ -64,13 +64,16 @@ module BasicAssumption
   def assume(name, context={}, &block)
     define_method(name) do
       @basic_assumptions       ||= {}
-      @basic_assumptions[name] ||= if block_given?
-        instance_eval(&block)
-      else
-        which = context.delete(:using) || self.class
-        block = DefaultAssumption.resolve(which)
-        instance_exec(name, context, &block)
+      unless @basic_assumptions.key?(name)
+        @basic_assumptions[name] = if block_given?
+          instance_eval(&block)
+        else
+          which = context.delete(:using) || self.class
+          block = DefaultAssumption.resolve(which)
+          instance_exec(name, context, &block)
+        end
       end
+      @basic_assumptions[name]
     end
     define_method("#{name}=") do |value|
       @basic_assumptions       ||= {}

data/lib/basic_assumption/configuration.rb

@@ -1,3 +1,5 @@
+require 'basic_assumption/configuration/active_record'
+
 module BasicAssumption
   # Provides app-level configuration options for +BasicAssumption+.
   # Useful in a Rails initializer or something similar.
@@ -7,18 +9,24 @@ module BasicAssumption
     #     conf.default_assumption = Proc.new { "I <3 GitHub." }
     #   end
     def self.configure #:yields: config_instance
-      yield self.new
+      @configuration = self.new
+      yield @configuration
+    end
+
+    def self.settings
+      @configuration.active_record.settings_hash
+    end
+
+    attr_reader :active_record #:nodoc:
+
+    def initialize #:nodoc:
+      @active_record = self.class::ActiveRecord.new
     end
 
-    # Invoke this method if you want to have API compatibility
-    # with the DecentExposure library.
-    # (http://www.github.com/voxdolo/decent_exposure)
-    # Namely, this provides +expose+ and +default_exposure+ which work
-    # identically to +assume+ and +default_assumption+ (or rather, vice-versa.)
-    def emulate_exposure!
-      BasicAssumption.module_eval do
-        alias expose assume
-        alias default_exposure default_assumption
+    # Allows substituting another method name aside from +assume+
+    def alias_assume_to(*aliases)
+      aliases.each do |a|
+        BasicAssumption.module_eval "alias #{a} assume"
       end
     end
 

data/lib/basic_assumption/configuration/active_record.rb

@@ -0,0 +1,19 @@
+module BasicAssumption
+  class Configuration
+    class ActiveRecord #:nodoc:
+      SETTINGS = [:find_on_id, :raise_error]
+
+      SETTINGS.each do |setting|
+        attr_accessor setting
+      end
+
+      def settings_hash
+        SETTINGS.inject({}) do |hash, setting|
+          hash[setting] = self.send setting
+          hash
+        end
+      end
+    end
+  end
+end
+

data/lib/basic_assumption/default_assumption.rb

@@ -29,16 +29,17 @@ module BasicAssumption
   # behavior. See the +Rails+ class for an example.
   module DefaultAssumption
     def self.register(klass, default) #:nodoc:
-      registry[klass.object_id] = strategy(default)
+      registry[klass.name] = strategy(default)
     end
 
     def self.resolve(klass) #:nodoc:
       return strategy(klass) if klass.kind_of?(Symbol)
-      while !registry.has_key?(klass.object_id)
+      while !registry.has_key?(klass.name)
         klass = superclass(klass)
         break if klass.nil?
       end
-      registry[klass.object_id]
+      lookup = klass && klass.name
+      registry[lookup]
     end
 
     class << self

data/lib/basic_assumption/default_assumption/rails.rb

@@ -17,9 +17,36 @@ module BasicAssumption
       #   end
       #
       #   class WidgetController < ActionController::Base
-      #     assume(:widget) { Widget.find(params[:widget_id] || params[:id]) }
+      #     assume(:widget) { Widget.find(params[:widget_id]) rescue nil }
       #   end
       #
+      # The find can also fall back to using params[:id] when
+      # :find_on_id is specified. The following are equivalent:
+      #
+      #   class WidgetController < ActionController::Base
+      #     assume :widget, :find_on_id => true
+      #   end
+      #
+      #   class WidgetController < ActionController::Base
+      #     assume(:widget) { Widget.find(params[:widget_id] || params[:id]) rescue nil }
+      #   end
+      #
+      # The find will, by default, swallow errors encountered
+      # when finding. This can be overridden by setting :raise_error.
+      #
+      #   class WidgetController < ActionController::Base
+      #     assume :widget, :raise_error => true
+      #   end
+      #
+      #   class WidgetController < ActionController::Base
+      #     assume(:widget) { Widget.find(params[:widget_id]) }
+      #   end
+      #
+      # Both of these settings can be turned on by default via
+      # configuration options, such as:
+      #
+      #   conf.active_record.raise_error = true
+      #
       # It is possible to specify an alternative model name:
       #
       #   class WidgetController < ApplicationController
@@ -36,12 +63,21 @@ module BasicAssumption
       end
 
       def result #:nodoc:
-        model_class.find(lookup_id)
+        begin
+          model_class.find(lookup_id)
+        rescue
+          raise if settings[:raise_error]
+          nil
+        end
       end
 
       protected
       def lookup_id #:nodoc:
-        params["#{name}_id"] || params['id']
+        if settings[:find_on_id]
+          params["#{name}_id"] || params['id']
+        else
+          params["#{name}_id"]
+        end
       end
 
       def model_class #:nodoc:
@@ -51,6 +87,11 @@ module BasicAssumption
       def model_name #:nodoc:
         context[:as] ? context[:as].to_s : name
       end
+
+      def settings #:nodoc:
+        @global_settings ||= BasicAssumption::Configuration.settings
+        @global_settings.merge(context)
+      end
     end
   end
 end

data/lib/basic_assumption/rails.rb

@@ -1,5 +1,4 @@
 if defined?(Rails) && Rails::VERSION::MAJOR == 3
-  require 'basic_assumption/default_assumption/cautious_rails'
   require 'basic_assumption/default_assumption/rails'
   require 'basic_assumption/default_assumption/restful_rails'
 

data/lib/basic_assumption/version.rb

@@ -1,7 +1,7 @@
 module BasicAssumption
   module Version
     MAJOR  = 0
-    MINOR  = 4
+    MINOR  = 5
     POINT  = 1
     STRING = "#{MAJOR}.#{MINOR}.#{POINT}"
   end

data/spec/basic_assumption/configuration_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe BasicAssumption::Configuration do
+  it "provides a #configure class method that yields an instance of the class" do
+    configuration_instance = nil
+    BasicAssumption::Configuration.configure { |instance| configuration_instance = instance }
+    configuration_instance.should be_a_kind_of(BasicAssumption::Configuration)
+  end
+
+  describe ".settings" do
+    it "returns a hash of the current settings" do
+      BasicAssumption::Configuration.configure do |config|
+        config.active_record.raise_error = true
+      end
+
+      settings = BasicAssumption::Configuration.settings
+      settings.should have_key(:raise_error)
+      settings[:raise_error].should be_true
+    end
+  end
+
+  context "an instance" do
+    class Assumer
+      extend BasicAssumption
+    end
+    let(:config) { BasicAssumption::Configuration.new }
+    let(:assuming_class) { named_class_extending Assumer }
+
+    describe "#alias_assume_to" do
+      it "aliases the #assume method" do
+        config.alias_assume_to :expose, :provide
+        assuming_class.should respond_to(:expose)
+        assuming_class.should respond_to(:provide)
+      end
+    end
+
+    it "can set the default assumption" do
+      config.default_assumption = Proc.new { :qux }
+      assuming_class.class_eval do
+        assume :baz
+      end
+      assuming_class.new.baz.should eql(:qux)
+    end
+
+    context "active_record" do
+      it "has a raise_error setting" do
+        expect do
+          config.active_record.raise_error = true
+        end.to_not raise_error
+      end
+
+      it "has a find_on_id setting" do
+        expect do
+          config.active_record.find_on_id = true
+        end.to_not raise_error
+      end
+    end
+
+    after(:all) do
+      config.default_assumption = nil
+    end
+  end
+end

data/spec/{lib/basic_assumption → basic_assumption}/default_assumption/rails_spec.rb

@@ -15,10 +15,20 @@ describe BasicAssumption::DefaultAssumption::Rails do
       default.stub!(:params).and_return(params)
     end
 
-    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, {})
+    context "when context[:find_on_id] is true" 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, {:find_on_id => true})
+      end
+    end
+
+    context "when context[:find_on_id] is not true" do
+      it "looks for a params[model_id] in its calling context" do
+        params.should_receive(:[]).with('model_id').and_return(nil)
+        params.should_not_receive(:[]).with('id')
+        default.block.call(:model, {:find_on_id => nil})
+      end
     end
 
     it "attempts to find a model instance based off the given name" do

data/spec/{lib/basic_assumption_spec.rb → basic_assumption_spec.rb}

@@ -11,7 +11,7 @@ describe BasicAssumption do
 
   context "when a class extends BasicAssumption" do
 
-    let(:extender_class) { Class.new(Extender) }
+    let(:extender_class)    { named_class_extending Extender }
     let(:extender_instance) { extender_class.new }
     before(:each) do
       extender_class.extend(BasicAssumption)
@@ -125,14 +125,19 @@ describe BasicAssumption do
         extender_instance.writeable = 'overwritten'
         extender_instance.writeable.should eql('overwritten')
       end
+
+      it "overrides the value returned by the created instance method with nil" do
+        extender_instance.writeable = nil
+        extender_instance.writeable.should be_nil
+      end
     end
   end
 
   context "within Rails" do
     before(:all) do
-      require File.expand_path(File.dirname(__FILE__) + '/../../rails/init.rb')
+      require File.expand_path(File.dirname(__FILE__) + '/../rails/init.rb')
     end
-    let(:controller_class) { Class.new(::ActionController::Base) }
+    let(:controller_class)    { named_class_extending(::ActionController::Base) }
     let(:controller_instance) { controller_class.new }
 
     it "is extended by ActionController::Base" do
@@ -156,9 +161,9 @@ describe BasicAssumption do
     end
 
     context "classes in the inheritance chain of ActionController::Base" do
-      let(:application_controller) { Class.new(controller_class) }
-      let(:derived_class) { Class.new(application_controller) }
-      let(:derived_instance) { derived_class.new }
+      let(:application_controller) { named_class_extending controller_class }
+      let(:derived_class)          { named_class_extending application_controller }
+      let(:derived_instance)       { derived_class.new }
 
       before(:all) do
         application_controller.class_eval do
@@ -180,7 +185,7 @@ describe BasicAssumption do
         controller_class.class_eval do
           assume(:model)
         end
-        controller_instance.stub(:params => {'id' => 123})
+        controller_instance.stub(:params => {'model_id' => 123})
         ::Model.should_receive(:find).with(123)
         controller_instance.model.should be_a_kind_of(Object)
       end

data/spec/spec_helper.rb

@@ -1,3 +1,25 @@
 require 'bundler'
 Bundler.setup
 require 'basic_assumption'
+
+module SubclassContainer
+  def next_subclass_id
+    @subclass_count ||= 0
+    @subclass_count +=  1
+  end
+  extend self
+end
+
+module BasicAssumptionSpecHelpers
+  def named_class_extending(base)
+    extender = Class.new(base)
+    subclass_name = "Subclass_#{SubclassContainer.next_subclass_id}_#{base.name.gsub(/:+/, '_')}"
+    SubclassContainer.const_set subclass_name, extender
+  end
+end
+
+RSpec.configure do |config|
+  config.include(BasicAssumptionSpecHelpers)
+
+  config.mock_with :rspec
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: basic_assumption
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 4
-  - 1
-  version: 0.4.1
+  prerelease: 
+  version: 0.5.1
 platform: ruby
 authors: 
 - Matt Yoho
@@ -14,23 +10,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-28 00:00:00 -04:00
+date: 2011-10-05 00:00:00 -04:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: bundler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 9
-        - 26
-        version: 0.9.26
-  type: :development
-  version_requirements: *id001
+dependencies: []
+
 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: []
@@ -47,9 +30,9 @@ files:
 - README.rdoc
 - lib/basic_assumption.rb
 - lib/basic_assumption/configuration.rb
+- lib/basic_assumption/configuration/active_record.rb
 - lib/basic_assumption/default_assumption.rb
 - lib/basic_assumption/default_assumption/base.rb
-- 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
@@ -57,6 +40,14 @@ files:
 - lib/basic_assumption/rspec.rb
 - lib/basic_assumption/version.rb
 - rails/init.rb
+- spec/spec_helper.rb
+- spec/basic_assumption_spec.rb
+- spec/basic_assumption/configuration_spec.rb
+- spec/basic_assumption/default_assumption_spec.rb
+- spec/basic_assumption/default_assumption/base_spec.rb
+- spec/basic_assumption/default_assumption/class_resolver_spec.rb
+- spec/basic_assumption/default_assumption/rails_spec.rb
+- spec/basic_assumption/default_assumption/restful_rails_spec.rb
 has_rdoc: true
 homepage: http://github.com/mattyoho/basic_assumption
 licenses: []
@@ -67,33 +58,30 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.6.2
 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.
 test_files: 
 - 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
+- spec/basic_assumption_spec.rb
+- spec/basic_assumption/configuration_spec.rb
+- spec/basic_assumption/default_assumption_spec.rb
+- spec/basic_assumption/default_assumption/base_spec.rb
+- spec/basic_assumption/default_assumption/class_resolver_spec.rb
+- spec/basic_assumption/default_assumption/rails_spec.rb
+- spec/basic_assumption/default_assumption/restful_rails_spec.rb

data/lib/basic_assumption/default_assumption/cautious_rails.rb

@@ -1,40 +0,0 @@
-require 'basic_assumption/default_assumption/rails'
-
-module BasicAssumption
-  module DefaultAssumption
-    # Custom default behavior in the context of Rails.
-    class CautiousRails < BasicAssumption::DefaultAssumption::Rails
-      # Returns a block that will attempt to find an instance of
-      # an ActiveRecord model based on the name that was given to
-      # BasicAssumption#assume and an id value in the parameters.
-      # It will not find based on params[:id], only params[:model_id].
-      # The following two examples would be equivalent:
-      #
-      #   class WidgetController < ActionController::Base
-      #     assume :widget
-      #   end
-      #
-      #   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
-
-      protected
-      def lookup_id #:nodoc:
-        params["#{name}_id"]
-      end
-    end
-  end
-end
-

data/spec/lib/basic_assumption/configuration_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe BasicAssumption::Configuration do
-  it "provides a #configure class method that yields an instance of the class" do
-    configuration_instance = nil
-    BasicAssumption::Configuration.configure { |instance| configuration_instance = instance }
-    configuration_instance.should be_a_kind_of(BasicAssumption::Configuration)
-  end
-
-  context "an instance" do
-    class Assumer
-      extend BasicAssumption
-    end
-    let(:config) { BasicAssumption::Configuration.new }
-    let(:assuming_class) { Class.new Assumer }
-    it "allows decent_exposure emulation mode" do
-      config.emulate_exposure!
-      assuming_class.should respond_to(:expose)
-    end
-
-    it "can set the default assumption" do
-      config.default_assumption = Proc.new { :qux }
-      assuming_class.class_eval do
-        assume :baz
-      end
-      assuming_class.new.baz.should eql(:qux)
-    end
-
-    after(:all) do
-      config.default_assumption = nil
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-require 'active_support'
-require 'basic_assumption/default_assumption/cautious_rails'
-
-class Model; end
-
-describe BasicAssumption::DefaultAssumption::CautiousRails do
-
-  context "#block" do
-    let(:default) { BasicAssumption::DefaultAssumption::CautiousRails.new }
-    let(:params)  { stub(:[] => 42) }
-
-    before(:each) do
-      Model.stub!(:find)
-      default.stub!(:params).and_return(params)
-    end
-
-    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, {})
-    end
-
-    it "does not look for params[id] in its calling context" do
-      params.should_receive(:[]).with('id').never
-      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)
-    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