basic_assumption 0.2.3 → 0.3.0

data/lib/basic_assumption.rb

@@ -1,14 +1,10 @@
 require 'basic_assumption/configuration'
+require 'basic_assumption/default_assumption'
 
 module BasicAssumption
-  def self.extended(base)
-    base.default_assumption {}
-  end
-
-  def default_assumption(&block)
-    define_method(:default_assumption) do
-      block
-    end
+  def default_assumption(symbol=nil, &block)
+    default = block_given? ? block : symbol
+    BasicAssumption::DefaultAssumption.register(self, default)
   end
 
   def assume(name, &block)
@@ -17,7 +13,8 @@ module BasicAssumption
       @basic_assumptions[name] ||= if block_given?
         instance_eval(&block)
       else
-        instance_exec(name, &default_assumption)
+        block = BasicAssumption::DefaultAssumption.resolve(self.class)
+        instance_exec(name, &block)
       end
     end
     after_assumption(name)

data/lib/basic_assumption/configuration.rb

@@ -10,5 +10,9 @@ module BasicAssumption
         alias default_exposure default_assumption
       end
     end
+
+    def default_assumption=(value)
+      BasicAssumption::DefaultAssumption.default = value
+    end
   end
 end

data/lib/basic_assumption/default_assumption.rb

@@ -0,0 +1,38 @@
+require 'basic_assumption/default_assumption/base'
+require 'basic_assumption/default_assumption/class_resolver'
+
+module BasicAssumption
+  module DefaultAssumption
+    def self.register(klass, default)
+      registry[klass.object_id] = strategy(default)
+    end
+
+    def self.resolve(klass)
+      while !registry.has_key?(klass.object_id)
+        klass = klass.superclass
+        break if klass.nil?
+      end
+      registry[klass.object_id]
+    end
+
+    class << self
+      attr_accessor :default
+
+      protected
+      def registry
+        @registry ||= Hash.new { |h, k| strategy(default) }
+      end
+
+      def strategy(given=nil)
+        case given
+        when Proc
+          given
+        when Symbol
+          ClassResolver.instance(given).block
+        else
+          Base.new.block
+        end
+      end
+    end
+  end
+end

data/lib/basic_assumption/default_assumption/base.rb

@@ -0,0 +1,10 @@
+module BasicAssumption
+  module DefaultAssumption
+    class Base
+      def block
+        Proc.new { |name| }
+      end
+    end
+  end
+end
+

data/lib/basic_assumption/default_assumption/class_resolver.rb

@@ -0,0 +1,23 @@
+module BasicAssumption
+  module DefaultAssumption
+    class ClassResolver
+      def self.instance(name, *args)
+        new(name).instance(*args)
+      end
+      def initialize(name)
+        @name = name
+      end
+      def instance(*args)
+        constantize(camelize(@name)).new(*args)
+      end
+      def camelize(name)
+        name.to_s.gsub(/(?:^|_)(.)/) { "#{$1.upcase}" }
+      end
+      def constantize(name)
+        namespace = BasicAssumption::DefaultAssumption
+        namespace.const_missing(name) unless namespace.const_defined? name
+        namespace.const_get(name)
+      end
+    end
+  end
+end

data/lib/basic_assumption/default_assumption/rails.rb

@@ -0,0 +1,2 @@
+require 'basic_assumption/default_assumption/simple_rails'
+

data/lib/basic_assumption/default_assumption/simple_rails.rb

@@ -0,0 +1,13 @@
+module BasicAssumption
+  module DefaultAssumption
+    class SimpleRails < BasicAssumption::DefaultAssumption::Base
+      def block
+        Proc.new do |name|
+          model_class = name.to_s.classify.constantize
+          model_class.find(params["#{name}_id"] || params['id'])
+        end
+      end
+    end
+  end
+end
+

data/lib/basic_assumption/rails.rb

@@ -0,0 +1,23 @@
+if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  require 'basic_assumption/default_assumption/rails'
+
+  module BasicAssumption
+    class Railtie < Rails::Railtie
+
+      initializer "basic_assumption.set_up_action_controller_base" do |app|
+        ActionController::Base.class_eval do
+          extend BasicAssumption
+
+          def self.after_assumption(name)
+            hide_action name
+            helper_method name
+          end
+        end
+
+        BasicAssumption::Configuration.configure do |config|
+          config.default_assumption = :simple_rails
+        end
+      end
+    end
+  end
+end

data/lib/basic_assumption/version.rb

@@ -0,0 +1,3 @@
+module BasicAssumption
+  VERSION = '0.3.0'
+end

data/rails/init.rb

@@ -1,8 +1,5 @@
-begin
-  require File.join(File.dirname(__FILE__), 'lib', 'basic_assumption')
-rescue LoadError
-  require 'basic_assumption'
-end
+require 'basic_assumption'
+require 'basic_assumption/default_assumption/rails'
 
 ActionController::Base.class_eval do
   extend BasicAssumption
@@ -11,9 +8,8 @@ ActionController::Base.class_eval do
     hide_action name
     helper_method name
   end
+end
 
-  default_assumption do |name|
-    model_class = name.to_s.classify.constantize
-    model_class.find(params["#{name}_id"] || params['id'])
-  end
+BasicAssumption::Configuration.configure do |config|
+  config.default_assumption = :simple_rails
 end

data/spec/lib/basic_assumption/configuration_spec.rb

@@ -8,14 +8,26 @@ describe BasicAssumption::Configuration do
   end
 
   context "an instance" do
-    class Exposer
+    class Assumer
       extend BasicAssumption
     end
-    let(:instance) { BasicAssumption::Configuration.new }
-    let(:exposing_class) { Exposer }
+    let(:config) { BasicAssumption::Configuration.new }
+    let(:assuming_class) { Class.new Assumer }
     it "allows decent_exposure emulation mode" do
