gin 1.1.2 → 1.2.0

data/lib/gin/request.rb

@@ -45,9 +45,9 @@ class Gin::Request < Rack::Request
 
   private
 
-  M_BOOLEAN = /^true|false$/  #:nodoc:
-  M_FLOAT   = /^\d+\.\d+$/    #:nodoc:
-  M_INTEGER = /^\d+$/         #:nodoc:
+  M_BOOLEAN = /^true|false$/          #:nodoc:
+  M_FLOAT   = /^-?([^0]\d+|\d)\.\d+$/ #:nodoc:
+  M_INTEGER = /^-?([^0]\d+|\d)$/      #:nodoc:
 
   ##
   # Enable string or symbol key access to the nested params hash.
@@ -56,7 +56,7 @@ class Gin::Request < Rack::Request
   def process_params object
     case object
     when Hash
-      new_hash = indifferent_hash
+      new_hash = Gin::StrictHash.new
       object.each { |key, value| new_hash[key] = process_params(value) }
       new_hash
     when Array
@@ -71,12 +71,4 @@ class Gin::Request < Rack::Request
       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

data/lib/gin/response.rb

@@ -8,13 +8,15 @@ class Gin::Response < Rack::Response
 
   def body= value
     value = value.body while Rack::Response === value
-    @body = value.respond_to?(:each) ? value : [value.to_s]
+    @body = value.respond_to?(:each) && !value.is_a?(String) ?
+              value : [value.to_s]
     @body
   end
 
 
   def finish
     body_out = body
+    body_out = [body_out] if String === body_out
     header[CNT_TYPE] ||= 'text/html;charset=UTF-8'
 
     if NO_HEADER_STATUSES.include?(status.to_i)
@@ -43,7 +45,7 @@ class Gin::Response < Rack::Response
                                l + Rack::Utils.bytesize(p)
                              end.to_s
       when File
-        header[CNT_LENGTH] = body.size.to_s
+        header[CNT_LENGTH] = File.size(body.path).to_s
       end
     end
   end

data/lib/gin/router.rb

@@ -28,15 +28,8 @@ class Gin::Router
   # Used by the Gin::App.mount DSL.
 
   class Mount
-    DEFAULT_ACTION_MAP = {
-      :index   => %w{get /},
-      :show    => %w{get /:id},
-      :new     => %w{get /new},
-      :create  => %w{post /:id},
-      :edit    => %w{get /:id/edit},
-      :update  => %w{put /:id},
-      :destroy => %w{delete /:id}
-    }
+
+    PATH_NAME_MATCHER = %r{\A[-+\w/]+\Z}m  #:nodoc:
 
     VERBS = %w{get post put delete head options trace}
 
@@ -45,28 +38,50 @@ class Gin::Router
     end
 
 
-    def initialize ctrl, base_path, &block
+    def initialize ctrl, base_path=nil, &block
+      raise ArgumentError,
+        "#{ctrl.inspect} must respond to `call'" unless ctrl.respond_to?(:call)
+
+      base_path ||= ctrl.controller_name if Gin::Mountable === ctrl
+
+      if !base_path
+        uname = Gin.underscore(ctrl.to_s)
+        base_path = File.join("", uname) if uname =~ PATH_NAME_MATCHER
+      end
+
+      raise ArgumentError,
+        "Could not deduce base path from #{ctrl.inspect}" unless base_path
+
       @ctrl      = ctrl
       @routes    = []
       @actions   = []
       @base_path = base_path
 
-      instance_eval(&block) if block_given?
-      defaults unless block_given?
+      if block_given?
+        instance_eval(&block)
+        return
+      end
+
+      if !(Gin::Mountable === @ctrl)
+        any :call, "/"
+      else
+        defaults
+      end
     end
 
 
     ##
     # Create and add default restful routes if they aren't taken already.
 
-    def defaults default_verb=nil
-      default_verb = default_verb || 'get'
+    def defaults
+      raise TypeError,
+        "#{@ctrl.inspect} must inherit Gin::Mountable to support defaults" unless
+        Gin::Mountable === @ctrl
 
       (@ctrl.actions - @actions).each do |action|
-        verb, path = DEFAULT_ACTION_MAP[action]
-        verb, path = [default_verb, "/#{action}"] if verb.nil?
+        verb, path = @ctrl.default_route_for(action)
 
-        add(verb, action, path) unless verb.nil? ||
+        add(verb, action, path) unless
           @routes.any?{|route| route === [verb, path] }
       end
     end
@@ -87,15 +102,25 @@ class Gin::Router
       path = args.shift        if String === args[0]
       name = args.shift.to_sym if args[0]
 
