gin 1.0.4 → 1.1.0

data/lib/gin/core_ext/gin_class.rb

@@ -1,6 +1,22 @@
 module GinClass #:nodoc:
   private
 
+  def opt_reader name, *names
+    names.unshift name
+    names.each do |n|
+      define_method(n){ @options[n] }
+    end
+  end
+
+
+  def class_rproxy name, *names
+    names.unshift name
+    names.each do |n|
+      define_method(n){ self.class.send(n) }
+    end
+  end
+
+
   def class_proxy name, *names
     names.unshift name
     names.each do |n|

data/lib/gin/errorable.rb

@@ -7,6 +7,19 @@ module Gin::Errorable
 
 
   module ClassMethods
+    def self.extended obj     # :nodoc:
+      obj.__setup_errorable
+    end
+
+    def inherited subclass    # :nodoc:
+      subclass.__setup_errorable
+      super
+    end
+
+    def __setup_errorable     # :nodoc:
+      @err_handlers = {}
+    end
+
 
     ##
     # Define an error handler for this Controller. Configurable with exceptions
@@ -51,7 +64,7 @@ module Gin::Errorable
     # Hash of error handlers defined by Gin::Controller.error.
 
     def error_handlers
-      @err_handlers ||= {}
+      @err_handlers
     end
 
 
@@ -82,7 +95,8 @@ module Gin::Errorable
   end
 
 
-  class_proxy :error_handlers, :error_handler_for
+  class_rproxy :error_handlers
+  class_proxy  :error_handler_for
 
   ##
   # Calls the appropriate error handlers for the given error.

data/lib/gin/filterable.rb

@@ -11,6 +11,32 @@ module Gin::Filterable
 
   module ClassMethods
 
+    def self.extended obj     # :nodoc:
+      obj.__setup_filterable
+    end
+
+    def inherited subclass    # :nodoc:
+      subclass.__setup_filterable
+      super
+    end
+
+
+    def __setup_filterable    # :nodoc:
+      @before_filters = {nil => []}
+      superclass.before_filters.each{|k,v| @before_filters[k] = v.dup if v } if
+        superclass.respond_to?(:before_filters)
+
+      @after_filters  = {nil => []}
+      superclass.after_filters.each{|k,v| @after_filters[k] = v.dup if v } if
+        superclass.respond_to?(:after_filters)
+
+      @filters = {}
+      pfilters = self.superclass.filters if
+        self.superclass.respond_to?(:filters)
+      @filters = pfilters.dup if pfilters
+    end
+
+
     ##
     # Create a filter for controller actions.
     #   filter :logged_in do
@@ -30,8 +56,7 @@ module Gin::Filterable
     # This attribute is inherited.
 
     def filters
-      @filters ||= self.superclass.respond_to?(:filters) ?
-                     self.superclass.filters.dup : {}
+      @filters
     end
 
 
@@ -102,13 +127,6 @@ module Gin::Filterable
     # 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
 
@@ -145,13 +163,6 @@ module Gin::Filterable
     # 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
 
@@ -183,9 +194,8 @@ module Gin::Filterable
     end
   end
 
-
-  class_proxy :filters, :before_filters, :after_filters,
-              :before_filters_for, :after_filters_for
+  class_rproxy :filters, :before_filters, :after_filters
+  class_proxy  :before_filters_for, :after_filters_for
 
   ##
   # Chain-call filters from an action. Raises the filter exception if any

data/lib/gin/reloadable.rb

@@ -37,7 +37,7 @@ module Gin::Reloadable #:nodoc:
 
 
     def gin_constants
-      return @gin_constants if @gin_constants
+      return @gin_constants if defined?(@gin_constants) && @gin_constants
       @gin_constants = {Gin.object_id => ::Gin}
 
       each_constant(Gin) do |name, const, _|

data/lib/gin/request.rb

@@ -32,6 +32,17 @@ class Gin::Request < Rack::Request
   end
 
 
+  def ip
+    if addr = @env['HTTP_X_FORWARDED_FOR']
+      (addr.split(',').grep(/\d\./).first || @env['REMOTE_ADDR']).to_s.strip
+    else
+      @env['REMOTE_ADDR']
+    end
+  end
+
+  alias remote_ip ip
+
+
   private
 
   M_BOOLEAN = /^true|false$/  #:nodoc:

data/lib/gin/router.rb

@@ -1,7 +1,32 @@
+##
+# The Gin::Router class is the core of how Gin maps HTTP requests to
+# a Controller and action (target), and vice-versa.
+#
+#   router = Gin::Router.new
+#   router.add FooController do
+#     get :index, "/"
+#     get :show, "/:id"
+#   end
+#
+#   router.path_to FooController, :show, id: 123
+#   #=> "/foo/123"
+#
+#   router.path_to :show_foo, id: 123
+#   #=> "/foo/123"
+#
+#   router.resources_for "get", "/foo/123"
+#   #=> [FooController, :show, {:id => "123"}]
+
 class Gin::Router
 
