exposure 0.0.4

data/lib/exposure/patterns/resources.rb

@@ -0,0 +1,323 @@
+module Exposure
+  module Patterns
+    module Resources
+      def self.extended(base)
+        base::const_set(:DefaultResponses, DefaultResponses)
+        base::const_set(:DefaultFlashMessages, DefaultFlashMessages)
+        base::const_set(:Finders, { true => {}, false => {} })
+        base::const_set(:FlashMessages, { true => {}, false => {} })
+        base::const_set(:Responses, {} )
+      end
+      
+      Callbacks = %w(
+        before_find after_find after_find_on_failure after_find_on_success
+        before_find_many after_find_many after_find_many_on_failure after_find_many_on_success
+        before_assign after_assign
+        before_save after_save after_save_on_failure after_save_on_success
+        before_create after_create_on_failure after_create_on_success
+        before_update after_update_on_failure after_update_on_success
+        before_destroy after_destroy_on_success
+        before_response before_response_on_success before_response_on_failure
+      )
+      
+      DefaultFlashMessages = {
+        true => {
+          :create =>  Proc.new { "#{resource_name.capitalize} successfully created" },
+          :update =>  Proc.new { "#{resource_name.capitalize} successfully updated" },
+          :destroy => Proc.new { "#{resource_name.capitalize} successfully removed" }
+        },
+        false => {}
+      }
+      
+      DefaultResponses = {
+        'index.success.html'  => Proc.new   { render('index') },
+        'show.success.html'   => Proc.new   { render('show')  },
+        'new.success.html'    => Proc.new   { render('new')   },
+        'create.success.html' => Proc.new  { redirect_to({:action => 'index'}) },
+        'edit.success.html'   => Proc.new  { render('edit')  },
+        'update.success.html' => Proc.new  { redirect_to({:action => 'show' }) },
+        'destroy.success.html'=> Proc.new { redirect_to({:action => 'index'}) },
+        'create.failure.html' => Proc.new { render('new')    },
+        'update.failure.html' => Proc.new { render('edit')   },
+        'index.success.xml'   => Proc.new { render(:xml => @resources) },
+        'show.success.xml'   => Proc.new  { render(:xml => @resource) },
+        'new.success.xml'    => Proc.new  { render(:xml => @resource) },
+        'create.success.xml' => Proc.new  { render({:xml => @resource, :status => :created, :location => @resource}) },
+        'created.failure.xml'=> Proc.new  { render(:xml => @resource.errors, :status => :unprocessable_entity)},
+        'update.success.xml' => Proc.new  { head(:ok)},
+        'update.failure.xml' => Proc.new  { render(:xml => @resource.errors, :status => :unprocessable_entity)},
+        'destroy.success.xml'=> Proc.new  { head(:ok)}
+      }
+
+      module Actions
+        def index
+          run_callbacks(:before_find_many)
+           if find_records
+             run_callbacks(:after_find_many_on_success)
+             run_callbacks(:after_find_many)
+             run_callbacks(:before_response)
+             run_callbacks(:before_response_on_success)
+             response_for(:index, :success, request.format.to_sym)
+           else
+             run_callbacks(:after_find_many_on_failure)
+             run_callbacks(:after_find_many)
+             run_callbacks(:before_response)
+             run_callbacks(:before_response_on_failure)
+             response_for(:index, :failure, request.format.to_sym)
+          end
+        end
+        
+        def show
+          run_callbacks(:before_find)
+          if find_record
+            run_callbacks(:after_find_on_success)
+            run_callbacks(:after_find)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_success)
+            response_for(:show, :success, request.format.to_sym)
+          else
+            run_callbacks(:after_find_on_failure)
+            run_callbacks(:after_find)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_failure)
+            response_for(:show, :failure, request.format.to_sym)
+          end
+        end
+        
+        def new
+          run_callbacks(:before_assign)
+          new_record
+          run_callbacks(:after_assign)
+          run_callbacks(:before_response)
+          run_callbacks(:before_response_on_success)
+          response_for(:new, :success, request.format.to_sym)
+        end
+        
+        def create
+          run_callbacks(:before_assign)
+          new_record
+          run_callbacks(:after_assign)
+
+          run_callbacks(:before_create)
+          run_callbacks(:before_save)
+
+          if save_record
+            run_callbacks(:after_save_on_success)
+            run_callbacks(:after_create_on_success)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_success)
+            flash_for(:create, true)
+            response_for(:create, :success, request.format.to_sym)
+          else
+            run_callbacks(:after_save_on_failure)
+            run_callbacks(:after_create_on_failure)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_failure)
+            flash_for(:create, false)
+            response_for(:create, :failure, request.format.to_sym)
+          end
+          
+        end
+        
+        def edit
+          run_callbacks(:before_find)
+          if find_record
+            run_callbacks(:after_find_on_success)
+            run_callbacks(:after_find)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_success)
+            response_for(:edit, :success, request.format.to_sym)
+          else
+            run_callbacks(:after_find_on_failure)
+            run_callbacks(:after_find)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_failure)
+            response_for(:edit, :failure, request.format.to_sym)
+          end
+        end
+        
+        def update
+          run_callbacks(:before_find)
+          if find_record
+            run_callbacks(:after_find_on_success)
+            run_callbacks(:after_find)
+            if update_record
+              run_callbacks(:after_save_on_success)
+              run_callbacks(:after_update_on_success)
+              run_callbacks(:before_response)
+              run_callbacks(:before_response_on_success)
+              flash_for(:update, true)
+              response_for(:update, :success, request.format.to_sym)
+            else
+              run_callbacks(:after_save_on_failure)
+              run_callbacks(:after_create_on_failure)
+              run_callbacks(:before_response)
+              run_callbacks(:before_response_on_failure)
+              flash_for(:update, false)
+              response_for(:update, :failure, request.format.to_sym)
+            end
+          else
+            run_callbacks(:after_find_on_failure)
+            run_callbacks(:after_find)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_failure)
+            response_for(:edit, :failure, request.format.to_sym)
+          end
+        end
+        
+        def destroy
+          run_callbacks(:before_find)
+          if find_record
+            run_callbacks(:after_find_on_success)
+            run_callbacks(:after_find)
+            run_callbacks(:before_destroy)
+
+            delete_record
+
+            run_callbacks(:after_destroy_on_success)
+            run_callbacks(:before_response)
+            run_callbacks(:before_response_on_success)
+            flash_for(:destroy, true)
+            response_for(:destroy, :success, request.format.to_sym)
+
+          else
+            run_callbacks(:after_find_on_failure)
+            run_callbacks(:after_find)
+            response_for(:destroy, :failure, request.format.to_sym)
+          end
+        end
+        
+        private
+          def custom_response_for(action_name, action_status, format)
+            if responder = self.class::Responses["#{action_name}.#{action_status}.#{format}"]
+              case responder
+              when Symbol
+                self.send(responder)
+              when Proc
+                self.instance_eval &responder
+              end
+            else
+              false
+            end
+          end
+
+          def default_response_for(action_name, action_status, format)
+            if responder = self.class::DefaultResponses["#{action_name}.#{action_status}.#{format}"]
+              self.instance_eval &responder
+            else
+              return false
+            end
+          end
+
+          def response_for(action_name, action_status, format = :html)
+            format = :html if format == :all
+            custom_response_for(action_name, action_status, format) || default_response_for(action_name, action_status, format) || head(:not_acceptable)
+          end
+          
+          def custom_flash_for(action_name, action_successful)
+            if flash_message = self.class::FlashMessages[action_successful][action_name]
+              case flash_message
+              when String
+                flash[:message] = flash_message
+              when Symbol
+                flash[:message] = self.send(flash_message)
+              when Proc
+                flash[:message] = self.instance_eval(&flash_message)
+              end
+            else
+              false
+            end
+          end
+          
+          def default_flash_for(action_name, action_successful)
+            if message_proc = self.class::DefaultFlashMessages[action_successful][action_name]
+              flash[:message] = self.instance_eval(&message_proc)
+            end
+          end
+          
+          def flash_for(action_name, action_successful)
+            custom_flash_for(action_name, action_successful) || default_flash_for(action_name, action_successful)
+          end
+          
+          def custom_finder_for(resource_name)
+            if finder = self.class::Finders[resource_name]
+              return finder
+            end
+          end
+          
+          def default_finder_for(resource_name)
+            if finder = self.class::DefaultFinders[resource_name]
+              return finder
+            end
+          end
+          
+          def finder_for(resource_name)
+            custom_finder_for(resource_name) || default_finder_for(resource_name)
+          end
+          
+          def call_finder_chain(object, chain, use_associaiton = true)
+            links = chain.shift
+            return object unless links
+
+            message = finder_for(links[0])
+            association = links[1] if use_associaiton
+
+            case message
+            when Symbol
+              value = self.send(message)
+            when Proc
+              value = self.instance_eval(&message)
+            else
+              raise "invalid finder of #{message.inspect}"
+            end
+
+            if value.kind_of?(Array) && !value.respond_to?(:proxy_target)
+              if use_associaiton
+                call_finder_chain(object.send(association).send(*value), chain)
+              else
+                call_finder_chain(object.send(*value), chain)
+              end
+            else
+              call_finder_chain(value, chain)
+            end
+          end
+          
+          def builder_for(resource_name)
+            custom_builder_for(resource_name) || default_builder_for(resource_name)
+          end
+          
+          def resource_name
+            self.class.resource_name
+          end
+          
+          def resources_name
+            self.class.resources_name
+          end
+          
+          def save_record
+            @resource.save
+          end
+          
+          def update_record
+            @resource.update_attributes(params[resource_name])
+          end
+          
+          def new_record
+            @resource = instance_variable_set("@#{resource_name}", self.class.parent_model.new(params[resource_name]))
+          end
+          
+          def find_record
+            @resource = instance_variable_set("@#{resource_name}", call_finder_chain(self.class.parent_model, self.class.member_nesting.clone, false))
+          end
+          
+          def find_records            
+            @resources = instance_variable_set("@#{resources_name}", call_finder_chain(self.class.parent_model, self.class.collection_nesting.clone, false))
+          end
+          
+          def delete_record
+            @resource.destroy
+          end
+      end
+    end
+  end
+end

