exposure 0.0.6 → 0.0.7

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+*.gemspec
+pkg

data/NOTES

@@ -0,0 +1,57 @@
+TOC.
+  I. Installing
+    sudo gem install exposure
+  II. REST
+  III. Current Controller behavior with class methods
+  IV. Exposure
+    A. expose
+    B. Finders
+    C. Responders
+    D. Flashers
+    E. Callbacks
+    
+Controllers already have some configuration-like structure:
+  before_filter
+  after_filter
+  around_filter
+  
+  skip_before_filter
+  skip_after_filter
+  skip_around_filter
+  
+  verify
+  layout
+  filter_parameter_logging
+  rescue_from
+  
+We're adding
+  expose
+  find
+  response_for
+  flash_for
+  
+  the following callbacks:
+    before_find
+    after_find
+    after_find_on_failure
+    after_find_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
+  and speciality access to these callbacks with
+    before
+    after

data/Rakefile

@@ -1,23 +1,14 @@
 require 'rubygems'
-gem 'hoe', '>= 2.1.0'
-require 'hoe'
-require 'fileutils'
-require './lib/exposure'
-
-Hoe.plugin :newgem
-# Hoe.plugin :website
-# Hoe.plugin :cucumberfeatures
-
-# Generate all the Rake tasks
-# Run 'rake -T' to see list of generated tasks (from gem root directory)
-$hoe = Hoe.spec 'exposure' do
-  self.developer 'Trek Glowacki', 'trek.glowacki@gmail.com'
-  self.summary = 'exposed resources'
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gemspec|
+  gemspec.name = 'exposure'
+  gemspec.summary = 'exposed resources'
+  gemspec.description = 'exposed resources'
+  gemspec.email = 'trek.glowacki@gmail.com'
+  gemspec.authors = ['Trek Glowacki']
 end
+Jeweler::GemcutterTasks.new
 
-require 'newgem/tasks'
-Dir['tasks/**/*.rake'].each { |t| load t }
-
-# TODO - want other tests/tasks run by default? Add them to the list
-# remove_task :default
-# task :default => [:spec, :features]
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/VERSION

@@ -0,0 +1 @@
+0.0.7

data/lib/exposure/behaviors/building.rb

@@ -0,0 +1,36 @@
+module Exposure
+  module Building
+    def self.included(base)
+      base.extend ClassMethods
+      base.send(:include, InstaneMethods)
+    end
+    
+    module ClassMethods
+      def build(name, options = {}, &block)
+        options[:with] ||= block
+        self.const_get(:Builders)[name] = options[:with]
+      end
+      
+      def build_default_builder(member, nesting)
+        self::const_set(:DefaultBuilder, {
+          self.resource_name.intern  => Proc.new { [:new, params[resource_name] ] }
+        })
+      end
+    end
+    
+    module InstaneMethods
+      private
+        def custom_builder_for(resource_name)
+          
+        end
+        
+        def default_builder_for(resource_name)
+          
+        end
+        
+        def builder_for(resource_name)
+          custom_builder_for(resource_name) || default_builder_for(resource_name)
+        end
+    end
+  end
+end

data/lib/exposure/behaviors/callbacks.rb

@@ -0,0 +1,53 @@
+module Exposure
+  module Callbacks
+    def self.included(base)
+      base.extend ClassMethods
+      base.send(:include, InstaneMethods)
+    end
+    
+    module ClassMethods
+      # access point for creating and configuring before_ callbacks.
+      def before(trigger, *actions)
+        options = actions.extract_options!
+        actions.each do |action|
+          build_callback('before', trigger, action, options)
+        end
+      end
+
+      # access point for creating and configuring after_ callbacks.
+      def after(trigger, *actions)
+        options = actions.extract_options!
+        actions.each do |action|
+          build_callback('after', trigger, action, options)
+        end
+      end
+      
+      # builds callbacks that adhere to the ActiveSupport::Callbacks interface
+      def build_callback(prefix, trigger, action, options) #:nodoc:
+        callback_name = "#{prefix}_#{trigger}"
+
+        if options[:on]
+          callback_name += "_on_#{options.delete(:on)}"
+        end
+
+        options[:if] ||= []
+
+        only_methods = options.delete(:only)
+        except_methods = options.delete(:except)
+
+        if only_methods
+          options[:if] << Proc.new {|c| only_methods.include?(c.action_name.intern) }
+        end
+
+        if except_methods
+          options[:if] << Proc.new {|c| !except_methods.include?(c.action_name.intern) }
+        end
+
+        self.send(callback_name, action, options)
+      end
+    end
+    
+    module InstaneMethods
+    end
+  end
+end

data/lib/exposure/behaviors/finding.rb