+  # Raised when a Route fails to build a path due to missing params
+  # or an invalid route target.
   class PathArgumentError < Gin::Error; end
 
+  ##
+  # Class for building temporary groups of routes for a given controller.
+  # Used by the Gin::App.mount DSL.
+
   class Mount
     DEFAULT_ACTION_MAP = {
       :index   => %w{get /},
@@ -20,55 +45,43 @@ class Gin::Router
     end
 
 
-    def initialize ctrl, base_path, sep="/", &block
-      @sep       = sep
+    def initialize ctrl, base_path, &block
       @ctrl      = ctrl
       @routes    = []
       @actions   = []
-      @base_path = base_path.split(@sep)
+      @base_path = base_path
 
       instance_eval(&block) if block_given?
       defaults unless block_given?
     end
 
 
-    # Create restful routes if they aren't taken already.
+    ##
+    # Create and add default restful routes if they aren't taken already.
+
     def defaults default_verb=nil
-      default_verb = (default_verb || 'get').to_s.downcase
+      default_verb = default_verb || 'get'
 
       (@ctrl.actions - @actions).each do |action|
         verb, path = DEFAULT_ACTION_MAP[action]
         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] }
+          @routes.any?{|route| route === [verb, path] }
       end
     end
 
 
+    ##
+    # Create routes for all standard verbs and add them to the Mount instance.
+
     def any action, path=nil
       VERBS.each{|verb| send verb, action, path}
     end
 
 
-    def make_route verb, path
-      param_keys = []
-      route = [verb].concat @base_path
-      route.concat path.split(@sep)
-      route.delete_if{|part| part.empty?}
-
-      route.map! do |part|
-        if part[0] == ":"
-          param_keys << part[1..-1]
-          "%s"
-        else
-          part
-        end
-      end
-
-      [route, param_keys]
-    end
-
+    ##
+    # Create a single route and add it to the Mount instance.
 
     def add verb, action, *args
       path = args.shift        if String === args[0]
@@ -77,19 +90,122 @@ class Gin::Router
       path ||= action.to_s
       name ||= :"#{action}_#{@ctrl.controller_name}"
 
-      route, param_keys = make_route(verb, path)
-      @routes << [route, name, [@ctrl, action, param_keys]]
+      path = File.join(@base_path, path)
+      target = [@ctrl, action]
+
+      route = Route.new(verb, path, target, name)
+      @routes << route
       @actions << action.to_sym
     end
 
 
+    ##
+    # Iterate through through all the routes in the Mount.
+
     def each_route &block
-      @routes.each{|(route, name, value)| block.call(route, name, value) }
+      @routes.each(&block)
     end
   end
 
 
-  class Node
+  ##
+  # Represents an HTTP path and path matcher, with inline params, and new path
+  # generation functionality.
+  #
+  #   r = Route.new "get", "/foo/:id.:format", [FooController, :show], :show_foo
+  #   r.to_path id: 123, format: "json"
+  #   #=> "/foo/123.json"
+
+  class Route
+    # Parsed out path param key names.
+    attr_reader :param_keys
+
+    # Array of path parts for tree-based matching.
+    attr_reader :match_keys
+
+    # Computed path String with wildcards.
+    attr_reader :path
+
+    # Target of the route, in this case an Array with controller and action.
+    attr_reader :target
+
+    # Arbitrary name of the route.
+    attr_reader :name
+
+    SEP = "/"               # :nodoc:
+    VAR_MATCHER = /:(\w+)/  # :nodoc:
+    PARAM_MATCHER = "(.*?)" # :nodoc:
+
+
+    def initialize verb, path, target, name
+      @target = target
+      @name   = 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"
+    #   #=> "/foo/123.json?foo=bar"
+
+    def to_path params={}
+      rendered_path = @path.dup
+      rendered_path = rendered_path % @param_keys.map do |k|
+        params.delete(k) || params.delete(k.to_sym) ||
+          raise(PathArgumentError, "Missing param #{k}")
+      end unless @param_keys.empty?
+
+      rendered_path << "?#{Gin.build_query(params)}" unless params.empty?
+      rendered_path
+    end
+
+
+    ##
+    # Returns true if the argument matches the route_id.
+    # The route id is an array with verb and original path.
+
+    def === other
+      @route_id == other
+    end
+
+
+    private
+
+    def build verb, path
+      verb = verb.to_s.downcase
+
+      @path = ""
+      @param_keys = []
+      @match_keys = []
+      @route_id = [verb, path]
+
+      parts = [verb].concat path.split(SEP)
+
+      parts.each_with_index do |p, i|
+        next if p.empty?
+
+        part = Regexp.escape(p).gsub!(VAR_MATCHER) do
+          @param_keys << $1
+          PARAM_MATCHER
+        end
+
+        if part == PARAM_MATCHER
+          part = "%s"
+        elsif $1
+          part = /^#{part}$/
+        else
+          part = p
+        end
+
+        @path << "#{SEP}#{p.gsub(VAR_MATCHER, "%s")}" if i > 0
+        @match_keys << part
+      end
+    end
+  end
+
+
+  class Node    # :nodoc:
     attr_accessor :value
 
     def initialize
