decent_exposure 0.2.4 → 1.0.0.rc1

data/README.md

@@ -22,11 +22,11 @@ In `config/environment.rb`:
 
     config.gem 'decent_exposure'
 
-When used in Rails 3, you must require the Railtie initializer:
+When used in Rails 3:
 
 In `Gemfile`:
 
-    gem 'decent_exposure', :require => ['decent_exposure', 'decent_exposure/railtie']
+    gem 'decent_exposure'
 
 
 The Particulars

data/VERSION

@@ -1 +1 @@
-0.2.4
+1.0.0.rc1

data/lib/decent_exposure.rb

@@ -1,3 +1,5 @@
+require 'decent_exposure/railtie'
+
 module DecentExposure
   def inherited(klass)
     closured_exposure = default_exposure
@@ -27,5 +29,4 @@ module DecentExposure
     helper_method name
     hide_action name
   end
-  alias let expose
 end

data/lib/decent_exposure/default_exposure.rb

@@ -0,0 +1,42 @@
+module DecentExposure
+  module DefaultExposure
+    def self.included(klass)
+      klass.extend(DecentExposure)
+      klass.superclass_delegating_accessor(:_default_exposure)
+      klass.default_exposure do |name|
+        self._resource_name = name.to_s
+        if id = params["#{name}_id"] || params[:id]
+          _proxy.find(id).tap do |r|
+            r.attributes = params[name] unless request.get?
+          end
+        else
+          _proxy.new(params[name])
+        end
+      end
+    end
+
+    private
+    attr_accessor :_resource_name
+
+    def _resource_class
+      _resource_name.classify.constantize
+    end
+
+    def _collection_name
+      _resource_name.pluralize
+    end
+
+    def _proxy
+      _collection.respond_to?(:scoped) ? _collection : _resource_class
+    end
+
+    def _collection
+      unless self.class.method_defined?(_collection_name)
+        self.class.expose(_collection_name) do
+          _collection_name.classify.constantize.scoped({})
+        end
+      end
+      send(_collection_name)
+    end
+  end
+end

data/lib/decent_exposure/railtie.rb

@@ -1,15 +1,19 @@
+require 'decent_exposure/default_exposure'
+
 module DecentExposure
-  class Railtie < Rails::Railtie
-    initializer "decent_exposure.extend_action_controller_base" do |app|
-      ActionController::Base.class_eval do
-        extend DecentExposure
-        superclass_delegating_accessor :_default_exposure
-        default_exposure do |name|
-          model_class = name.to_s.classify.constantize
-          model_class.find(params["#{name}_id"] || params['id'])
+  if defined? Rails::Railtie
+    class Railtie < Rails::Railtie
+      initializer "decent_exposure.extend_action_controller_base" do |app|
+        ActiveSupport.on_load(:action_controller) do
+          DecentExposure::Railtie.insert
         end
       end
     end
   end
-end
 
+  class Railtie
+    def self.insert
+      ActionController::Base.send(:include, DecentExposure::DefaultExposure)
+    end
+  end
+end

data/rails/init.rb

@@ -1,14 +1,2 @@
-begin
-  require File.join(File.dirname(__FILE__), 'lib', 'decent_exposure') # From here
-rescue LoadError
-  require 'decent_exposure' # From gem
-end
-
-ActionController::Base.class_eval do
-  extend DecentExposure
-  superclass_delegating_accessor :_default_exposure
-  default_exposure do |name|
-    model_class = name.to_s.classify.constantize
-    model_class.find(params["#{name}_id"] || params['id'])
-  end
-end
+require 'decent_exposure/railtie'
+DecentExposure::Railtie.insert

data/spec/lib/decent_exposure_spec.rb

@@ -1,175 +1,79 @@
-require File.join(File.dirname(__FILE__), '..', 'helper')
+require 'helper'
 
-class Quacker
-  extend DecentExposure
-  def self.helper_method(*args); end
-  def self.hide_action(*args); end
-  def memoizable(*args); args; end
-  expose(:proxy)
-end
+describe DecentExposure do
 
-module ActionController
-  class Base
+  class Controller
+    extend DecentExposure
     def self.helper_method(*args); end
     def self.hide_action(*args); end
-    def self.superclass_delegating_accessor(*args); end
-    def params; {'resource_id' => 42}; end
+    def memoizable(arg); arg; end
   end
-end
-require File.join(File.dirname(__FILE__), '..', '..', 'rails', 'init.rb')
-
-class MyController < ActionController::Base
-end
 
-class Resource
-  def self.find(*args); end
-end
-
-class Widget
-  def self.find(*args); end
-end
-
-describe DecentExposure do
-  context "classes extending DecentExposure" do
-    it "respond to :expose" do
-      Quacker.respond_to?(:expose).should be_true
-    end
+  context 'classes extending DecentExposure' do
+    subject { Controller }
+    specify { should respond_to(:expose) }
+    specify { should respond_to(:default_exposure) }
   end
 