@@ -0,0 +1,84 @@
+module Exposure
+  module Finding
+    def self.included(base)
+      base.extend ClassMethods
+      base.send(:include, InstaneMethods)
+    end
+    
+    module ClassMethods
+      # find :person, :with => Proc.new { Person.find_by_permalink(params[:permalink]) }
+      # find :people, :with => Proc.new { Person.send(params[:scope]) }
+      # find :dogs, :with => :dogs_adopted_after_date
+      # find :dogs do
+      #   Dog.all
+      # end
+      # 
+      # valid options are
+      #   :with
+      #   :only (unimplemented)
+      #   :except (unimplemented)
+      def find(name, options = {}, &block)
+        options[:with] ||= block
+        self.const_get(:Finders)[name] = options[:with]
+      end
+      
+      def build_default_finders(member, nesting) #:nodoc:
+        finders = self::const_set(:DefaultFinders, {
+          self.resource_name.intern  => Proc.new { [:find, params[:id] ] },
+          self.resources_name.intern => Proc.new { [:all] }
+        })
+
+        nesting.each do |association_name|
+          finders[association_name.to_s.singularize.to_sym] = Proc.new { [:find, params[:"#{association_name.to_s.singularize}_id"]] }
+          finders[association_name] = Proc.new { [ :all ] }
+        end
+      end
+    end
+    
+    module InstaneMethods
+      private
+        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
+    end
+  end
+end

data/lib/exposure/behaviors/flashing.rb

@@ -0,0 +1,62 @@
+module Exposure
+  module Flashing
+    def self.included(base)
+      base.extend ClassMethods
+      base.send(:include, InstaneMethods)
+    end
+    
+    module ClassMethods
+      # configure flash messages
+      # valid action names are 
+      #   :index :show :new :create :edit :update :destroy
+      # valid options are
+      #   :on (optional)
+      #     :success, :failure, :any
+      #     default is :any
+      #   :is (optional if block given)
+      #     can be a Proc or method name as symbol.
+      def flash_for(action_name, options = {}, &block)
+        options[:is] ||= block
+
+        case options[:on]
+        when NilClass, :any
+          self.const_get(:FlashMessages)["#{action_name}.success.html"]  = options[:is]
+          self.const_get(:FlashMessages)["#{action_name}.failure.html"]  = options[:is]
+        when :success
+          self.const_get(:FlashMessages)["#{action_name}.success.html"]  = options[:is]
+        when :failure
+          self.const_get(:FlashMessages)["#{action_name}.failure.html"]  = options[:is]
+        end
+      end
+    end
+    
+    module InstaneMethods
+      private
+        def custom_flash_for(action_name, action_status)
+          if flash_message = self.class::FlashMessages["#{action_name}.#{action_status}.html"]
+            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_status)
+          if message_proc = self.class::DefaultFlashMessages["#{action_name}.#{action_status}.html"]
+            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
+    end
+    
+  end
+end

data/lib/exposure/behaviors/responding.rb

@@ -0,0 +1,80 @@
+module Exposure
+  module Responding
+    def self.included(base)
+      base.extend ClassMethods
+      base.send(:include, InstaneMethods)
+    end
+    
+    module ClassMethods
+      # response_for :create, :on => :success, :is => { proc }
+      # response_for :show, :formats => [:html] do
+      #   @resource.activated ? render('show') : render('next_steps')
+      # end
+      # response_for :new, :is => :new_foo_built
+      #
+      # valid action names are 
+      #   :index :show :new :create :edit :update :destroy
+      # valid options are
+      #   :on (optional)
+      #     :success, :failure, :any
+      #     default is :any
+      #   :is (option if block given)
+      #     can be a Proc or method name as symbol.
+      #   :formats
+      #     array of formats as symbols.
+      #     defaults to [:html]
+      def response_for(*actions, &block)
+        options = actions.extract_options!
+        options[:is] ||= block
+        formats  = options[:formats] || [:html]
+
+        case options[:on]
+        when NilClass, :any
+          build_custom_response(actions, :success, formats, options[:is])
+          build_custom_response(actions, :failure, formats, options[:is])
+        when :success
+          build_custom_response(actions, :success, formats, options[:is])
+        when :failure
+          build_custom_response(actions, :failure, formats, options[:is])
+        end
+      end
+      
+      def build_custom_response(action_names, success_status, formats, response) #:nodoc:
+        action_names.each do |action_name|
+          formats.each do |format|
+            self.const_get(:Responses)["#{action_name}.#{success_status}.#{format}"] = response
+          end
+        end
+      end
+    end
+    
+    module InstaneMethods
+      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
+    end
+  end
+end

data/lib/exposure/configuration.rb