-      path ||= action.to_s
-      name ||= :"#{action}_#{@ctrl.controller_name}"
+      if Gin::Mountable === @ctrl
+        path ||= @ctrl.default_route_for(action)[1]
+        name ||= @ctrl.route_name_for(action)
+      elsif !(path && name) && !action.is_a?(Array) && !action.is_a?(Hash) &&
+      action.to_s =~ PATH_NAME_MATCHER
+        path ||= action.to_s
+        uname = Gin.underscore(@ctrl.to_s).sub(%r{^.*/},'')
+        name = "#{action}_#{uname}" if !name && uname =~ PATH_NAME_MATCHER
+      end
+
+      raise ArgumentError, "No path could be determined for target %s %s" %
+        [@ctrl.inspect, action.inspect] unless path
 
       path = File.join(@base_path, path)
       target = [@ctrl, action]
 
       route = Route.new(verb, path, target, name)
-      @routes << route
-      @actions << action.to_sym
+      @routes  << route
+      @actions << action
     end
 
 
@@ -117,6 +142,8 @@ class Gin::Router
   #   #=> "/foo/123.json"
 
   class Route
+    include Gin::Constants
+
     # Parsed out path param key names.
     attr_reader :param_keys
 
@@ -132,24 +159,28 @@ class Gin::Router
     # Arbitrary name of the route.
     attr_reader :name
 
+    # HTTP verb used by the route.
+    attr_reader :verb
+
     SEP = "/"               # :nodoc:
     VAR_MATCHER = /:(\w+)/  # :nodoc:
     PARAM_MATCHER = "(.*?)" # :nodoc:
 
 
-    def initialize verb, path, target, name
+    def initialize verb, path, target=[], name=nil
       @target = target
-      @name   = name
+      @name   = name.to_sym if name
       build verb, path
     end
 
 
     ##
     # Render a route path by giving it inline (and other) params.
-    #   route.to_path id: 123, format: "json", foo: "bar"
+    #   route.to_path :id => 123, :format => "json", :foo => "bar"
     #   #=> "/foo/123.json?foo=bar"
 
     def to_path params={}
+      params ||= {}
       rendered_path = @path.dup
       rendered_path = rendered_path % @param_keys.map do |k|
         val = params.delete(k) || params.delete(k.to_sym)
@@ -162,6 +193,27 @@ class Gin::Router
     end
 
 
+    ##
+    # Creates a Rack env hash with the given params and headers.
+
+    def to_env params={}, headers={}
+      headers ||= {}
+      params  ||= {}
+
+      path_info, query_string = to_path(params).split('?', 2)
+
+      env = headers.merge(
+        PATH_INFO => path_info,
+        REQ_METHOD => @verb,
+        QUERY_STRING => query_string
+      )
+
+      # TODO: implement multipart streams for requests that support a body
+      env[RACK_INPUT] ||= ''
+      env
+    end
+
+
     ##
     # Returns true if the argument matches the route_id.
     # The route id is an array with verb and original path.
@@ -174,26 +226,28 @@ class Gin::Router
     private
 
     def build verb, path
-      verb = verb.to_s.downcase
+      @verb = verb.to_s.upcase
 
       @path = ""
       @param_keys = []
       @match_keys = []
-      @route_id = [verb, path]
+      @route_id = [@verb, path]
 
-      parts = [verb].concat path.split(SEP)
+      parts = [@verb].concat path.split(SEP)
 
       parts.each_with_index do |p, i|
         next if p.empty?
 
+        is_param = false
         part = Regexp.escape(p).gsub!(VAR_MATCHER) do
           @param_keys << $1
+          is_param = true
           PARAM_MATCHER
         end
 
         if part == PARAM_MATCHER
           part = "%s"
-        elsif $1
+        elsif is_param
           part = /^#{part}$/
         else
           part = p
@@ -243,8 +297,6 @@ class Gin::Router
   # Used by Gin::App.mount.
 
   def add ctrl, base_path=nil, &block
-    base_path ||= ctrl.controller_name
-
     mount = Mount.new(ctrl, base_path, &block)
 
     mount.each_route do |route|
@@ -284,7 +336,8 @@ class Gin::Router
   ##
   # Get the path to the given Controller and action combo or route name,
   # provided with the needed params. Routes with missing path params will raise
-  # MissingParamError. Returns a String starting with "/".
+  # MissingParamError. Missing routes will raise a RouterError.
+  # Returns a String starting with "/".
   #
   #   path_to FooController, :show, id: 123
   #   #=> "/foo/123"
@@ -296,13 +349,32 @@ class Gin::Router
   #   #=> "/foo/123?more=true"
 
   def path_to *args
+    params = args.pop.dup if Hash === args.last
+    route = route_to(*args)
+    route.to_path(params)
+  end
+
+
+  ##
+  # Get the route object to the given Controller and action combo or route name.
+  # MissingParamError. Returns a Gin::Router::Route instance.
+  # Raises a RouterError if no route can be found.
+  #
+  #   route_to FooController, :show
+  #   route_to :show_foo
+
+  def route_to *args
     key = Class === args[0] ? args.slice!(0..1) : args.shift
     route = @routes_lookup[key]
-    raise PathArgumentError, "No route for #{Array(key).join("#")}" unless route
 