-      instance.emulate_exposure!
-      exposing_class.should respond_to(:expose)
+      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/base_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'active_support'
+
+describe BasicAssumption::DefaultAssumption::Base do
+  context "#block.call" do
+    subject { BasicAssumption::DefaultAssumption::Base.new.block.call(:name) }
+    it { should be_nil }
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'basic_assumption/default_assumption/class_resolver'
+
+class ::ExampleClass
+  attr_reader :foo, :bar
+  def initialize(foo=nil, bar=nil)
+    @foo = foo; @bar = bar
+  end
+end
+
+describe BasicAssumption::DefaultAssumption::ClassResolver do
+  let(:resolver) { BasicAssumption::DefaultAssumption::ClassResolver.new(nil) }
+  context '#camelize, given a symbol or string' do
+    it 'returns an upper camel-cased string' do
+      resolver.camelize('camel').should eql('Camel')
+    end
+    it 'treats underscores as word boundaries and removes them' do
+      resolver.camelize('camel_case_word').should eql('CamelCaseWord')
+    end
+  end
+  context '#constantize' do
+    it 'retrieves a constant from the BasicAssumption::DefaultAssumption namespace' do
+      resolver.constantize('ClassResolver').should eql(BasicAssumption::DefaultAssumption::ClassResolver)
+    end
+    it 'raises an error if no such constant is found' do
+      expect { resolver.constantize('CamelCase') }.to raise_error(NameError)
+    end
+  end
+  context '#instance' do
+    before(:each) do
+      @resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:example_class)
+      @resolver.stub!(:constantize).and_return(ExampleClass)
+    end
+    it 'returns an instance of the resolved class' do
+      @resolver.instance.should be_a_kind_of(ExampleClass)
+    end
+    it 'accepts and passes on any arguments to the instantiation of the object' do
+      example_object = @resolver.instance('foo', 'bar')
+      example_object.foo.should eql('foo')
+      example_object.bar.should eql('bar')
+    end
+  end
+  context '::instance' do
+    it 'returns an instance of the resolved class' do
+      mod = BasicAssumption::DefaultAssumption
+      mod::ClassResolver.instance(:base).should be_an_instance_of(mod::Base)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'active_support'
+require 'basic_assumption/default_assumption/simple_rails'
+
+describe BasicAssumption::DefaultAssumption::SimpleRails do
+  class Model; end
+
+  context "#block" do
+    let(:default) { BasicAssumption::DefaultAssumption::SimpleRails.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] 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)
+    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
+end

data/spec/lib/basic_assumption/default_assumption_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'lib/basic_assumption/default_assumption/simple_rails'
+
+describe BasicAssumption::DefaultAssumption do
+  let(:mod) { BasicAssumption::DefaultAssumption }
+  describe "::register and ::resolve" do
+    it "maps an object to a proc according to an internal strategy" do
+      mod.should_receive(:strategy).with(:behavior).and_return(:block)
+      mod.register(Class, :behavior)
+      mod.resolve(Class).should eql(:block)
+    end
+  end
+  describe "::strategy" do
+    it "returns the proc when given one" do
+      a_proc = Proc.new { :block }
+      mod.send(:strategy, a_proc).call.should eql(:block)
+    end
+    it "returns the block of a class in the BasicAssumption::DefaultAssumption namespace when given a symbol" do
+      mod::SimpleRails.should_receive(:new).and_return(stub(:block => :block))
+      mod.send(:strategy, :simple_rails).should eql(:block)
+    end
+    it "returns the block of a Base instance otherwise" do
+      mod.send(:strategy, nil).call.should be_nil
+    end
+  end
+  describe "::registry" do
+    before(:each) do
+      mod.send(:registry).clear
+    end
+    it "returns a default when given a key it doesn't have" do
+      mod.default = :custom_default
+      mod.stub!(:strategy).with(:custom_default).and_return(:some_block)
+      mod.send(:registry).should_not have_key(:key)
+      mod.send(:registry)[:key].should eql(:some_block)
+    end
+    after(:each) do
+      mod.default = nil
+    end
+  end
+end

data/spec/lib/basic_assumption_spec.rb

@@ -120,7 +120,7 @@ describe BasicAssumption do
       end
     end
 
-    context "classes derived from ActionController::Base" do
+    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 }
@@ -131,7 +131,7 @@ describe BasicAssumption do
         end
       end
 
-      it "inherit the default assumption" do
+      it "inherits the default assumption" do
         derived_class.class_eval do
           assume(:twice)
         end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
   - 3
-  version: 0.2.3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Matt Yoho
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-17 00:00:00 -05:00
+date: 2010-05-12 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -69,9 +69,15 @@ extra_rdoc_files:
 - README.md
 files: 
 - README.md
-- VERSION
 - lib/basic_assumption.rb
 - lib/basic_assumption/configuration.rb
+- lib/basic_assumption/default_assumption.rb
+- lib/basic_assumption/default_assumption/base.rb
+- lib/basic_assumption/default_assumption/class_resolver.rb
+- lib/basic_assumption/default_assumption/rails.rb
+- lib/basic_assumption/default_assumption/simple_rails.rb
+- lib/basic_assumption/rails.rb
+- lib/basic_assumption/version.rb
 - rails/init.rb
 has_rdoc: true
 homepage: http://github.com/mattyoho/basic_assumption
@@ -102,8 +108,12 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Allows a simple declarative idiom for resources in controllers and views
+summary: Allows a simple declarative idiom for resources in controllers and 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/class_resolver_spec.rb
+- spec/lib/basic_assumption/default_assumption/simple_rails_spec.rb

data/VERSION

@@ -1 +0,0 @@
-0.2.3