gin 0.0.0 → 1.0.0

data/lib/gin/core_ext/cgi.rb

@@ -0,0 +1,15 @@
+require 'cgi'
+
+unless RUBY_VERSION >= "2.0"
+
+class CGI #:nodoc:
+  class << self
+    alias_method :__escapeHTML, :escapeHTML
+  end
+
+  def self.escapeHTML str
+    __escapeHTML(str).gsub!("'", "&#39;")
+  end
+end
+
+end

data/lib/gin/core_ext/gin_class.rb

@@ -0,0 +1,10 @@
+module GinClass #:nodoc:
+  private
+
+  def class_proxy name, *names
+    names.unshift name
+    names.each do |n|
+      define_method(n){|*args,&block| self.class.send(n,*args,&block) }
+    end
+  end
+end

data/lib/gin/errorable.rb

@@ -0,0 +1,113 @@
+module Gin::Errorable
+  extend GinClass
+
+  def self.included klass
+    klass.extend ClassMethods
+  end
+
+
+  module ClassMethods
+
+    ##
+    # Define an error handler for this Controller. Configurable with exceptions
+    # or status codes. Omitting the err_types argument acts as a catch-all for
+    # non-explicitly handled errors.
+    #
+    #   error 502, 503, 504 do
+    #     # handle unexpected upstream error
+    #   end
+    #
+    #   error do |err|
+    #     # catch-all
+    #   end
+    #
+    #   error Timeout::Error do |err|
+    #     # something timed out
+    #   end
+
+    def error *err_types, &block
+      return unless block_given?
+      err_types << nil if err_types.empty?
+
+      err_types.each do |name|
+        self.error_handlers[name] = block
+      end
+    end
+
+
+    ##
+    # Run after an error has been raised and optionally handled by an
+    # error callback. The block will get run on all errors and is given
+    # the exception instance as an argument.
+    # Note: This block will not get run after http status error handlers.
+
+    def all_errors &block
+      return unless block_given?
+      self.error_handlers[:all] = block
+    end
+
+
+    ##
+    # Hash of error handlers defined by Gin::Controller.error.
+
+    def error_handlers
+      @err_handlers ||= {}
+    end
+
+
+    ##
+    # Find the appropriate error handler for the given error.
+    # First looks for handler in the current class, then looks
+    # in parent classes if none is found.
+
+    def error_handler_for err #:nodoc:
+      handler =
+        case err
+        when Integer
+          error_handlers[err] || error_handlers[nil]
+
+        when Exception
+          klasses = err.class.ancestors[0...-3]
+          key = klasses.find{|klass| error_handlers[klass] }
+          error_handlers[key]
+
+        else
+          error_handlers[err]
+        end
+
+        handler ||
+          self.superclass.respond_to?(:error_handler_for) &&
+            self.superclass.error_handler_for(err)
+    end
+  end
+
+
+  class_proxy :error_handlers, :error_handler_for
+
+  ##
+  # Calls the appropriate error handlers for the given error.
+  # Re-raises the error if no handler is found.
+
+  def handle_error err
+    (@env[Gin::App::RACK_KEYS[:errors]] ||= []) << err
+    status(err.http_status) if err.respond_to?(:http_status)
+    status(500) unless (400..599).include? status
+
+    handler = error_handler_for(err)
+    instance_exec(err, &handler) if handler
+
+    ahandler = error_handler_for(:all)
+    instance_exec(err, &ahandler) if ahandler
+
+    raise err unless handler
+  end
+
+
+  ##
+  # Calls the appropriate error handlers for the given status code.
+
+  def handle_status code
+    handler = error_handler_for(code)
+    instance_exec(&handler) if handler
+  end
+end

data/lib/gin/filterable.rb

