benhoskings-hammock 0.2.4

data/lib/hammock/overrides.rb

@@ -0,0 +1,32 @@
+module Hammock
+  module Overrides
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      private
+
+      def custom_scope
+        nil
+      end
+
+      def postsave_render result
+        nil
+      end
+
+      def postsave_redirect
+        nil
+      end
+
+      def postdestroy_redirect
+        nil
+      end
+
+    end
+  end
+end

data/lib/hammock/resource_mapping_hooks.rb

@@ -0,0 +1,28 @@
+module Hammock
+  module ResourceMappingHooks
+    MixInto = ActionController::Resources
+
+    def self.included base # :nodoc:
+      base.send :include, Methods
+
+      base.class_eval {
+        alias_method_chain_once :map_resource, :hammock_route_map
+        alias_method_chain_once :map_singleton_resource, :hammock_route_map
+      }
+    end
+
+    module Methods
+
+      def map_resource_with_hammock_route_map entity, options = {}, &block
+        ActionController::Routing::Routes.route_map.add entity, options
+        map_resource_without_hammock_route_map entity, options, &block
+      end
+
+      def map_singleton_resource_with_hammock_route_map entity, options = {}, &block
+        ActionController::Routing::Routes.route_map.add_singleton entity, options
+        map_singleton_resource_without_hammock_route_map entity, options, &block
+      end
+
+    end
+  end
+end

data/lib/hammock/resource_retrieval.rb

@@ -0,0 +1,115 @@
+module Hammock
+  module ResourceRetrieval
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      private
+
+      def find_deleted_record
+        find_record :find_with_deleted
+      end
+
+      def find_record finder = :find
+        result = if !callback(:before_find)
+          # callbacks failed
+        elsif (record = retrieve_record(finder)).nil?
+          log "#{mdl}<#{params[:id]}> doesn't exist within #{requester_name.possessive} #{action_name} scope."
+          :not_found
+        elsif :ok != (verbability = can_verb_record?(action_name.to_sym, record))
+          verbability
+        elsif !callback(:during_find, record)
+          # callbacks failed
+        else
+          :ok
+        end
+
+        if :ok != result
+          escort(result)
+        else
+          assign_entity record
+        end
+      end
+
+      def retrieve_resource
+        if (scope = current_scope).nil?
+          escort :unauthed
+        else
+          assign_entity scope
+        end
+      end
+
+      def retrieve_record finder
+        if (scope = current_scope).nil?
+
+        else
+          record = scope.send finder, :first, :conditions => {find_column_name => params[:id]}
+          record || required_callback(:after_failed_find)
+        end
+      end
+
+      def escort reason
+        if rendered_or_redirected?
+          # lol
+        elsif request.xhr?
+          # TODO bad request might only be appropriate for invalid requests, as opposed to just an auth failure.
+          escort_for_bad_request
+        elsif :relogin == reason
+          reset_session # TODO: instead of a full reset, this should just set unauthed so we can remember who the user was without granting them their creds.
+          redirect_to returning_login_path
+        elsif :readonly == reason
+          escort_for_read_only
+        elsif :unauthed == reason
+          escort_for_403
+        elsif @current_account.nil? && account_verb_scope?
+          escort_for_login
+        else
+          escort_for_404
+        end
+        false
+      end
+
+
+      private
+
+      def returning_login_path
+        session[:path_after_login] = request.request_uri
+        login_path
+      end
+
+      def escort_for_bad_request
+        log
+        render :nothing => true, :status => 400
+      end
+      def escort_for_read_only
+        log
+        redirect_to :action => :show
+      end
+      def escort_for_login
+        log
+        # render :partial => 'login/account', :status => 401 # unauthorized
+        redirect_to returning_login_path
+      end
+      def escort_for_404
+        if partial_exists? 'shared/status_404'
+          render :partial => 'shared/status_404', :layout => true
+        else
+          render :file => File.join(RAILS_ROOT, 'public/404.html'), :status => 404
+        end
+      end
+      def escort_for_403
+        if partial_exists? 'shared/status_404'
+          render :partial => 'shared/status_404', :layout => true
+        else
+          render :file => File.join(RAILS_ROOT, 'public/404.html'), :status => 403
+        end
+      end
+
+    end
+  end
+end