@@ -1,26 +1,5 @@
 module Exposure
-  module Configuration
-    # options
-    # :nested => false or symbol or array of symbols
-    #   defaults to false
-    # :only   => array of REST methods names as symbols to only include
-    #   defaults to [:show, :new, :create, :edit, :update, :destroy]
-    # :except => array of REST methods to exclude
-    #   defaults to [ ]
-    # :formats => array of 
-    #   defaults to [ :html, :xml, :json ]
-    def expose_one(resource_name, options = {})
-      include ActiveSupport::Callbacks      
-      extend Exposure::Common
-      self.resource_name = resource_name
-      self.member_nesting = [ [self.resource_name.to_sym] ]
-
-      extend  Patterns::Resource
-      include Patterns::Resource::Actions
-      
-      define_callbacks(*Patterns::Resource::Callbacks)
-    end
-    
+  module Configuration  
     # options
     # :nested => false or symbol or array of symbols
     #   defaults to false
@@ -29,34 +8,37 @@ module Exposure
     # :except => array of REST methods to exclude
     #   defaults to [ ]
     # :formats => array of 
-    #   defaults to [ :html, :xml, :json ]
+    #   defaults to [ :html, :xml]
     # 
     def expose_many(name, options = {})
-      include ActiveSupport::Callbacks
-      extend Exposure::Common
+      @_exposed_resource_name = name
+      @_exposed_resource_options = options
       
-      self.resource_name  = name.to_s.singularize
-      self.resources_name = name.to_s
+      extend Configuration::Options
       
-      if nesting = options[:nested]
-        
-        self.parent_model = nesting.shift.to_s.singularize.camelize.constantize
-        
-        build_default_finders(self.resources_name, nesting)
-        
-        nesting.collect! {|sym| [sym.to_s.singularize.to_sym, sym]}
-        self.member_nesting = nesting + [ [self.resource_name.to_sym] ]
-        self.collection_nesting = nesting + [ [self.resources_name.to_sym] ]
-      else
-        self.parent_model = self.resource_name.camelize.constantize
-        build_default_finders(self.resource_name, [])
-        self.member_nesting = [ [self.resource_name.to_sym] ]
-        self.collection_nesting = [ [self.resources_name.to_sym] ]
+      class << self
+        attr_accessor :resource_name, :resources_name, 
+                      :resource_chain, :resources_chain, 
+                      :collection_nesting, :member_nesting,
+                      :parent_model
       end
       
+      include ActiveSupport::Callbacks
+      include Exposure::Finding
+      include Exposure::Flashing
+      include Exposure::Responding
+      include Exposure::Callbacks
+      
+      self.name!
+      self.build_default_finders!
+      self.build_default_builders!
+      
       extend  Patterns::Resources
       include Patterns::Resources::Actions
       
+      self.allow_actions!
+      self.allow_formats!
+      
       define_callbacks(*Patterns::Resources::Callbacks)
     end
     alias :expose :expose_many

data/lib/exposure/options.rb

@@ -0,0 +1,55 @@
+module Exposure
+  module Configuration
+    module Options
+      
+      def allow_actions!
+        if @_exposed_resource_options[:only]
+          @_exposed_resource_options[:except] = Patterns::Resources::DefaultActions - @_exposed_resource_options[:only]
+        end
+
+        if @_exposed_resource_options[:except]
+          @_exposed_resource_options[:except].each do |action|
+            undef_method(action)
+          end
+        end
+      end
+
+      def allow_formats!
+        formats = @_exposed_resource_options[:formats] || [:html, :xml] 
+      end
+
+      def name!
+        self.resource_name  = @_exposed_resource_name.to_s.singularize
+        self.resources_name = @_exposed_resource_name.to_s
+      end
+
+      def build_default_finders!
+        if nesting = @_exposed_resource_options[:nested]
+          self.build_nested_default_finders!(nesting)
+          return 
+        end
+
+        self.parent_model = self.resource_name.camelize.constantize
+        build_default_finders(self.resource_name, [])
+        self.member_nesting = [ [self.resource_name.to_sym] ]
+        self.collection_nesting = [ [self.resources_name.to_sym] ]
+      end
+
+      def build_default_builders!
+        true
+      end
+
+      def build_nested_default_finders!(nesting)
+
+        self.parent_model = nesting.shift.to_s.singularize.camelize.constantize
+
+        build_default_finders(self.resources_name, nesting)
+
+        nesting.collect! {|sym| [sym.to_s.singularize.to_sym, sym]}
+
+        self.member_nesting = nesting + [ [self.resource_name.to_sym] ]
+        self.collection_nesting = nesting + [ [self.resources_name.to_sym] ]
+      end
+    end
+  end
+end