@@ -0,0 +1,200 @@
+module Gin::Filterable
+
+  extend GinClass
+
+  class InvalidFilterError < Gin::Error; end
+
+  def self.included klass
+    klass.extend ClassMethods
+  end
+
+
+  module ClassMethods
+
+    ##
+    # Create a filter for controller actions.
+    #   filter :logged_in do
+    #     @user && @user.logged_in?
+    #   end
+    #
+    # Use Gin::Controller.before_filter and Gin::Controller.after_filter to
+    # apply filters.
+
+    def filter name, &block
+      self.filters[name.to_sym] = block
+    end
+
+
+    ##
+    # Hash of filters defined by Gin::Controller.filter.
+    # This attribute is inherited.
+
+    def filters
+      @filters ||= self.superclass.respond_to?(:filters) ?
+                     self.superclass.filters.dup : {}
+    end
+
+
+    def modify_filter_stack filter_hsh, name, *names #:nodoc:
+      names = [name].concat(names)
+      opts  = Hash === names[-1] ? names.pop : {}
+      names.map!(&:to_sym)
+
+      if opts[:only]
+        Array(opts[:only]).each do |action|
+          action = action.to_sym
+          filter_hsh[action] ||= filter_hsh[nil].dup
+          yield filter_hsh, action, names
+        end
+
+      elsif opts[:except]
+        except = Array(opts[:except])
+        filter_hsh.keys.each do |action|
+          next if action.nil?
+          filter_hsh[action] ||= filter_hsh[nil].dup and next if
+            except.include?(action)
+
+          yield filter_hsh, action, names
+        end
+        yield filter_hsh, nil, names
+
+      else
+        filter_hsh.keys.each do |action|
+          yield filter_hsh, action, names
+        end
+      end
+    end
+
+
+    def append_filters filter_hsh, name, *names #:nodoc:
+      modify_filter_stack(filter_hsh, name, *names) do |h,k,n|
+        h[k].concat n
+      end
+    end
+
+
+    def skip_filters filter_hsh, name, *names #:nodoc:
+      modify_filter_stack(filter_hsh, name, *names) do |h,k,n|
+        h[k] -= n
+      end
+    end
+
+
+    ##
+    # Assign one or more filters to run before calling an action.
+    # Set for all actions by default.
+    # This attribute is inherited.
+    # Supports an options hash as the last argument with :only and :except
+    # keys.
+    #
+    #   before_filter :logged_in, :except => :index do
+    #     verify_session! || halt 401
+    #   end
+
+    def before_filter name, *opts, &block
+      filter(name, &block) if block_given?
+      append_filters(before_filters, name, *opts)
+    end
+
+
+    ##
+    # List of before filters.
+    # This attribute is inherited.
+
+    def before_filters
+      return @before_filters if @before_filters
+      @before_filters ||= {nil => []}
+
+      if superclass.respond_to?(:before_filters)
+        superclass.before_filters.each{|k,v| @before_filters[k] = v.dup }
+      end
+
+      @before_filters
+    end
+
+
+    ##
+    # Skip a before filter in the context of the controller.
+    # This attribute is inherited.
+    # Supports an options hash as the last argument with :only and :except
+    # keys.
+
+    def skip_before_filter name, *names
+      skip_filters(self.before_filters, name, *names)
+    end
+
+
+    ##
+    # Assign one or more filters to run after calling an action.
+    # Set for all actions by default.
+    # This attribute is inherited.
+    # Supports an options hash as the last argument with :only and :except
+    # keys.
+    #
+    #   after_filter :clear_cookies, :only => :logout do
+    #     session[:user] = nil
+    #   end
+
+    def after_filter name, *opts, &block
+      filter(name, &block) if block_given?
+      append_filters(self.after_filters, name, *opts)
+    end
+
+
+    ##
+    # List of after filters.
+
+    def after_filters
+      return @after_filters if @after_filters
+      @after_filters ||= {nil => []}
+
+      if superclass.respond_to?(:after_filters)
+        superclass.after_filters.each{|k,v| @after_filters[k] = v.dup }
+      end
+
+      @after_filters
+    end
+
+
+    ##
+    # Skip an after filter in the context of the controller.
+    # This attribute is inherited.
+    # Supports an options hash as the last argument with :only and :except
+    # keys.
+
+    def skip_after_filter name, *names
+      skip_filters(self.after_filters, name, *names)
+    end
+
+
+    ##
+    # Get an Array of before filter names for the given action.
+
+    def before_filters_for action
+      before_filters[action] || before_filters[nil] || []
+    end
+
+
+    ##
+    # Get an Array of after filter names for the given action.
+
+    def after_filters_for action
+      after_filters[action] || after_filters[nil] || []
+    end
+  end
+
+
+  class_proxy :filters, :before_filters, :after_filters,
+              :before_filters_for, :after_filters_for
+
+  ##
+  # Chain-call filters from an action. Raises the filter exception if any
+  # filter in the chain fails.
+  #   filter :logged_in, :admin
+
+  def filter *names
+    names.each do |n|
+      instance_eval(&self.filters[n.to_sym])
+    end
+  end
+end