@@ -100,15 +216,22 @@ class Gin::Router
       @children[key]
     end
 
-    def add_child key, val=nil
+    def match key
+      @children.keys.each do |k|
+        next unless Regexp === k
+        m = k.match key
+        return [@children[k], m[1..-1]] if m
+      end
+      nil
+    end
+
+    def add_child key
       @children[key] ||= Node.new
-      @children[key].value = val unless val.nil?
     end
   end
 
 
-  def initialize separator="/" # :nodoc:
-    @sep = separator
+  def initialize
     @routes_tree = Node.new
     @routes_lookup = {}
   end
@@ -116,31 +239,30 @@ class Gin::Router
 
   ##
   # Add a Controller to the router with a base path.
+  # Used by Gin::App.mount.
 
   def add ctrl, base_path=nil, &block
     base_path ||= ctrl.controller_name
 
-    mount = Mount.new(ctrl, base_path, @sep, &block)
+    mount = Mount.new(ctrl, base_path, &block)
 
-    mount.each_route do |route_ary, name, val|
+    mount.each_route do |route|
       curr_node = @routes_tree
 
-      route_ary.each do |part|
+      route.match_keys.each do |part|
         curr_node.add_child part
         curr_node = curr_node[part]
       end
 
-      curr_node.value = val
-      route = [route_ary[0], "/" << route_ary[1..-1].join(@sep), val[2]]
-
-      @routes_lookup[name]      = route if name
-      @routes_lookup[val[0..1]] = route
+      curr_node.value = route
+      @routes_lookup[route.name]   = route if route.name
+      @routes_lookup[route.target] = route
     end
   end
 
 
   ##
-  # Check if a Controller and action combo has a route.
+  # Check if a Controller and action pair has a route.
 
   def has_route? ctrl, action
     !!@routes_lookup[[ctrl, action]]
@@ -148,7 +270,7 @@ class Gin::Router
 
 
   ##
-  # Yield every Controller, action, route combination.
+  # Yield every route, controller, action combinations the router knows about.
 
   def each_route &block
     @routes_lookup.each do |key,route|
@@ -163,34 +285,33 @@ class Gin::Router
   # provided with the needed params. Routes with missing path params will raise
   # MissingParamError. Returns a String starting with "/".
   #
-  #   path_to FooController, :show, :id => 123
+  #   path_to FooController, :show, id: 123
   #   #=> "/foo/123"
   #
-  #   path_to :show_foo, :id => 123
+  #   path_to :show_foo, id: 123
   #   #=> "/foo/123"
+  #
+  #   path_to :show_foo, id: 123, more: true
+  #   #=> "/foo/123?more=true"
 
   def path_to *args
     key = Class === args[0] ? args.slice!(0..1) : args.shift
-    verb, route, param_keys = @routes_lookup[key]
+    route = @routes_lookup[key]
     raise PathArgumentError, "No route for #{Array(key).join("#")}" unless route
 
     params = (args.pop || {}).dup
 
-    route = route.dup
-    route = route % param_keys.map do |k|
-      params.delete(k) || params.delete(k.to_sym) ||
-        raise(PathArgumentError, "Missing param #{k}")
-    end unless param_keys.empty?
-
-    route << "?#{Gin.build_query(params)}" unless params.empty?
-
-    route
+    route.to_path(params)
   end
 
 
   ##
-  # Takes a path and returns an array of 3 items:
-  #   [controller_class, action_symbol, path_params_hash]
+  # Takes a path and returns an array with the
+  # controller class, action symbol, processed path params.
+  #
+  #   router.resources_for "get", "/foo/123"
+  #   #=> [FooController, :show, {:id => "123"}]
+  #
   # Returns nil if no match was found.
 
   def resources_for http_verb, path
@@ -208,18 +329,21 @@ class Gin::Router
         param_vals << key
         curr_node = curr_node["%s"]
 
+      elsif child_and_matches = curr_node.match(key)
+        param_vals.concat child_and_matches[1]
+        curr_node = child_and_matches[0]
+
       else
         return
       end
     end
 
     return unless curr_node.value
-    rsc = curr_node.value.dup
+    route = curr_node.value
 
-    rsc[-1] = param_vals.empty? ?
-              Hash.new :
-              rsc[-1].inject({}){|h, name| h[name] = param_vals.shift; h}
+    path_params = param_vals.empty? ?
+      {} : route.param_keys.inject({}){|h, name| h[name] = param_vals.shift; h}
 
-    rsc
+    [*route.target, path_params]
   end
 end