data/lib/exposure.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'exposure/configuration'
+require 'exposure/common'
+require 'exposure/patterns/resources'
+require 'exposure/patterns/resource'
+
+module Exposure
+  VERSION = '0.0.4'
+  def self.included(base)
+    base.extend Configuration
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/exposure.rb'}"
+puts "Loading exposure gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/custom_matchers.rb

@@ -0,0 +1,41 @@
+module Shoulda
+  module ActionController
+    module Matchers
+      class RespondWithMatcher
+        def to(where)
+           @location = case where
+           when Symbol
+             where == :back ? where : {:action => where.to_s}
+           else
+             where
+           end
+           self
+         end
+         
+         def description
+           description = "respond with #{@status}"
+           description << " to #{@location.inspect}" unless @location.nil?
+           description
+         end
+         
+         def matches?(controller)
+           @controller = controller
+           (correct_status_code? || correct_status_code_range?) && correct_redirect_location
+         end
+         
+         def expectation
+           expectation = "response to be a #{@status},"
+           expectation << " redirecting to #{@location.inspect}, " if @location
+           expectation << " but was #{response_code}"
+           expectation << " redirected to #{@controller.response.redirected_to.inspect}" if @location
+           expectation
+         end
+         private
+           def correct_redirect_location
+             return true unless @location
+             @controller.response.redirected_to == @location
+           end
+       end
+    end
+  end
+end

