gin 1.0.3 → 1.0.4

data/History.rdoc

@@ -1,4 +1,16 @@
-=== 1.0.2 / 2013-03-12
+=== 1.0.4 / 2013-03-19
+
+* Minor Enhancements
+  * Gin no longer relies on Rack::CommonLogger
+  * Allow routes to default with a custom HTTP verb
+  * Gin::Controller#delete_cookie helper method
+
+* Bugfixes
+  * Fix for reloading of required files
+  * Fix for routing HTTP verbs that don't have routes mounted to them
+  * Better check before extending the CGI class
+
+=== 1.0.3 / 2013-03-12
 
 * Minor Enhancements
   * Routes have priority over static assets

data/Manifest.txt

@@ -7,9 +7,11 @@ Rakefile
 lib/gin.rb
 lib/gin/app.rb
 lib/gin/config.rb
+lib/gin/constants.rb
 lib/gin/controller.rb
 lib/gin/core_ext/cgi.rb
 lib/gin/core_ext/gin_class.rb
+lib/gin/core_ext/rack_commonlogger.rb
 lib/gin/errorable.rb
 lib/gin/filterable.rb
 lib/gin/reloadable.rb

data/README.rdoc

@@ -4,10 +4,8 @@
 
 == Description
 
-Gin is a small web framework built from the redistillation of
-Sinatra and Rails idioms. Specifically, it uses much of Sinatra's
-request flow and HTTP helper methods with dedicated controller classes
-that support Rails-like filters.
+Gin is a small Ruby web framework, built on Rack, which borrows from
+Sinatra expressiveness, and targets larger applications.
 
 == Hello World
 

data/lib/gin.rb

@@ -1,8 +1,7 @@
-require 'logger'
 require 'rack'
 
 class Gin
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
 
   LIB_DIR    = File.expand_path("..", __FILE__)            #:nodoc:
   PUBLIC_DIR = File.expand_path("../../public/", __FILE__) #:nodoc:
@@ -108,7 +107,9 @@ class Gin
 
   require 'gin/core_ext/cgi'
   require 'gin/core_ext/gin_class'
+  require 'gin/core_ext/rack_commonlogger'
 
+  require 'gin/constants'
   require 'gin/app'
   require 'gin/router'
   require 'gin/config'

data/lib/gin/app.rb

@@ -13,21 +13,10 @@
 
 class Gin::App
   extend GinClass
+  include Gin::Constants
 
   class RouterError < Gin::Error; end
 
