basic_assumption 0.5.1 → 0.5.2

data/lib/basic_assumption/version.rb

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

data/spec/basic_assumption/default_assumption/class_resolver_spec.rb

@@ -1,49 +1,65 @@
 require 'spec_helper'
 require 'basic_assumption/default_assumption/class_resolver'
 
-class ::ExampleClass
+class BasicAssumption::DefaultAssumption::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
+module Foo
+  class ExampleClass
   end
-  context '#constantize' do
-    it 'retrieves a constant from the BasicAssumption::DefaultAssumption namespace' do
-      resolver.constantize('ClassResolver').should eql(BasicAssumption::DefaultAssumption::ClassResolver)
+end
+
+class TopLevelExampleClass
+end
+
+describe BasicAssumption::DefaultAssumption::ClassResolver do
+
+  context '#klass' do
+    it 'returns a class from the BasicAssumption::DefaultAssumption namespace' do
+      resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:example_class, 'BasicAssumption::DefaultAssumption')
+      resolver.klass.should equal(BasicAssumption::DefaultAssumption::ExampleClass)
     end
-    it 'raises an error if no such constant is found' do
-      expect { resolver.constantize('CamelCase') }.to raise_error(NameError)
+
+    context "specifying a namespace" do
+      it 'returns a class from that namespace' do
+        resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:example_class, 'Foo')
+        resolver.klass.should equal(Foo::ExampleClass)
+      end
+
+      it 'returns a class from the top-level namespace by default' do
+        resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:top_level_example_class)
+        resolver.klass.should equal(TopLevelExampleClass)
+      end
     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)
+
+    it 'returns a class instance from the BasicAssumption::DefaultAssumption namespace' do
+      resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:example_class, 'BasicAssumption::DefaultAssumption')
+      resolver.instance.should be_a_kind_of(BasicAssumption::DefaultAssumption::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')
+
+    it 'raises an error if no such constant is found' do
+      resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:no_such_class)
+      expect { resolver.instance }.to raise_error(NameError)
     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)
+
+    context "specifying a namespace" do
+      it 'returns a class instance from that namespace' do
+        resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:example_class, 'Foo')
+        resolver.instance.should be_a_kind_of(Foo::ExampleClass)
+      end
+
+      it 'returns a class instance from the top-level namespace' do
+        resolver = BasicAssumption::DefaultAssumption::ClassResolver.new(:top_level_example_class)
+        resolver.instance.should be_a_kind_of(TopLevelExampleClass)
+      end
     end
   end
 end

data/spec/basic_assumption/default_assumption/rails_spec.rb

@@ -2,45 +2,202 @@ require 'spec_helper'
 require 'active_support'
 require 'basic_assumption/default_assumption/rails'
 
-class Model; end
+class Model
+  attr_accessor :age, :color, :owner_id
+  def initialize(hash = {})
+    hash.each do |k, v|
+      self.send("#{k}=", v)
+    end
+  end
+end
 
 describe BasicAssumption::DefaultAssumption::Rails do
 
+  let(:default) { BasicAssumption::DefaultAssumption::Rails.new(:model, {}, request) }
+  let(:request) { stub(:params => params, :get? => true) }
+  let(:params)  { {'id' => 42} }
+
   context "#block" do
-    let(:default) { BasicAssumption::DefaultAssumption::Rails.new }
-    let(:params)  { stub(:[] => 42) }
+    let(:relation) { stub("where", :find => nil)  }
 
     before(:each) do
-      Model.stub!(:find)
-      default.stub!(:params).and_return(params)
+      Model.stub!(:where).and_return(relation)
     end
 
-    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})
+    it "attempts to find a model instance based off the given name" do
+      relation.should_receive(:find).with(42).and_return(:model)
+      BasicAssumption::DefaultAssumption::Rails.new(:model, {}, request).result.should eql(:model)
+    end
+
+    context "when passed an alternative model name" do
+      it "finds a model instance based off the alternative name" do
+        relation.should_receive(:find).with(42).and_return(:model)
+        BasicAssumption::DefaultAssumption::Rails.new(:my_model, {:as => :model}, request).result.should eql(:model)
       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})
+    context "when the name given to assume is plural" do
+      let(:name) { :models }
+
+      %w(create destroy edit index new show update).each do |action|
+        let(:params) { {'action' => action} }
+
+        context "when action is #{action}" do
+          it "finds all the records of the model class" do
+            Model.should_receive(:where)
+            default.block.call(name, {})
+          end
+        end
       end
+
     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)