data/spec/exposure_spec.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "exposure" do
+end

data/spec/factories/pirate_factory.rb

@@ -0,0 +1,8 @@
+Factory.define :pirate do |p|
+  p.title 'Captain Jack'
+  p.booty 'Rum, Ladies, and a cutlass'
+end
+
+Factory.define :pirate_with_ships, :parent => :pirate do |p|
+  p.ships {|ships| [ships.association(:ship)]}
+end

data/spec/factories/ship_factory.rb

@@ -0,0 +1,3 @@
+Factory.define :ship do |s|
+  s.name 'Black Pearl'
+end

data/spec/finders/finder_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "finders", :type => :controller do   
+  class PiratesController < ActionController::Base
+    expose_many(:pirates)
+    private
+      def find_pirate
+        Pirate.find_by_title(params[:id])
+      end
+  end 
+  
+  controller_name :pirates
+
+  before(:each) do
+    @controller = PiratesController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    ActionController::Routing::Routes.draw do |map| 
+      map.resources :pirates
+    end
+    
+    @pirate = Factory.stub(:pirate)
+    Pirate.stub(:find_by_title => @pirate)
+  end
+  
+  after(:each) do
+    PiratesController::Finders.clear
+  end
+  
+  it "finds with a method name as symbol" do
+    PiratesController.find :pirate, :with => Proc.new { Pirate.find_by_title(params[:id]) }
+    get(:show, {:id => 'Captain'})
+    
+    should assign_to(:pirate).with(@pirate)
+  end
+  
+  it "finds with a proc" do
+    PiratesController.find :pirate, :with => :find_pirate
+    get(:show, {:id => 'Captain'})
+    
+    should assign_to(:pirate).with(@pirate)    
+  end
+  
+  it "finds with a block" do
+    PiratesController.find :pirate do
+      Pirate.find_by_title(params[:id])
+    end
+    
+    get(:show, {:id => 'Captain'})
+    
+    should assign_to(:pirate).with(@pirate)    
+  end
+end