data/lib/hammock/restful_actions.rb

@@ -0,0 +1,170 @@
+module Hammock
+  module RestfulActions
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      # The +index+ action. (GET, safe, idempotent)
+      #
+      # Lists the current resource's records that are visible within the current index scope, defined by +index_scope+ and +index_scope_for+ on the current model.
+      def index
+        if tasks_for_index
+          respond_to do |format|
+            format.html
+            format.xml { render :xml => @records.kick }
+            format.json { render :json => @records.kick }
+            format.yaml { render :text => @records.kick.to_yaml }
+          end
+        end
+      end
+
+      # The +new+ action. (GET, safe, idempotent)
+      #
+      # Renders a form containing the required fields to create a new record.
+      #
+      # This action is available within the same scope as +create+, since it is only useful if a subsequent +create+ would be successful.
+      def new
+        if !tasks_for_new
+          escort :unauthed
+        else
+          render_for_safe_actions
+        end
+      end
+
+      # The +create+ action. (POST, unsafe, non-idempotent)
+      #
+      # Creates a new record with the supplied attributes. TODO
+      def create
+        if !find_record_on_create && !assign_createable
+          escort :unauthed
+        else
+          render_or_redirect_after save_record
+        end
+      end
+
+      # The +show+ action. (GET, safe, idempotent)
+      #
+      # Displays the specified record if it is within the current read scope, defined by +read_scope+ and +read_scope_for+ on the current model.
+      def show
+        if find_record
+          render_for_safe_actions if callback(:before_show)
+        end
+      end
+
+      # The +edit+ action. (GET, safe, idempotent)
+      #
+      # Renders a form containing the fields populated with the current record's attributes.
+      #
+      # This action is available within the same scope as +update+, since it is only useful if a subsequent +update+ would be successful.
+      def edit
+        if find_record
+          render_for_safe_actions if callback(:before_modify) and callback(:before_edit)
+        end
+      end
+
+      # The +update+ action. (PUT, unsafe, idempotent)
+      #
+      # Updates the specified record with the supplied attributes if it is within the current write scope, defined by +write_scope+ and +write_scope_for+ on the current model.
+      def update
+        if find_record
+          # If params[:attribute] is given, update only that attribute. We mass-assign either way to filter through attr_accessible.
+          @record.attributes = if (attribute_name = params[:attribute])
+            { attribute_name => params_for(mdl.symbolize)[attribute_name] }
+          else
+            params_for mdl.symbolize
+          end
+
+          render_or_redirect_after save_record
+        end
+      end
+
+      # The +destroy+ action. (DELETE, unsafe, non-idempotent)
+      #
+      # Destroys the specified record if it is within the current write scope, defined by +write_scope+ and +write_scope_for+ on the current model.
+      def destroy
+        if find_record
+          result = callback(:before_destroy) and @record.destroy and callback(:after_destroy)
+          render_for_destroy result
+        end
+      end
+
+      # The +undestroy+ action. (POST, unsafe, idempotent)
+      #
+      # Reverses a previous destroy on the specified record if it is within the current write scope, defined by +write_scope+ and +write_scope_for+ on the current model.
+      def undestroy
+        if find_deleted_record
+          result = callback(:before_undestroy) and @record.undestroy and callback(:after_undestroy)
+          render_for_destroy result
+        end
+      end
+
+      # The +suggest+ action. (GET, safe, idempotent)
+      #
+      # Lists the current resource's records that would be listed by an index, filtered to show only those where at least one of the specified keys matches each whitespace-separated term in the query.
+      def suggest
+        @results = if params[:q].blank?
+          log 'No query specified.'
+        elsif params[:fields].blank?
+          log "No fields specified."
+        elsif !callback(:before_suggest)
+          # fail
+        else
+          fields = params[:fields].split(',')
+          @queries = params[:q].downcase.split(/\s+/)
+
+          mdl.suggest fields, @queries
+        end
+        
+        if @results.nil?
+          escort_for_bad_request
+        else
+          callback(:after_suggest)
+          render :action => "suggest_#{fields.join(',')}", :layout => false
+        end
+      end
+
+
+      private
+
+      def tasks_for_index
+        retrieve_resource and callback(:before_index) and (!inline_createable_resource? || tasks_for_new)
+      end
+
+      def tasks_for_new
+        callback(:before_modify) and callback(:before_new) if assign_createable
+      end
+
+      def find_record_on_create
+        if findable_on_create?
+          if record = nest_scope.find(:first, :conditions => params_for(mdl.symbolize))
+            log "suitable record already exists: #{record}"
+            assign_entity record
+          else
+            log "couldn't find a suitable record, proceeding with creation."
+          end
+        end
+      end
+
+      def save_record
+        verb = @record.new_record? ? 'create' : 'update'
+        if callback("before_#{verb}") and callback(:before_save) and save
+          callback("after_#{verb}") and callback(:after_save)
+        else
+          log "#{mdl} errors: " + @record.errors.full_messages.join(', ')
+          callback("after_failed_#{verb}") and callback(:after_failed_save) and false
+        end
+      end
+
+      def save
+        @record.save
+      end
+
+    end
+  end
+end

