hammock 0.2.11.2

data/lib/hammock/monkey_patches/string.rb

@@ -0,0 +1,197 @@
+module Hammock
+  module StringPatches
+    MixInto = String
+    
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      # Generates a random string consisting of +length+ hexadecimal characters (i.e. matching [0-9a-f]{length}).
+      def af09 length = 1
+        (1..length).inject('') {|a, t|
+          a << rand(16).to_s(16)
+        }
+      end
+
+      # Generates a random string consisting of +length+ alphamuneric characters (i.e. matching [0-9a-zA-Z]{length}).
+      def azAZ09 length = 1
+        (1..length).inject('') {|a, t|
+          a << ((r = rand(62)) < 36 ? r.to_s(36) : (r - 26).to_s(36).upcase)
+        }
+      end
+
+    end
+
+    module InstanceMethods
+
+      # Returns true iff +str+ appears exactly at the start of +self+.
+      def starts_with? str
+        self[0, str.length] == str
+      end
+
+      # Returns true iff +str+ appears exactly at the end of +self+.
+      def ends_with? str
+        self[-str.length, str.length] == str
+      end
+
+      # Return a duplicate of +self+, with +str+ prepended to it if it doesn't already start with +str+.
+      def start_with str
+        starts_with?(str) ? self : str + self
+      end
+
+      # Return a duplicate of +self+, with +str+ appended to it if it doesn't already end with +str+.
+      def end_with str
+        ends_with?(str) ? self : self + str
+      end
+
+      def possessive
+        "#{self}'#{'s' unless ends_with?('s')}"
+      end
+
+      # TODO any more to add?
+      NamePrefixes = %w[de den la von].freeze
+
+      def capitalize_name
+        split(' ').map {|term|
+          term.split('-').map {|term|
+            if NamePrefixes.include?(term)
+              term.downcase
+            elsif (term != term.downcase)
+              term
+            else # only capitalize words that are entirely lower case
+              term.capitalize
+            end
+          }.join('-')
+        }.join(' ')
+      end
+
+      def capitalize_name!
+        self.replace self.capitalize_name
+      end
+
+      # Returns whether this IP should be considered a valid one for a client to be using.
+      def valid_ip?
+        if production?
+          describe_as_ip == :public
+        else
+          describe_as_ip.in? :public, :private, :loopback
+        end
+      end
+
+      # Returns a symbol describing the class of IP address +self+ represents, if any.
+      #
+      # Examples:
+      #
+      #     "Hello world!".valid_ip?   #=> false
+      #     "192.168.".valid_ip?       #=> false
+      #     "127.0.0.1".valid_ip?      #=> :loopback
+      #     "172.24.137.6".valid_ip?   #=> :private
+      #     "169.254.1.142".valid_ip?  #=> :self_assigned
+      #     "72.9.108.122".valid_ip?   #=> :public
+      def describe_as_ip
+        parts = strip.split('.')
+        bytes = parts.zip(parts.map(&:to_i)).map {|(str,val)|
+          val if ((1..255) === val) || (val == 0 && str == '0')
+        }.squash
+
+        if bytes.length != 4
+          false
+        elsif bytes.starts_with? 0 # Source hosts on "this" network
+          :reserved
+        elsif bytes.starts_with? 127 # Loopback network; RFC1700
+          :loopback
+        elsif bytes.starts_with? 10 # Class-A private; RFC1918
+          :private
+        elsif bytes.starts_with?(172) && ((16..31) === bytes[1]) # Class-B private; RFC1918
+          :private
+        elsif bytes.starts_with? 169, 254 # Link-local range; RFC3330/3927
+          bytes[2].in?(0, 255) ? :reserved : :self_assigned
+        elsif bytes.starts_with? 192, 0, 2 # TEST-NET - used as example.com IP
+          :reserved
+        elsif bytes.starts_with? 192, 88, 99 # 6-to-4 relay anycast; RFC3068
+          :reserved
+        elsif bytes.starts_with? 192, 168 # Class-C private; RFC1918
+          :private
+        elsif bytes.starts_with? 198, 18 # Benchmarking; RFC2544
+          :reserved
+        else
+          :public
+        end
+      end
+
+      # Returns true if the string represents a valid email address.
+      def valid_email?
+        /^([a-z0-9\-\+\_\.]{2,})\@([a-z0-9\-]+\.)*([a-z0-9\-]{2,}\.)([a-z0-9\-]{2,})$/ =~ self
+      end
+
+      def colorize description = '', start_at = nil
+        if start_at.nil? || (cut_point = index(start_at)).nil?
+          Colorizer.colorize self, description
+        else
+          self[0...cut_point] + Colorizer.colorize(self[cut_point..-1], description)
+        end
+      end
+
+      def colorize! description = '', start_at = nil
+        replace colorize(description, start_at)
+      end
+
+      private
+
+      class Colorizer
+        HomeOffset = 29
+        LightOffset = 60
+        BGOffset = 10
+        LightRegex = /^light_/
+        ColorRegex = /^(light_)?none|gr[ae]y|red|green|yellow|blue|pink|cyan|white$/
+        CtrlRegex = /^bold|underlined?|blink(ing)?|reversed?$/
+        ColorOffsets = {
+          'none' => 0,
+          'gray' => 1, 'grey' => 1,
+          'red' => 2,
+          'green' => 3,
+          'yellow' => 4,
+          'blue' => 5,
+          'pink' => 6,
+          'cyan' => 7,
+          'white' => 8
+        }
+        CtrlOffsets = {
+          'bold' => 1,
+          'underline' => 4, 'underlined' => 4,
+          'blink' => 5, 'blinking' => 5,
+          'reverse' => 7, 'reversed' => 7
+        }
+        class << self
+          def colorize text, description
+            terms = " #{description} ".gsub(' light ', ' light_').gsub(' on ', ' on_').strip.split(/\s+/)
+            bg = terms.detect {|i| /on_#{ColorRegex}/ =~ i }
+            fg = terms.detect {|i| ColorRegex =~ i }
+            ctrl = terms.detect {|i| CtrlRegex =~ i }
+
+            "\e[#{"0;#{fg_for(fg)};#{bg_for(bg) || ctrl_for(ctrl)}"}m#{text}\e[0m"
+          end
+
+          def fg_for name
+            light = name.gsub!(LightRegex, '') unless name.nil?
+            (ColorOffsets[name] || 0) + HomeOffset + (light ? LightOffset : 0)
+          end
+
+          def bg_for name
+            # There's a hole in the table on bg=none, so we use BGOffset to the left
+            offset = fg_for((name || '').sub(/^on_/, ''))
+            offset + BGOffset unless offset == HomeOffset
+          end
+
+          def ctrl_for name
+            CtrlOffsets[name] || HomeOffset
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hammock/overrides.rb

@@ -0,0 +1,36 @@
+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 suggest_scope
+        mdl.readable_by current_user
+      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,119 @@
+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
+          if pagination_enabled?
+            assign_entity scope.paginate(:page => params[:page])
+          else
+            assign_entity scope
+          end
+        end
+      end
+
+      def retrieve_record finder
+        if (scope = current_scope).nil?
+
+        else
+          record = scope.send finder, :first, :conditions => {mdl.routing_attribute => 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_user.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,172 @@
+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.send :with_scope, :find => suggest_scope.to_hash do
+            mdl.suggest fields, @queries
+          end
+        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 = current_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