+    context "when the name given to assume is singular" do
+      let(:name) { :model }
+
+      context "in the index action" do
+        let(:params)  { { 'action' => 'index' } }
+
+        before { params['model'] = {:initializer => 'value'} }
+        it "creates a new model instance and passes in appropriate params" do
+          Model.should_receive(:new).with({:initializer => 'value'}).and_return(name)
+          default.block.call(name, {}).should eql(name)
+        end
+      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
+          relation.should_receive(:find).with(42).and_return(name)
+          default.block.call(name, {}).should eql(:model)
+        end
+      end
+
+      context "in the edit action" do
+        let(:params) { { 'id' => 42, 'action' => 'edit' } }
+        let(:model)  { stub("model", :attributes= => {}) }
+
+        before { relation.should_receive(:find).with(42).and_return(model) }
+
+        it "attempts to find a model instance based off the given name" do
+          default.block.call(name, {}).should eql(model)
+        end
+
+        it "sets the updated attributes" do
+          model.should_receive(:attributes=).once
+          default.block.call(name, {})
+        end
+      end
+
+      context "in the update action" do
+        let(:params) { {'id' => 42, 'action' => 'update'} }
+        let(:model)  { stub("model", :attributes= => {}) }
+
+        before { relation.should_receive(:find).with(42).and_return(model) }
+
+        it "attempts to find a model instance based off the given name" do
+          default.block.call(name, {}).should eql(model)
+        end
+
+        it "sets the updated attributes" do
+          model.should_receive(:attributes=).once
+          default.block.call(name, {})
+        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
+          relation.should_receive(:find).with(42).and_return(name)
+          default.block.call(name, {}).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(name, {}) }
+          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(name, {}) }
+          its(:age)   { should be(27) }
+          its(:color) { should eql('blue') }
+        end
+      end
     end
+  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)
+  context "ensuring ownership" do
+    class User
+      def id
+        5678
+      end
+    end
+
+    class Controller
+      def owner
+        User.new
+      end
+    end
+
+    let(:params) { {'id' => 123} }
+
+    it "accepts a symbol" do
+      Model.should_receive(:where).with(:user_id => 5678).and_return(stub(:find => nil))
+
+      default = BasicAssumption::DefaultAssumption::Rails.new(:model, {:owner => :owner, :controller => Controller.new}, request)
+
+      default.result
+    end
+
+    it "accepts a proc" do
+      Model.should_receive(:where).with(:user_id => 5678).and_return(stub(:find => nil))
+
+      default = BasicAssumption::DefaultAssumption::Rails.new(:model, {:owner => proc { owner }, :controller => Controller.new}, request)
+
+      default.result
+    end
+
+    context "with a specified column name" do
+
+      it "obeys the column name" do
+        Model.should_receive(:where).with(:user_id => 5678).and_return(stub(:find => nil))
+
+        owner_context = {:column_name => :user_id, :object => proc { owner }}
+        default = BasicAssumption::DefaultAssumption::Rails.new(:model, {:owner => owner_context, :controller => Controller.new}, request)
+
+        default.result
+      end
+
+      it "obeys the column name given a proc" do
+        Model.should_receive(:where).with(:owner_id => 5678).and_return(stub(:find => nil))
+
+        owner_context = {:column_name => :owner_id, :object => :owner}
+        default = BasicAssumption::DefaultAssumption::Rails.new(:model, {:owner => owner_context, :controller => Controller.new}, request)
+
+        default.result
       end
     end
   end
+
 end

data/spec/basic_assumption_spec.rb

@@ -185,9 +185,11 @@ describe BasicAssumption do
         controller_class.class_eval do
           assume(:model)
         end
-        controller_instance.stub(:params => {'model_id' => 123})
-        ::Model.should_receive(:find).with(123)
-        controller_instance.model.should be_a_kind_of(Object)
+        controller_instance.stub(:request => stub(:params => {'id' => 123}, :get? => true))
+        relation = stub("where")
+        relation.should_receive(:find).with(123)
+        ::Model.stub(:where => relation)
+        controller_instance.model
       end
     end
   end

metadata

@@ -1,30 +1,40 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: basic_assumption
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.5.1
+version: !ruby/object:Gem::Version
+  version: 0.5.2
 platform: ruby
-authors: 
+authors:
 - Matt Yoho
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-10-05 00:00:00 -04:00
-default_executable: 
-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    "
+date: 2015-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+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: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - HISTORY.rdoc
 - MIT-LICENSE
 - README.rdoc
-files: 
+files:
 - HISTORY.rdoc
 - MIT-LICENSE
 - README.rdoc
@@ -32,51 +42,51 @@ files:
 - lib/basic_assumption/configuration.rb
 - lib/basic_assumption/configuration/active_record.rb
 - lib/basic_assumption/default_assumption.rb
+- lib/basic_assumption/default_assumption/action.rb
 - lib/basic_assumption/default_assumption/base.rb
 - lib/basic_assumption/default_assumption/class_resolver.rb
+- lib/basic_assumption/default_assumption/name.rb
+- lib/basic_assumption/default_assumption/owner_attributes.rb
 - 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/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
+- spec/basic_assumption/default_assumption_spec.rb
+- spec/basic_assumption_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/mattyoho/basic_assumption
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 2.2.3
 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: 
+specification_version: 4
+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/basic_assumption_spec.rb
 - spec/basic_assumption/configuration_spec.rb
@@ -84,4 +94,3 @@ test_files:
 - 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