data/lib/hammock/restful_rendering.rb

@@ -0,0 +1,114 @@
+module Hammock
+  module RestfulRendering
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      private
+
+      def render_or_redirect_after result
+        if request.xhr?
+          render_for_safe_actions result, :editable => true, :edit => false
+        else
+          if postsave_render result
+            # rendered - no redirect
+          elsif result
+            render_http_success
+          else
+            render_http_failure
+          end
+        end
+      end
+
+      def render_for_safe_actions result = true, opts = {}
+        if request.xhr?
+          if params[:attribute]
+            render_attribute opts
+          elsif params[:display_as]
+            render_as
+          else
+            respond_to {|format|
+              format.html { render :template => "#{controller_name}/#{action_name}", :layout => false }
+              format.xml
+              format.js
+            }
+          end
+        else
+          respond_to do |format|
+            format.html
+            format.xml { render :xml => @record }
+            format.js
+          end unless rendered_or_redirected?
+        end
+      end
+
+      def render_http_success
+        flash[:notice] = "#{mdl} was successfully #{@record.new_or_deleted_before_save? ? 'created' : 'updated'}."
+        respond_to do |format|
+          format.html {
+            default_redirect_path = postsave_redirect || nested_path_for(inline_createable_resource? ? mdl : @entity)
+
+            if params[:redirect] == 'back'
+              redirect_back_or default_redirect_path
+            else
+              redirect_to default_redirect_path
+            end
+          }
+          format.xml {
+            if @record.new_or_deleted_before_save?
+              render :xml => @record, :status => :created, :location => @record
+            else # update
+              head :ok
+            end
+          }
+          format.js
+          format.json { render :json => {:result => 'success'}.to_json }
+        end
+      end
+      
+      def render_http_failure
+        respond_to do |format|
+          format.html {
+            if inline_createable_resource?
+              tasks_for_index
+              render :action => :index
+            else
+              render :action => (@record.new_record? ? 'new' : 'edit')
+            end
+          }
+          format.xml { render :xml => @record.errors, :status => :unprocessable_entity }
+          format.js
+          format.json { render :json => {:result => 'failure'}.to_json }
+        end
+      end
+
+      def render_attribute opts = {}
+        render :partial => "restful/attribute", :locals => {
+          :record => @record,
+          :attribute => params[:attribute],
+          :editable => opts[:editable],
+          :editing => editing?(@record)
+        }
+      end
+
+      def render_for_destroy success, opts = {}
+        if request.xhr?
+          render :partial => "shared/#{action_name}", :locals => { :record => @record }
+        else
+          respond_to do |format|
+            format.html { redirect_to postdestroy_redirect || nested_path_for(@record.class) }
+            format.xml  { head :ok }
+            format.js { render :partial => "shared/#{action_name}", :locals => {:record => @record} }
+          end
+        end
+      end
+
+    end
+  end
+end