-    params = (args.pop || {}).dup
+    unless route
+      name = Array === key && Gin::Mountable === key[0] ?
+              key[0].display_name(key[1]) : name.inspect
 
-    route.to_path(params)
+      raise Gin::RouterError, "No route for #{name}"
+    end
+
+    route
   end
 
 
@@ -317,10 +389,11 @@ class Gin::Router
 
   def resources_for http_verb, path
     param_vals = []
-    curr_node  = @routes_tree[http_verb.to_s.downcase]
+    curr_node  = @routes_tree[http_verb.to_s.upcase]
     return unless curr_node
 
-    path.scan(%r{/([^/]+|$)}) do |(key)|
+    path.scan(%r{/([^/]+|$)}) do |matches|
+      key = matches[0]
       next if key.empty?
 
       if curr_node[key]
@@ -345,6 +418,6 @@ class Gin::Router
     path_params = param_vals.empty? ?
       {} : route.param_keys.inject({}){|h, name| h[name] = param_vals.shift; h}
 
-    [*route.target, path_params]
+    [route.target, path_params]
   end
 end

data/lib/gin/strict_hash.rb

@@ -0,0 +1,33 @@
+class Gin::StrictHash < Hash
+
+  def [] key
+    super key.to_s
+  end
+
+  def []= key, value
+    super key.to_s, value
+  end
+
+  def delete key
+    super key.to_s
+  end
+
+  def has_key? key
+    super key.to_s
+  end
+
+  alias key? has_key?
+
+  def merge hash
+    return super if hash.class == self.class
+    new_hash = self.dup
+    new_hash.merge!(hash)
+    new_hash
+  end
+
+  def merge! hash
+    return super if hash.class == self.class
+    hash.each{|k,v| self[k] = v}
+    self
+  end
+end

data/lib/gin/test.rb

@@ -137,7 +137,7 @@ module Gin::Test::Assertions
   #   assert_select '**/address/domestic=YES/../value'
 
   def assert_data path, opts={}, msg=nil
-    assert_select path, opts.merge(selector: :rb_path), msg
+    assert_select path, opts.merge(:selector => :rb_path), msg
   end
 
 
@@ -153,7 +153,7 @@ module Gin::Test::Assertions
   #   assert_select '.address[domestic=Yes]'
 
   def assert_css path, opts={}, msg=nil
-    assert_select path, opts.merge(selector: :css), msg
+    assert_select path, opts.merge(:selector => :css), msg
   end
 
 
@@ -169,7 +169,7 @@ module Gin::Test::Assertions
   #   assert_select './/address[@domestic=Yes]'
 
   def assert_xpath path, opts={}, msg=nil
-    assert_select path, opts.merge(selector: :xpath), msg
+    assert_select path, opts.merge(:selector => :xpath), msg
   end
 
 
@@ -243,7 +243,7 @@ module Gin::Test::Assertions
   # controller and action.
 
   def assert_route verb, path, exp_ctrl, exp_action, msg=nil
-    ctrl, action, = app.router.resources_for(verb, path)
+    ctrl, action, = Array(app.router.resources_for(verb, path))[0]
     expected = "#{exp_ctrl}##{exp_action}"
     real     = "#{ctrl}##{action}"
     real_msg = ctrl && action ? "got #{real}" : "doesn't exist"
@@ -463,6 +463,10 @@ Run the following command and try again: gem install #{gemname}"
     env['REQUEST_METHOD'] = verb.to_s.upcase
     env['QUERY_STRING']   = query
     env['PATH_INFO']      = path
+
+    host, port = (app.hostname || "localhost").split(":")
+    env['SERVER_NAME'] = host
+    env['SERVER_PORT'] = port || '80'
     env.merge! headers
 
     @rack_response = app.call(env)

data/lib/gin/worker.rb

@@ -0,0 +1,49 @@
+require 'fileutils'
+
+class Gin::Worker
+
+  def initialize pidfile, &block
+    @pidfile = pidfile
+    @pid     = nil
+    @block   = block
+  end
+
+
+  def run
+    FileUtils.touch(@pidfile)
+    f = File.open(@pidfile, 'r+')
+    return unless f.flock(File::LOCK_EX | File::LOCK_NB)
+
+    if other_pid = f.read
+      running = Process.kill(0, other_pid) rescue false
+      return if running
+    end
+
+    @pid = fork do
+      begin
+        f.truncate(File.size(f.path))
+        f.write Process.pid.to_s
+        f.flush
+        @block.call
+      rescue Interrupt
+        $stderr.puts "Worker Interrupted: #{@pidfile} (#{Process.pid})"
+      ensure
+        f.close unless f.closed?
+        File.delete(f.path)
+      end
+    end
+
+  ensure
+    f.close if f && !f.closed?
+  end
+
+
+  def kill sig="INT"
+    Process.kill(sig, @pid) if @pid
+  end
+
+
+  def wait
+    Process.waitpid(@pid) if @pid
+  end
+end