-  context "#expose" do
-    let(:instance){ Quacker.new }
-
-    it "creates a method with the given name" do
-      Quacker.new.methods.map{|m| m.to_s}.should include('proxy')
-    end
-
-    it "prevents the method from being a callable action" do
-      Quacker.expects(:hide_action).with(:blerg)
-      Quacker.class_eval do
-        expose(:blerg){ 'ehm' }
-      end
-    end
+  context '.expose' do
+    let(:controller) { Class.new(Controller){ expose(:resource) } }
+    let(:instance) { controller.new }
 
-    it "declares the method as a helper method" do
-      Quacker.stubs(:hide_action)
-      Quacker.expects(:helper_method).with(:blarg)
-      Quacker.class_eval do
-        expose(:blarg){ 'uhm' }
-      end
+    it 'creates a method with the given name' do
+      instance.methods.should include('resource')
     end
 
-    it "returns the result of the exposed block from the method" do
-      Quacker.stubs(:hide_action)
-      Quacker.stubs(:helper_method)
-      Quacker.class_eval do
-        expose(:quack){ memoizable('quack!') }
-      end
-      instance.quack.should == %w(quack!)
+    it 'prevents the method from being a callable action' do
+      controller.expects(:hide_action).with(:resources)
+      controller.class_eval { expose(:resources) }
     end
 
-    it "memoizes the value of the created method" do
-      instance.expects(:memoizable).once.returns('value')
-      instance.quack
-      instance.quack
+    it 'declares the method as a helper method' do
+      controller.expects(:helper_method).with(:resources)
+      controller.class_eval { expose(:resources) }
     end
 
-    context "when specifying custom default behavior" do
-      before(:all) do
-        class ::DuckController
-          extend DecentExposure
-          def self.helper_method(*args); end
-          def self.hide_action(*args); end
-          def params; end
-          default_exposure {"default value"}
-          expose(:quack)
+    context 'custom exposures' do
+      before do
+        controller.class_eval do
+          expose(:resource) { memoizable("I'm a resource!") }
         end
       end
 
-      it "uses that behavior when no block is given" do
-        DuckController.new.quack.should == "default value"
+      it 'returns the result of the exposed block from the method' do
+        instance.resource.should == "I'm a resource!"
       end
 
-      it "passes the name given to #expose into the block" do
-        DuckController.class_eval do
-          default_exposure {|name| "downy #{name}"}
-          expose :feathers
-        end
-        DuckController.new.feathers.should == "downy feathers"
+      it 'memoizes the value of the created method' do
+        instance.expects(:memoizable).once.returns('value')
+        2.times { instance.resource }
       end
     end
-  end
-
-  context "within Rails" do
-    let(:controller) {ActionController::Base.new}
-
-    let(:resource){ 'resource' }
-    let(:resource_class_name){ 'Resource' }
-    before do
-      resource.stubs(:to_s => resource, :classify => resource_class_name)
-      resource_class_name.stubs(:constantize => Resource)
-    end
-
-    it "extends ActionController::Base" do
-      ActionController::Base.respond_to?(:expose).should == true
-    end
 
-    context "by default" do
-      it "calls find with params[:resource_id] on the resource's class" do
-        name = resource
-        Resource.expects(:find).with(42)
-        ActionController::Base.class_eval do
-          expose name
-        end
-        controller.resource
-      end
-      context "or, when there is no :resource_id in params" do
+    context '.default_exposure' do
+      let(:defaulted_controller) { Class.new(Controller) }
+      let(:instance) { defaulted_controller.new }
+      context 'when the default_exposure is overridden' do
         before do
-          ActionController::Base.class_eval do
-            def params; {'id' => 24}; end
+          defaulted_controller.class_eval do
+            default_exposure { 'default value' }
+            expose(:default)
           end
         end
-        it "calls find with params[:id] on the resource's class" do
-          Resource.expects(:find).with(24)
-          controller.resource
+        it 'uses the overridden default_exposure' do
+          instance.default.should == 'default value'
         end
       end
-    end
-
-    let(:widget){ 'widget' }
-    let(:widget_class_name){ 'Widget' }
-    before do
-      widget.stubs(:to_s => widget, :classify => widget_class_name)
-      widget_class_name.stubs(:constantize => Widget)
-    end
-
-    let(:my_controller) {MyController.new}
-
-    it "works in descendant controllers" do
-      name = widget
-      Widget.expects(:find).with(123).returns('a widget')
-      MyController.class_eval do
-        def params; {'id' => 123} end
-        expose name
-      end
-
-      my_controller.widget.should == 'a widget'
-    end
-
-    it "allows overridden default in descendant controllers" do
-      MyController.class_eval do
-        default_exposure {|name| name.to_s}
-        expose :overridden
-      end
-      my_controller.overridden.should == 'overridden'
-    end
 
-    it "preserves default in ancestors" do
-      name = widget
-      Widget.stubs(:find).returns('preserved')
-      ActionController::Base.class_eval do
-        expose name
+      context 'with named arguments' do
+        it 'makes the named arguments available' do
+          defaulted_controller.class_eval do
+            default_exposure {|name| "I got: '#{name}'"}
+            expose :default
+          end
+          instance.default.should == "I got: 'default'"
+        end
       end