data/spec/finders/nested_resources_finder_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "nested finders", :type => :controller do   
+  class ShipsController < ActionController::Base
+    expose_many(:ships, :nested => [:pirates])
+  end 
+  
+  controller_name :ships
+
+  before(:each) do
+    @controller = ShipsController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    ActionController::Routing::Routes.draw do |map| 
+      map.resources :pirates do |pirate|
+        pirate.resources :ships
+      end
+    end
+    
+    @pirate = Factory.create(:pirate_with_ships)
+    Pirate.stub(:find => @pirate)
+    
+    get(:index, {:pirate_id => 1})
+  end
+  
+  it { should assign_to(:ships) }
+  it { should assign_to(:resources) }
+  
+end

data/spec/flashers/flash_with_block_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "flash messages with blocks", :type => :controller do   
+  class PiratesController < ActionController::Base
+    expose_many(:pirates)
+    PiratesController.flash_for :create do
+      "the flash is set to #{@pirate.title}"
+    end
+  end 
+  
+  controller_name :pirates
+  
+  before(:each) do
+    @controller = PiratesController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    ActionController::Routing::Routes.draw do |map| 
+      map.resources :pirates, :collection => {:test => :any}
+    end
+    
+    @pirate = Factory.stub(:pirate, {:title => 'Captain'})
+    Pirate.stub(:new => @pirate)
+    
+    @pirate.stub(:save => true)
+    
+    @custom_flash_message = "the flash is set to #{@pirate.title}"
+    
+    post(:create)
+  end
+  
+  it { should set_the_flash.to(@custom_flash_message) }
+end

data/spec/flashers/flash_with_method_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "flash messages with methods", :type => :controller do   
+  class PiratesController < ActionController::Base
+    expose_many(:pirates)
+    private
+      def custom_flash_message
+        'the flash was set'
+      end
+  end 
+  
+  controller_name :pirates
+  
+  before(:each) do
+    @controller = PiratesController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    ActionController::Routing::Routes.draw do |map| 
+      map.resources :pirates, :collection => {:test => :any}
+    end
+    
+    @custom_flash_message = 'the flash was set'
+    
+    @pirate = Factory.stub(:pirate)
+    Pirate.stub(:new => @pirate)
+  end
+  
+  after(:each) do
+    PiratesController::FlashMessages[true].clear
+    PiratesController::FlashMessages[false].clear
+  end
+  
+  describe "responding with a method call" do
+    before(:each) do
+      PiratesController.flash_for :create, :is => :custom_flash_message
+    end
+    
+    it "should respond with redirect to test on success" do
+      @pirate.stub(:save => true)
+      post(:create)
+      should set_the_flash.to(@custom_flash_message)
+    end
+    
+    it "should respond with redirect to test on failure" do
+      @pirate.stub(:save => false)
+      post(:create)
+      should set_the_flash.to(@custom_flash_message)
+    end
+  end
+  
+  describe "responding with a method call :on => :success" do
+    before(:each) do
+       PiratesController.flash_for :create, :is => :custom_flash_message, :on => :success
+     end
+
+    it "should respond with custom response on success" do
+       @pirate.stub(:save => true)
+       post(:create)
+       should set_the_flash.to(@custom_flash_message)
+     end
+
+    it "should not respond with custom response on failure" do
+       @pirate.stub(:save => false)
+       post(:create)
+       should_not redirect_to({:action => 'test'})
+     end
+  end
+  
+  describe "responding with a method call :on => :failure" do
+      before(:each) do
+        PiratesController.flash_for :create, :is => :custom_flash_message, :on => :failure
+      end
+
+      it "should not respond with custom response  on success" do
+        @pirate.stub(:save => true)
+        post(:create)        
+        should_not redirect_to({:action => 'test'})
+      end
+
+      it "should respond with custom response on failure" do
+        @pirate.stub(:save => false)
+        post(:create)
+        should set_the_flash.to(@custom_flash_message)
+      end
+    end
+end