data/lib/gin/reloadable.rb

@@ -0,0 +1,90 @@
+module Gin::Reloadable #:nodoc:
+  extend GinClass
+
+  def self.included klass
+    klass.extend ClassMethods
+  end
+
+
+  module ClassMethods #:nodoc:
+    def reloadables
+      @reloadables ||= {}
+    end
+
+
+    def erase_dependencies!
+      reloadables.each do |key, (path, files, consts)|
+        erase! files, consts
+      end
+      true
+    end
+
+
+    def erase! files, consts, parent=nil
+      parent ||= Object
+      files.each{|f| $LOADED_FEATURES.delete f }
+      clear_constants parent, consts
+    end
+
+
+    def clear_constants parent, names=nil
+      names ||= parent.constants
+
+      names.each do |name|
+        const = parent.const_get(name)
+        next unless const
+
+        if Class === const
+          next unless parent == Object || const.name =~ /(^|::)#{parent.name}::/
+          clear_constants const
+          parent.send(:remove_const, name)
+        else
+          parent.send(:remove_const, name) rescue nil
+        end
+      end
+    end
+
+
+    def without_warnings &block
+      warn_level = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = warn_level
+    end
+
+
+    def track_require file
+      old_consts   = Object.constants
+      old_features = $LOADED_FEATURES.dup
+
+      filepath = Gin.find_loadpath file
+
+      if !reloadables[filepath]
+        success = Object.send(:require, file)
+
+      else reloadables[filepath]
+        without_warnings{
+          success = Object.send(:require, file)
+        }
+      end
+
+      reloadables[filepath] = [
+        file,
+        $LOADED_FEATURES - old_features,
+        Object.constants - old_consts
+      ] if success
+
+      success
+    end
+
+
+    def require file
+      if autoreload
+        track_require file
+      else
+        super file
+      end
+    end
+  end
+end

data/lib/gin/request.rb

@@ -0,0 +1,76 @@
+class Gin::Request < Rack::Request
+
+  def initialize env
+    super
+    self.params.update env[Gin::App::RACK_KEYS[:path_params]] if
+      env[Gin::App::RACK_KEYS[:path_params]]
+  end
+
+
+  def forwarded?
+    @env.include? "HTTP_X_FORWARDED_HOST"
+  end
+
+
+  def ssl?
+    scheme == 'https'
+  end
+
+
+  def safe?
+    get? or head? or options? or trace?
+  end
+
+
+  def idempotent?
+    safe? or put? or delete?
+  end
+
+
+  def params
+    unless @params
+      super
+      @params = process_params @params
+    end
+
+    @params
+  end
+
+
+  private
+
+  M_BOOLEAN = /^true|false$/  #:nodoc:
+  M_FLOAT   = /^\d+\.\d+$/    #:nodoc:
+  M_INTEGER = /^\d+$/         #:nodoc:
+
+  ##
+  # Enable string or symbol key access to the nested params hash.
+  # Make String numbers into Numerics.
+
+  def process_params object
+    case object
+    when Hash
+      new_hash = indifferent_hash
+      object.each { |key, value| new_hash[key] = process_params(value) }
+      new_hash
+    when Array
+      object.map { |item| process_params(item) }
+    when M_BOOLEAN
+      object == "true"
+    when M_FLOAT
+      object.to_f
+    when M_INTEGER
+      object.to_i
+    else
+      object
+    end
+  end
+
+
+  ##
+  # Creates a Hash with indifferent access.
+
+  def indifferent_hash
+    Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+  end
+end