-      controller.widget.should == 'preserved'
     end
   end
 end

data/spec/lib/rails_integration_spec.rb

@@ -0,0 +1,130 @@
+require 'helper'
+require 'action_controller'
+require 'decent_exposure/railtie'
+DecentExposure::Railtie.insert
+
+class Resource
+  def self.scoped(opts); self; end
+  def self.find(*args); end
+  def initialize(*args); end
+end
+
+describe "Rails' integration:", DecentExposure do
+  let(:controller) { Class.new(ActionController::Base) }
+  let(:instance) { controller.new }
+  let(:request) { mock(:get? => true) }
+  let(:params) { HashWithIndifferentAccess.new(:resource_id => 42) }
+
+  before do
+    controller.expose(:resource)
+    instance.stubs(:request).returns(request)
+  end
+
+  context '.expose' do
+    it 'is available to ActionController::Base' do
+      ActionController::Base.should respond_to(:expose)
+    end
+  end
+
+  context 'within descendant controllers' do
+    let(:resource_controller) { Class.new(ActionController::Base) }
+    let(:instance) { resource_controller.new }
+
+    before do
+      instance.stubs(:request).returns(request)
+      instance.stubs(:params).returns(params)
+      resource_controller.expose :resource
+    end
+
+    it 'inherits the default_exposure' do
+      Resource.stubs(:find).returns('resource')
+      instance.resource.should == 'resource'
+    end
+
+    it 'allows you to override the default_exposure' do
+      resource_controller.class_eval do
+        default_exposure {|name| name.to_s}
+        expose :overridden
+      end
+      instance.overridden.should == 'overridden'
+    end
+
+    it 'does not override the default in ancestors' do
+      Resource.stubs(:find).returns('preserved')
+      instance.resource.should == 'preserved'
+    end
+  end
+
+  context '.default_exposure' do
+    before do
+      instance.stubs(:params).returns(params)
+    end
+
+    it 'is available to ActionController::Base' do
+      ActionController::Base.should respond_to(:default_exposure)
+    end
+
+    context 'when no collection method exists' do
+      it 'creates a collection method to scope from' do
+        instance.resource
+        instance.methods.should include('resources')
+      end
+    end
+
+    context 'when a collection method exists' do
+      let(:controller){ Class.new(ActionController::Base) }
+      let(:instance){ controller.new }
+
+      before { class Person < Resource; end }
+
+      context 'and the collection can be scoped' do
+        let(:collection){ mock(:scoped => [self]) }
+
+        before{ controller.expose(:person) }
+
+        it 'uses the existing collection method' do
+          instance.stubs(:people).returns(collection)
+          collection.expects(:new)
+          instance.person
+        end
+      end
+      context 'when the collection can not be scoped' do
+        let(:collection){ mock }
+
+        before{ controller.expose(:person) }
+
+        it 'falls back to the singularized constant' do
+          instance.stubs(:people).returns(collection)
+          Person.expects(:new)
+          instance.person
+        end
+      end
+    end
+
+    context 'when either :resource_id or :id are present in params' do
+      it "calls find with params[:resource_id] on the resource's class" do
+        Resource.expects(:find).with(42)
+        instance.resource
+      end
+
+      context 'when there is no :resource_id in params' do
+        before { instance.stubs(:params).returns({:id => 73}) }
+
+        it "calls find with params[:id] on the resource's class" do
+          Resource.expects(:find).with(73)
+          instance.resource
+        end
+      end
+    end
+    context 'when there are no ids in params' do
+      before do
+        instance.stubs(:params).returns({:resource => {:name => 'bob'}})
+      end
+
+      it 'calls new with params[:resouce_name]' do
+        Resource.expects(:new).with({:name => 'bob'})
+        instance.resource
+      end
+    end
+  end
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: decent_exposure
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
+  - 1
+  - 0
   - 0
-  - 2
-  - 4
-  version: 0.2.4
+  - rc1
+  version: 1.0.0.rc1
 platform: ruby
 authors: 
 - Stephen Caudill
@@ -15,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-01 00:00:00 -04:00
+date: 2010-07-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,6 +47,18 @@ dependencies:
         version: 0.9.8
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: "\n      DecentExposure helps you program to an interface, rather than an implementation\n      in your Rails controllers.  The fact of the matter is that sharing state\n      via instance variables in controllers promotes close coupling with views.\n      DecentExposure gives you a declarative manner of exposing an interface to the\n      state that controllers contain and thereby decreasing coupling and\n      improving your testability and overall design.\n    "
 email: scaudill@gmail.com
 executables: []
@@ -59,6 +72,7 @@ files:
 - README.md
 - VERSION
 - lib/decent_exposure.rb
+- lib/decent_exposure/default_exposure.rb
 - lib/decent_exposure/railtie.rb
 - rails/init.rb
 has_rdoc: true
@@ -79,11 +93,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
@@ -94,3 +110,4 @@ summary: A helper for creating declarative interfaces in controllers
 test_files: 
 - spec/helper.rb
 - spec/lib/decent_exposure_spec.rb
+- spec/lib/rails_integration_spec.rb