-  RACK_KEYS = { #:nodoc:
-    :stack       => 'gin.stack'.freeze,
-    :http_route  => 'gin.http_route'.freeze,
-    :path_params => 'gin.path_query_hash'.freeze,
-    :controller  => 'gin.controller'.freeze,
-    :action      => 'gin.action'.freeze,
-    :static      => 'gin.static'.freeze,
-    :reloaded    => 'gin.reloaded'.freeze,
-    :errors      => 'gin.errors'.freeze
-  }.freeze
-
-
   CALLERS_TO_IGNORE = [ # :nodoc:
     /\/gin(\/(.*?))?\.rb$/,             # all gin code
     /lib\/tilt.*\.rb$/,                 # all tilt code
@@ -76,7 +65,7 @@ class Gin::App
     end
 
     if @autoreload && (!defined?(Gin::Reloadable) || !include?(Gin::Reloadable))
-      require 'gin/reloadable'
+      Object.send :require, 'gin/reloadable'
       include Gin::Reloadable
     end
 
@@ -84,6 +73,18 @@ class Gin::App
   end
 
 
+  ##
+  # Custom require used for auto-reloading.
+
+  def self.require file
+    if autoreload
+      track_require file
+    else
+      super file
+    end
+  end
+
+
   ##
   # Mount a Gin::Controller into the App and specify a base path. If controller
   # mounts at root, use "/" as the base path.
@@ -352,7 +353,7 @@ class Gin::App
 
   def self.environment env=nil
     @environment = env if env
-    @environment ||= ENV['RACK_ENV'] || "development"
+    @environment ||= ENV['RACK_ENV'] || ENV_DEV
   end
 
 
@@ -360,7 +361,7 @@ class Gin::App
   # Check if running in development mode.
 
   def self.development?
-    self.environment == "development"
+    self.environment == ENV_DEV
   end
 
 
@@ -368,7 +369,7 @@ class Gin::App
   # Check if running in test mode.
 
   def self.test?
-    self.environment == "test"
+    self.environment == ENV_TEST
   end
 
 
@@ -376,7 +377,7 @@ class Gin::App
   # Check if running in staging mode.
 
   def self.staging?
-    self.environment == "staging"
+    self.environment == ENV_STAGE
   end
 
 
@@ -384,7 +385,7 @@ class Gin::App
   # Check if running in production mode.
 
   def self.production?
-    self.environment == "production"
+    self.environment == ENV_PROD
   end
 
 
@@ -412,12 +413,12 @@ class Gin::App
   def initialize rack_app=nil, logger=nil
     load_config
 
-    if !rack_app.respond_to?(:call) && rack_app.respond_to?(:log) && logger.nil?
+    if !rack_app.respond_to?(:call) && rack_app.respond_to?(:<<) && logger.nil?
       @rack_app = nil
       @logger   = rack_app
     else
       @rack_app = rack_app
-      @logger   = Logger.new $stdout
+      @logger   = $stdout
     end
 
     validate_all_controllers!
@@ -434,7 +435,6 @@ class Gin::App
   # If you use this in production, you're gonna have a bad time.
 
   def reload!
-    return unless autoreload
     @mutex ||= Mutex.new
 
     @mutex.synchronize do
@@ -443,7 +443,7 @@ class Gin::App
                         self.class.namespace
 
       self.class.erase_dependencies!
-      Object.send(:require, self.class.source_file)
+      require self.class.source_file
       @app = self.class.source_class.new @rack_app, @logger
     end
   end
@@ -474,8 +474,8 @@ class Gin::App
   # Check if autoreload is needed and reload.
 
   def try_autoreload env
-    return if env[RACK_KEYS[:reloaded]]
-    env[RACK_KEYS[:reloaded]] = true
+    return if env[GIN_RELOADED] || !autoreload
+    env[GIN_RELOADED] = true
     reload!
   end
 
@@ -484,13 +484,14 @@ class Gin::App
   # Call App instance stack without static file lookup or reloading.
 
   def call! env
-    if env[RACK_KEYS[:stack]]
-      env.delete RACK_KEYS[:stack]
-      dispatch env, env[RACK_KEYS[:controller]], env[RACK_KEYS[:action]]
+    if env[GIN_STACK]
+      dispatch env, env[GIN_CTRL], env[GIN_ACTION]
 
     else
-      env[RACK_KEYS[:stack]] = true
-      @stack.call env
+      env[GIN_STACK] = true
+      with_log_request(env) do
+        @stack.call env
+      end
     end
   end
 
@@ -500,7 +501,9 @@ class Gin::App
   # env filename.
 
   def call_static env
-    error_delegate.exec(self, env){ send_file env[RACK_KEYS[:static]] }
+    with_log_request(env) do
+      error_delegate.exec(self, env){ send_file env[GIN_STATIC] }
+    end
   end
 
 
@@ -509,13 +512,13 @@ class Gin::App
   # variable to the filepath.
 
   def static! env
-    filepath = %w{GET HEAD}.include?(env['REQUEST_METHOD']) &&
-               asset(env['PATH_INFO'])
+    filepath = %w{GET HEAD}.include?(env[REQ_METHOD]) &&
+               asset(env[PATH_INFO])
 
-    filepath ? (env[RACK_KEYS[:static]] = filepath) :
-                env.delete(RACK_KEYS[:static])
+    filepath ? (env[GIN_STATIC] = filepath) :
+                env.delete(GIN_STATIC)
 
-    !!env[RACK_KEYS[:static]]
+    !!env[GIN_STATIC]
   end
 
 
@@ -525,15 +528,15 @@ class Gin::App
   # and gin.http_route env variables.
 
   def route! env
-    http_route = "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
-    return true if env[RACK_KEYS[:http_route]] == http_route
+    http_route = "#{env[REQ_METHOD]} #{env[PATH_INFO]}"
+    return true if env[GIN_ROUTE] == http_route
 
-    env[RACK_KEYS[:controller]], env[RACK_KEYS[:action]], env[RACK_KEYS[:path_params]] =
-      router.resources_for env['REQUEST_METHOD'], env['PATH_INFO']
+    env[GIN_CTRL], env[GIN_ACTION], env[GIN_PATH_PARAMS] =
+      router.resources_for env[REQ_METHOD], env[PATH_INFO]
 
-    env[RACK_KEYS[:http_route]] = http_route
+    env[GIN_ROUTE] = http_route
 
-    !!(env[RACK_KEYS[:controller]] && env[RACK_KEYS[:action]])
+    !!(env[GIN_CTRL] && env[GIN_ACTION])
   end
 
 
@@ -560,7 +563,7 @@ class Gin::App
 
   def dispatch env, ctrl, action
     raise Gin::NotFound,
-      "No route exists for: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}" unless
+      "No route exists for: #{env[REQ_METHOD]} #{env[PATH_INFO]}" unless
       ctrl && action
 
     ctrl.new(self, env).call_action action
@@ -577,8 +580,6 @@ class Gin::App
     delegate = error_delegate
 
     begin
-      trace = Gin.app_trace(Array(err.backtrace)).join("\n")
-      logger.error("#{err.class.name}: #{err.message}\n#{trace}")
       delegate.exec(self, env){ handle_error(err) }
 
     rescue ::Exception => err
@@ -591,6 +592,39 @@ class Gin::App
   private
 
 
+  LOG_FORMAT = %{%s - %s [%s] "%s %s%s" %s %d %s %0.4f %s\n}.freeze #:nodoc:
+  TIME_FORMAT = "%d/%b/%Y %H:%M:%S".freeze #:nodoc:
+
+  def log_request env, resp
+    now  = Time.now
+    time = now - env[GIN_TIMESTAMP] if env[GIN_TIMESTAMP]
+
+    ctrl, action = env[GIN_CTRL], env[GIN_ACTION]
+    target = "#{ctrl}##{action}" if ctrl && action
+
+    @logger << ( LOG_FORMAT % [
+        env[FWD_FOR] || env[REMOTE_ADDR] || "-",
+        env[REMOTE_USER] || "-",
+        now.strftime(TIME_FORMAT),
+        env[REQ_METHOD],
+        env[PATH_INFO],
+        env[QUERY_STRING].to_s.empty? ? "" : "?#{env[QUERY_STRING]}",
+        env[HTTP_VERSION] || "HTTP/1.1",
+        resp[0],
+        resp[1][CNT_LENGTH] || "-",
+        time || "-",
+        target || "-" ] )
+  end
+
+
+  def with_log_request env
+    env[GIN_TIMESTAMP] ||= Time.now
+    resp = yield
+    log_request env, resp
+    resp
+  end
+
+
   def build_app builder
     setup_sessions   builder
     setup_protection builder

data/lib/gin/constants.rb

@@ -0,0 +1,47 @@
+module Gin::Constants
+  EPOCH = Time.at(0)
+
+  # Rack env constants
+  FWD_FOR        = 'HTTP_X_FORWARDED_FOR'.freeze
+  FWD_HOST       = 'HTTP_X_FORWARDED_HOST'.freeze
+  REMOTE_ADDR    = 'REMOTE_ADDR'.freeze
+  REMOTE_USER    = 'REMOTE_USER'.freeze
+  HTTP_VERSION   = 'HTTP_VERSION'.freeze
+  REQ_METHOD     = 'REQUEST_METHOD'.freeze
+  PATH_INFO      = 'PATH_INFO'.freeze
+  QUERY_STRING   = 'QUERY_STRING'.freeze
+  IF_MATCH       = 'HTTP_IF_MATCH'.freeze
+  IF_NONE_MATCH  = 'HTTP_IF_NONE_MATCH'.freeze
+  IF_MOD_SINCE   = 'HTTP_IF_MODIFIED_SINCE'.freeze
+  IF_UNMOD_SINCE = 'HTTP_IF_UNMODIFIED_SINCE'.freeze
+
+  ASYNC_CALLBACK = 'async.callback'.freeze
+
+  # Rack response header constants
+  ETAG            = 'ETag'.freeze
+  CNT_LENGTH      = 'Content-Length'.freeze
+  CNT_TYPE        = 'Content-Type'.freeze
+  CNT_DISPOSITION = 'Content-Disposition'.freeze
+  LOCATION        = 'Location'.freeze
+  LAST_MOD        = 'Last-Modified'.freeze
+  CACHE_CTRL      = 'Cache-Control'.freeze
+  EXPIRES         = 'Expires'.freeze
+  PRAGMA          = 'Pragma'.freeze
+
+  # Gin env constants
+  GIN_STACK       = 'gin.stack'.freeze
+  GIN_ROUTE       = 'gin.http_route'.freeze
+  GIN_PATH_PARAMS = 'gin.path_query_hash'.freeze
+  GIN_CTRL        = 'gin.controller'.freeze
+  GIN_ACTION      = 'gin.action'.freeze
+  GIN_STATIC      = 'gin.static'.freeze
+  GIN_RELOADED    = 'gin.reloaded'.freeze
+  GIN_ERRORS      = 'gin.errors'.freeze
+  GIN_TIMESTAMP   = 'gin.timestamp'.freeze
+
+  # Environment names
+  ENV_DEV   = "development".freeze
+  ENV_TEST  = "test".freeze
+  ENV_STAGE = "staging".freeze
+  ENV_PROD  = "production".freeze
+end

data/lib/gin/controller.rb

@@ -1,10 +1,15 @@
 class Gin::Controller
   extend  GinClass
+  include Gin::Constants
   include Gin::Filterable
   include Gin::Errorable
 
 
   error Gin::NotFound, Gin::BadRequest, ::Exception do |err|
+    trace = Gin.app_trace(Array(err.backtrace)).join("  \n")
+    trace = "  " << trace << "\n\n" unless trace.empty?
+    logger << "[ERROR] #{err.class.name}: #{err.message}\n#{trace}"
+
     status( err.respond_to?(:http_status) ? err.http_status : 500 )
     @response.headers.clear
     content_type :html
@@ -71,8 +76,7 @@ class Gin::Controller
   def call_action action #:nodoc:
     invoke{ dispatch action }
     invoke{ handle_status(@response.status) }
-    content_type self.class.content_type unless
-      @response[Gin::Response::H_CTYPE]
+    content_type self.class.content_type unless @response[CNT_TYPE]
     @response.finish
   end
 
@@ -107,7 +111,7 @@ class Gin::Controller
   # Get or set the HTTP response Content-Type header.
 
   def content_type type=nil, params={}
-    return @response[Gin::Response::H_CTYPE] unless type
+    return @response[CNT_TYPE] unless type
 
     default   = params.delete(:default)
     mime_type = mime_type(type) || default
@@ -127,7 +131,7 @@ class Gin::Controller
       end.join(', ')
     end
 
-    @response[Gin::Response::H_CTYPE] = mime_type
+    @response[CNT_TYPE] = mime_type
   end
 
 
@@ -175,15 +179,15 @@ class Gin::Controller
 
     value = '"%s"' % value
     value = 'W/' + value if kind == :weak
-    @response['ETag'] = value
+    @response[ETAG] = value
 
     if (200..299).include?(status) || status == 304
-      if etag_matches? @env['HTTP_IF_NONE_MATCH'], new_resource
+      if etag_matches? @env[IF_NONE_MATCH], new_resource
         halt(@request.safe? ? 304 : 412)
       end
 
-      if @env['HTTP_IF_MATCH']
-        halt 412 unless etag_matches? @env['HTTP_IF_MATCH'], new_resource
+      if @env[IF_MATCH]
+        halt 412 unless etag_matches? @env[IF_MATCH], new_resource
       end
     end
   end
@@ -191,7 +195,7 @@ class Gin::Controller
 
   def etag_matches? list, new_resource=@request.post? #:nodoc:
     return !new_resource if list == '*'
-    list.to_s.split(/\s*,\s*/).include? response['ETag']
+    list.to_s.split(/\s*,\s*/).include? response[ETAG]
   end
 
 
@@ -216,7 +220,7 @@ class Gin::Controller
   #   end
 
   def stream keep_open=false, &block
-    scheduler = env['async.callback'] ? EventMachine : Gin::Stream
+    scheduler = env[ASYNC_CALLBACK] ? EventMachine : Gin::Stream
     body Gin::Stream.new(scheduler, keep_open){ |out| yield(out) }
   end
 
@@ -270,6 +274,15 @@ class Gin::Controller
   end
 
 
+  ##
+  # Delete the response cookie with the given name.
+  # Does not affect request cookies.
+
+  def delete_cookie name
+    @response.delete_cookie name
+  end
+
+
   ##
   # Build a path to the given controller and action or route name,
   # with any expected params. If no controller is specified and the
@@ -344,13 +357,13 @@ class Gin::Controller
   #   redirect to(:show_foo, :id => 123)
 
   def redirect uri, *args
-    if @env['HTTP_VERSION'] == 'HTTP/1.1' && @env["REQUEST_METHOD"] != 'GET'
+    if @env[HTTP_VERSION] == 'HTTP/1.1' && @env[REQ_METHOD] != 'GET'
       status 303
     else
       status 302
     end
 
-    @response['Location'] = url_to(uri.to_s)
+    @response[LOCATION] = url_to(uri.to_s)
     halt(*args)
   end
 
@@ -360,7 +373,7 @@ class Gin::Controller
   # Produces a 404 response if no file is found.
 
   def send_file path, opts={}
-    if opts[:type] || !@response[Gin::Response::H_CTYPE]
+    if opts[:type] || !@response[CNT_TYPE]
       content_type opts[:type] || File.extname(path),
                     :default => 'application/octet-stream'
     end
@@ -371,14 +384,14 @@ class Gin::Controller
     filename    = File.basename(path) if filename.nil?
 
     if disposition
-      @response['Content-Disposition'] =
+      @response[CNT_DISPOSITION] =
         "%s; filename=\"%s\"" % [disposition, filename]
     end
 
     last_modified opts[:last_modified] || File.mtime(path).httpdate
     halt 200 if @request.head?
 
-    @response['Content-Length'] = File.size?(path).to_s
+    @response[CNT_LENGTH] = File.size?(path).to_s
     halt 200, File.open(path, "rb")
 
   rescue Errno::ENOENT
@@ -398,20 +411,20 @@ class Gin::Controller
     time = Time.parse(time) if String === time
     time = time.to_time     if time.respond_to?(:to_time)
 
-    @response['Last-Modified'] = time.httpdate
-    return if @env['HTTP_IF_NONE_MATCH']
+    @response[LAST_MOD] = time.httpdate
+    return if @env[IF_NONE_MATCH]
 
-    if status == 200 && @env['HTTP_IF_MODIFIED_SINCE']
+    if status == 200 && @env[IF_MOD_SINCE]
       # compare based on seconds since epoch
-      since = Time.httpdate(@env['HTTP_IF_MODIFIED_SINCE']).to_i
+      since = Time.httpdate(@env[IF_MOD_SINCE]).to_i
       halt 304 if since >= time.to_i
     end
 
-    if @env['HTTP_IF_UNMODIFIED_SINCE'] &&
+    if @env[IF_UNMOD_SINCE] &&
       ((200..299).include?(status) || status == 412)
 
       # compare based on seconds since epoch
-      since = Time.httpdate(@env['HTTP_IF_UNMODIFIED_SINCE']).to_i
+      since = Time.httpdate(@env[IF_UNMOD_SINCE]).to_i
       halt 412 if since < time.to_i
     end
   rescue ArgumentError
@@ -442,7 +455,7 @@ class Gin::Controller
       values << [key, value].join('=')
     end
 
-    @response['Cache-Control'] = values.join(', ') if values.any?
+    @response[CACHE_CTRL] = values.join(', ') if values.any?
   end
 
 
@@ -470,7 +483,7 @@ class Gin::Controller
     values.last.merge!(:max_age => max_age) unless values.last[:max_age]
     cache_control(*values)
 
-    @response['Expires'] = time.httpdate
+    @response[EXPIRES] = time.httpdate
   end
 
 
@@ -479,9 +492,8 @@ class Gin::Controller
   # not to cache the response.
 
   def expire_cache_control
-    @response['Pragma'] = 'no-cache'
-    expires Time.new("1990","01","01"),
-      :no_cache, :no_store, :must_revalidate, max_age: 0
+    @response[PRAGMA] = 'no-cache'
+    expires EPOCH, :no_cache, :no_store, :must_revalidate, max_age: 0
   end
 
 
@@ -579,7 +591,7 @@ class Gin::Controller
   private
 
 
-  DEV_ERROR_HTML = File.read(File.join(Gin::PUBLIC_DIR, "error.html")) #:nodoc:
+  DEV_ERROR_HTML = File.read(File.join(Gin::PUBLIC_DIR, "error.html")).freeze #:nodoc:
 
   BAD_REQ_MSG = "Expected param `%s'" #:nodoc:
 

data/lib/gin/core_ext/cgi.rb

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

data/lib/gin/core_ext/rack_commonlogger.rb

@@ -0,0 +1,7 @@
+class Rack::CommonLogger
+  alias log_without_check log unless method_defined? :log_without_check
+
+  def log env, *args
+    log_without_check(env, *args) unless env[Gin::Constants::GIN_TIMESTAMP]
+  end
+end

data/lib/gin/errorable.rb

@@ -89,7 +89,7 @@ module Gin::Errorable
   # Re-raises the error if no handler is found.
 
   def handle_error err
-    (@env[Gin::App::RACK_KEYS[:errors]] ||= []) << err
+    (@env[Gin::Constants::GIN_ERRORS] ||= []) << err
     status(err.http_status) if err.respond_to?(:http_status)
     status(500) unless (400..599).include? status
 

data/lib/gin/reloadable.rb

@@ -13,7 +13,7 @@ module Gin::Reloadable #:nodoc:
 
 
     def erase_dependencies!
-      reloadables.each do |key, (path, files, consts)|
+      reloadables.each do |key, (_, files, consts)|
         erase! files, consts
       end
       true
@@ -21,26 +21,45 @@ module Gin::Reloadable #:nodoc:
 
 
     def erase! files, consts, parent=nil
-      parent ||= Object
+      parent ||= ::Object
       files.each{|f| $LOADED_FEATURES.delete f }
       clear_constants parent, consts
     end
 
 
-    def clear_constants parent, names=nil
-      names ||= parent.constants
+    def clear_constants root, names=nil
+      each_constant(root, names) do |name, const, parent|
+        if Module === const || !gin_constants[const.object_id]
+          parent.send(:remove_const, name) rescue nil
+        end
+      end
+    end
 
+
+    def gin_constants
+      return @gin_constants if @gin_constants
+      @gin_constants = {Gin.object_id => ::Gin}
+
+      each_constant(Gin) do |name, const, _|
+        @gin_constants[const.object_id] = const
+      end
+
+      @gin_constants
+    end
+
+
+    def each_constant parent, names=nil, &block
+      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
+        if ::Module === const
+          next unless parent == ::Object || const.name =~ /(^|::)#{parent.name}::/
+          each_constant(const, &block)
         end
+
+        block.call name, const, parent
       end
     end
 
@@ -55,36 +74,27 @@ module Gin::Reloadable #:nodoc:
 
 
     def track_require file
-      old_consts   = Object.constants
+      old_consts   = ::Object.constants
       old_features = $LOADED_FEATURES.dup
 
       filepath = Gin.find_loadpath file
 
       if !reloadables[filepath]
-        success = Object.send(:require, file)
+        success = ::Object.send(:require, file)
 
       else reloadables[filepath]
         without_warnings{
-          success = Object.send(:require, file)
+          success = ::Object.send(:require, file)
         }
       end
 
       reloadables[filepath] = [
         file,
         $LOADED_FEATURES - old_features,
-        Object.constants - old_consts
+        ::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

@@ -1,14 +1,14 @@
 class Gin::Request < Rack::Request
+  include Gin::Constants
 
   def initialize env
     super
-    self.params.update env[Gin::App::RACK_KEYS[:path_params]] if
-      env[Gin::App::RACK_KEYS[:path_params]]
+    self.params.update env[GIN_PATH_PARAMS] if env[GIN_PATH_PARAMS]
   end
 
 
   def forwarded?
-    @env.include? "HTTP_X_FORWARDED_HOST"
+    @env.include? FWD_HOST
   end
 
 
@@ -28,12 +28,7 @@ class Gin::Request < Rack::Request
 
 
   def params
-    unless @params
-      super
-      @params = process_params @params
-    end
-
-    @params
+    @params ||= process_params(super) || {}
   end
 
 

data/lib/gin/response.rb

@@ -1,8 +1,7 @@
 class Gin::Response < Rack::Response
+  include Gin::Constants
 
   NO_HEADER_STATUSES = [100, 101, 204, 205, 304].freeze #:nodoc:
-  H_CTYPE   = "Content-Type".freeze   #:nodoc:
-  H_CLENGTH = "Content-Length".freeze #:nodoc:
 
   attr_accessor :status
   attr_reader :body
@@ -16,11 +15,11 @@ class Gin::Response < Rack::Response
 
   def finish
     body_out = body
-    header[H_CTYPE] ||= 'text/html;charset=UTF-8'
+    header[CNT_TYPE] ||= 'text/html;charset=UTF-8'
 
     if NO_HEADER_STATUSES.include?(status.to_i)
-      header.delete H_CTYPE
-      header.delete H_CLENGTH
+      header.delete CNT_TYPE
+      header.delete CNT_LENGTH
 
       if status.to_i > 200
         close
@@ -37,14 +36,14 @@ class Gin::Response < Rack::Response
   private
 
   def update_content_length
-    if header[H_CTYPE] && !header[H_CLENGTH]
+    if header[CNT_TYPE] && !header[CNT_LENGTH]
       case body
       when Array
-        header[H_CLENGTH] = body.inject(0) do |l, p|
-                              l + Rack::Utils.bytesize(p)
-                            end.to_s
+        header[CNT_LENGTH] = body.inject(0) do |l, p|
+                               l + Rack::Utils.bytesize(p)
+                             end.to_s
       when File
-        header[H_CLENGTH] = body.size.to_s
+        header[CNT_LENGTH] = body.size.to_s
       end
     end
   end

data/lib/gin/router.rb

@@ -33,10 +33,12 @@ class Gin::Router
 
 
     # Create restful routes if they aren't taken already.
-    def defaults restful_only=false
+    def defaults default_verb=nil
+      default_verb = (default_verb || 'get').to_s.downcase
+
       (@ctrl.actions - @actions).each do |action|
         verb, path = DEFAULT_ACTION_MAP[action]
-        verb, path = ['get', "/#{action}"] if !restful_only && verb.nil?
+        verb, path = [default_verb, "/#{action}"] if verb.nil?
 
         add(verb, action, path) unless verb.nil? ||
           @routes.any?{|(r,n,(c,a,p))| r == make_route(verb, path)[0] }
@@ -194,6 +196,7 @@ class Gin::Router
   def resources_for http_verb, path
     param_vals = []
     curr_node  = @routes_tree[http_verb.to_s.downcase]
+    return unless curr_node
 
     path.scan(%r{/([^/]+|$)}) do |(key)|
       next if key.empty?

data/test/test_app.rb

@@ -87,8 +87,8 @@ class AppTest < Test::Unit::TestCase
     FooApp.instance_variable_set("@autoreload", nil)
 
     @error_io = StringIO.new
-    @app  = FooApp.new Logger.new(@error_io)
-    @rapp = FooApp.new lambda{|env| [200,{'Content-Type'=>'text/html'},["HI"]]}
+    @app  = FooApp.new @error_io
+    @rapp = FooApp.new lambda{|env| [200,{'Content-Type'=>'text/html'},["HI"]]}, @error_io
   end
 
 
@@ -242,7 +242,7 @@ class AppTest < Test::Unit::TestCase
     assert_equal [FooMiddleware, :foo, :bar], FooApp.middleware[0]
     assert !FooMiddleware.called?
 
-    myapp = FooApp.new
+    myapp = FooApp.new @error_io
     myapp.call({'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET'})
     assert FooMiddleware.called?
 
@@ -254,7 +254,7 @@ class AppTest < Test::Unit::TestCase
 
   def test_call_reload
     FooApp.autoreload true
-    myapp = FooApp.new
+    myapp = FooApp.new @error_io
 
     assert !myapp.reloaded?
     myapp.call 'rack.input' => "", 'PATH_INFO' => '/foo', 'REQUEST_METHOD' => 'GET'
@@ -277,7 +277,7 @@ class AppTest < Test::Unit::TestCase
     env   = {'rack.input' => "", 'PATH_INFO' => '/bad', 'REQUEST_METHOD' => 'GET'}
     expected = [200, {'Content-Length'=>"5"}, "AHOY!"]
     myapp = lambda{|env| expected }
-    @app = FooApp.new myapp
+    @app = FooApp.new myapp, @error_io
 
     resp = @app.call env
     assert_equal expected, resp
@@ -330,7 +330,7 @@ class AppTest < Test::Unit::TestCase
     assert_equal 'text/html;charset=UTF-8', resp[1]['Content-Type']
     assert_equal @app.asset("404.html"), resp[2].path
 
-    msg = "ERROR -- : Gin::NotFound: No route exists for: GET /foo"
+    msg = "[ERROR] Gin::NotFound: No route exists for: GET /foo"
     @error_io.rewind
     assert @error_io.read.include?(msg)
   end
@@ -344,7 +344,7 @@ class AppTest < Test::Unit::TestCase
     assert_equal 500, resp[0]
     assert_equal @app.asset("500.html"), resp[2].path
     @error_io.rewind
-    assert @error_io.read.empty?
+    assert @error_io.read.include?("[ERROR] RuntimeError: Something bad happened\n")
   end
 
 
@@ -530,8 +530,9 @@ class AppTest < Test::Unit::TestCase
 
 
   def test_init
-    assert Logger === @app.logger, "logger attribute should be a Logger"
-    assert Logger === @rapp.logger, "logger attribute should be a Logger"
+    @app = FooApp.new
+    assert_equal $stdout, @app.logger, "logger should default to $stdout"
+    assert_equal $stdout, @rapp.logger, "logger should default to $stdout"
     assert_nil @app.rack_app, "Rack application should be nil by default"
     assert Proc === @rapp.rack_app, "Rack application should be a Proc"
     assert Gin::Router === @app.router, "Should have a Gin::Router"

data/test/test_controller.rb

@@ -69,7 +69,7 @@ class ControllerTest < Test::Unit::TestCase
   def setup
     MockApp.instance_variable_set("@environment", nil)
     MockApp.instance_variable_set("@asset_host", nil)
-    @app  = MockApp.new Logger.new(StringIO.new)
+    @app  = MockApp.new StringIO.new
     @ctrl = BarController.new(@app, rack_env)
   end
 
@@ -230,7 +230,7 @@ class ControllerTest < Test::Unit::TestCase
     assert_equal 'no-cache', @ctrl.response['Pragma']
     assert_equal 'no-cache, no-store, must-revalidate, max-age=0',
                   @ctrl.response['Cache-Control']
-    assert_equal Time.new("1990","01","01").httpdate,
+    assert_equal Gin::Constants::EPOCH.httpdate,
                   @ctrl.response['Expires']
   end
 
@@ -249,6 +249,15 @@ class ControllerTest < Test::Unit::TestCase
   end
 
 
+  def test_delete_cookie
+    test_set_cookie
+
+    @ctrl.delete_cookie "test"
+    assert_equal "test=; max-age=0; expires=Thu, 01 Jan 1970 00:00:00 -0000",
+                 @ctrl.response['Set-Cookie']
+  end
+
+
   def test_set_session
     @ctrl.session['test'] = 'user@example.com'
     assert_equal({"test"=>"user@example.com"}, @ctrl.env['rack.session'])

data/test/test_router.rb

@@ -113,7 +113,7 @@ class RouterTest < Test::Unit::TestCase
   end
 
 
-  def test_add_all_restful_routes
+  def test_add_all_routes_as_defaults
     @router.add MyCtrl, "/" do
       get :show, "/:id"
       defaults
@@ -124,6 +124,23 @@ class RouterTest < Test::Unit::TestCase
   end
 
 
+  def test_add_all_with_default_verb
+    @router.add MyCtrl, "/" do
+      get :show, "/:id"
+      defaults :post
+    end
+
+    assert_equal [MyCtrl, :index, {}],
+      @router.resources_for("GET", "/")
+
+    assert_equal [MyCtrl, :show, {'id' => '123'}],
+      @router.resources_for("GET", "/123")
+
+    assert_equal [MyCtrl, :unmounted_action, {}],
+      @router.resources_for("POST", "/unmounted_action")
+  end
+
+
   def test_add_all
     @router.add MyCtrl, "/"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gin
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2013-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -75,13 +75,9 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.5'
-description: ! 'Gin is a small web framework built from the redistillation of
+description: ! 'Gin is a small Ruby web framework, built on Rack, which borrows from
 
-  Sinatra and Rails idioms. Specifically, it uses much of Sinatra''s
-
-  request flow and HTTP helper methods with dedicated controller classes
-
-  that support Rails-like filters.'
+  Sinatra expressiveness, and targets larger applications.'
 email:
 - yaksnrainbows@gmail.com
 executables: []
@@ -100,9 +96,11 @@ files:
 - lib/gin.rb
 - lib/gin/app.rb
 - lib/gin/config.rb
+- lib/gin/constants.rb
 - lib/gin/controller.rb
 - lib/gin/core_ext/cgi.rb
 - lib/gin/core_ext/gin_class.rb
+- lib/gin/core_ext/rack_commonlogger.rb
 - lib/gin/errorable.rb
 - lib/gin/filterable.rb
 - lib/gin/reloadable.rb
@@ -150,7 +148,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3408999320760955315
+      hash: -1880592358909000516
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -162,8 +160,8 @@ rubyforge_project: gin
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Gin is a small web framework built from the redistillation of Sinatra and
-  Rails idioms
+summary: Gin is a small Ruby web framework, built on Rack, which borrows from Sinatra
+  expressiveness, and targets larger applications.
 test_files:
 - test/test_app.rb
 - test/test_config.rb