howl-router 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4ebbc66f3c3f654d674622767d7edf84254af76
-  data.tar.gz: a4f0e1a5b59fab741073bae7cf03fa985ada4ab9
+  metadata.gz: 7762704358bdeef51e547cbcf8fd5c82ed290850
+  data.tar.gz: 6be61141decbb09555cb5419c5b68e1db83369a9
 SHA512:
-  metadata.gz: 85c9892dd1461ab74ac61faceb3d5a92555793a5f4810d3c724008765aec3758dda65e478a6d22e534076bfce3b743a3d463920a2d1ed768870b3e301b1f8459
-  data.tar.gz: 08f15a1b94df198e78e195ea4a1e547b2552a3b2ef1d041f405fabfa3e56f2f771192471f09ad9b23ee456defad79e77e60be5ccaf9a8a384830049de3d1b90d
+  metadata.gz: d2456c6071cad44e55290fcf59db6460a163da793073d0acb76ff36eb14a1c49562efccbb54203d34b7343d9f414dd006590ffffc714b32b186e5bb9e736f535
+  data.tar.gz: 9bcbe7162ef0a76bfe25597233df1b25c753ce2c68435e7e8f324ea7a020be6cb4b755e723ba6a3480ac0ce123e5b7f6ae254eae77196caa0d95e4553869f3b8

data/lib/howl-router.rb

@@ -19,9 +19,9 @@ class Howl
   # Generate a route, and add to routes.
   #
   # @param [String, Symbol] verb The verb decide a acceptable request method.
-  # @param [String] path The path associate to route.
+  # @param [String, Regexp] path The path associate to route.
   # @option options [String] :path_for_generation Accept path_for_generation.
-  # @yield The block assosiate to route.
+  # @yield The block associate to route.
   #
   # @example
   #   howl = Howl.new
@@ -60,7 +60,8 @@ class Howl
 
   # Determines whether the compiled.
   #
-  # @return [Bool]
+  # @return [Boolean]
+  #
   def compiled?
     @compiled
   end
@@ -68,6 +69,7 @@ class Howl
   # Compile routes.
   #
   # @return [Array] Return a compiled routes.
+  #
   def compile
     @compiled = true
     router.compile
@@ -78,6 +80,7 @@ class Howl
   # @param [Rack::Request] request The request is a Rack::Request or instance that inherited it.
   #
   # @return [Array] Return a routes that match the path_info.
+  #
   def recognize(request)
     router.recognize(request)
   end
@@ -86,7 +89,7 @@ class Howl
   #
   # @param [String] path_info
   #
-  # @return [Array] Return a Array that likes [name, params].
+  # @return [Array] Return an Array that likes [name, params].
   def recognize_path(path_info)
     response      = router.recognize(Rack::MockRequest.env_for(path_info))
     route, params = response.first
@@ -102,6 +105,7 @@ class Howl
   # Return a Router instance.
   #
   # @return [Howl::Router]
+  #
   def router
     @router ||= Router.new
   end
@@ -109,6 +113,7 @@ class Howl
   # Return a added routes.
   #
   # @return [Array]
+  #
   def routes
     router.routes
   end

data/lib/howl-router/matcher.rb

@@ -2,16 +2,39 @@ require 'mustermann'
 
 class Howl
   class Matcher
+    # @param [String] path The path is string or regexp.
+    # @option options [Hash] :capture Set capture for path pattern.
+    # @option options [Hash] :default_values Set default_values for path pattern.
+    #
+    # @return [Howl::Matcher]
+    #
     def initialize(path, options = {})
       @path           = path.is_a?(String) && path.empty? ? "/" : path
       @capture        = options.delete(:capture)
       @default_values = options.delete(:default_values)
     end
 
+    # Do the matching.
+    #
+    # @param [String] pattern The pattern is actual path (path_info etc).
+    #
+    # @return [MatchData] If the pattern matched this route, return a MatchData.
+    # @return [Nil] If the pattern doesn't matched this route, return a nil.
+    #
     def match(pattern)
       handler.match(pattern)
     end
 
+    # Expand the path with params.
+    #
+    # @param [Hash] params The params for path pattern.
+    #
+    # @example
+    #   matcher = Howl::Matcher.new("/foo/:bar")
+    #   matcher.expand(:bar => 123) #=> "/foo/123"
+    #   matcher.expand(:bar => "bar", :baz => "test") #=> "/foo/bar?baz=test"
+    #
+    # @return [String] A expaneded path.
     def expand(params)
       params = params.dup
       query = params.keys.inject({}) do |result, key|
@@ -24,25 +47,30 @@ class Howl
       expanded_path
     end
 
+    # @return [Boolean] This matcher's handler is mustermann ?
     def mustermann?
       handler.class == Mustermann::Rails
     end
 
+    # @return [Mustermann::Rails] Return a Mustermann::Rails when @path is string.
+    # @return [Regexp] Return a regexp when @path is regexp.
     def handler
       @handler ||= case @path
       when String
-        Mustermann.new(@path, :type => :rails, :capture => @capture, :uri_decode => nil)
+        Mustermann.new(@path, :type => :rails, :capture => @capture)
       when Regexp
         /^(?:#{@path})$/
       end
     end
 
+    # @return [String] Return a converted handler.
     def to_s
       handler.to_s
     end
 
+    # @return [Array] Return a named captures.
     def names
-      mustermann? ? handler.names.map(&:to_sym) : []
+      handler.names.map(&:to_sym)
     end
   end
 end

data/lib/howl-router/padrino/ext/class_methods.rb

@@ -51,129 +51,130 @@ class Howl
       end
 
       private
-        def route(verb, path, *args, &block)
-          options = case args.size
-            when 2
-              args.last.merge(:map => args.first)
-            when 1
-              map = args.shift if args.first.is_a?(String)
-              if args.first.is_a?(Hash)
-                map ? args.first.merge(:map => map) : args.first
-              else
-                {:map => map || args.first}
-              end
-            when 0
-              {}
-            else raise
-          end
-
-          route_options = options.dup
-          route_options[:provides] = @_provides if @_provides
-
-          if allow_disabled_csrf
-            unless route_options[:csrf_protection] == false
-              route_options[:csrf_protection] = true
-            end
-          end
 
-          path, *route_options[:with] = path if path.is_a?(Array)
-          action = path
-          path, name, route_parents, options, route_options = *parse_route(path, route_options, verb)
-          options.reverse_merge!(@_conditions) if @_conditions
-
-          method_name = "#{verb} #{path}"
-          unbound_method = generate_method(method_name, &block)
-
-          block = block.arity != 0 ?
-            proc {|a,p| unbound_method.bind(a).call(*p) } :
-            proc {|a,p| unbound_method.bind(a).call }
-
-          invoke_hook(:route_added, verb, path, block)
-
-          # Howl route construction
-          path[0, 0] = "/" if path == "(.:format)"
-          route = router.add(verb.downcase.to_sym, path, route_options)
-          route.name = name if name
-          route.action = action
-          priority_name = options.delete(:priority) || :normal
-          priority = ROUTE_PRIORITY[priority_name] or raise("Priority #{priority_name} not recognized, try #{ROUTE_PRIORITY.keys.join(', ')}")
-          route.cache = options.key?(:cache) ? options.delete(:cache) : @_cache
-          route.parent = route_parents ? (route_parents.count == 1 ? route_parents.first : route_parents) : route_parents
-          route.host = options.delete(:host) if options.key?(:host)
-          route.user_agent = options.delete(:agent) if options.key?(:agent)
-          if options.key?(:default_values)
-            defaults = options.delete(:default_values)
-            route.default_values = defaults if defaults
-          end
-          options.delete_if do |option, captures|
-            if route.significant_variable_names.include?(option)
-              route.capture[option] = Array(captures).first
-              true
+      def route(verb, path, *args, &block)
+        options = case args.size
+          when 2
+            args.last.merge(:map => args.first)
+          when 1
+            map = args.shift if args.first.is_a?(String)
+            if args.first.is_a?(Hash)
+              map ? args.first.merge(:map => map) : args.first
+            else
+              {:map => map || args.first}
             end
-          end
+          when 0
+            {}
+          else raise
+        end
 
-          # Add Sinatra conditions
-          options.each {|o, a| route.respond_to?("#{o}=") ? route.send("#{o}=", a) : send(o, *a) }
-          conditions, @conditions = @conditions, []
-          route.custom_conditions.concat(conditions)
+        route_options = options.dup
+        route_options[:provides] = @_provides if @_provides
 
-          invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
+        if allow_disabled_csrf
+          unless route_options[:csrf_protection] == false
+            route_options[:csrf_protection] = true
+          end
+        end
 
-          # Add Application defaults
-          route.before_filters.concat(@filters[:before])
-          route.after_filters.concat(@filters[:after])
-          if @_controller
-            route.use_layout = @layout
-            route.controller = Array(@_controller)[0].to_s
+        path, *route_options[:with] = path if path.is_a?(Array)
+        action = path
+        path, name, route_parents, options, route_options = *parse_route(path, route_options, verb)
+        options.reverse_merge!(@_conditions) if @_conditions
+
+        method_name = "#{verb} #{path}"
+        unbound_method = generate_method(method_name, &block)
+
+        block = block.arity != 0 ?
+          proc {|a,p| unbound_method.bind(a).call(*p) } :
+          proc {|a,p| unbound_method.bind(a).call }
+
+        invoke_hook(:route_added, verb, path, block)
+
+        # Howl route construction
+        path[0, 0] = "/" if path == "(.:format)"
+        route = router.add(verb.downcase.to_sym, path, route_options)
+        route.name = name if name
+        route.action = action
+        priority_name = options.delete(:priority) || :normal
+        priority = ROUTE_PRIORITY[priority_name] or raise("Priority #{priority_name} not recognized, try #{ROUTE_PRIORITY.keys.join(', ')}")
+        route.cache = options.key?(:cache) ? options.delete(:cache) : @_cache
+        route.parent = route_parents ? (route_parents.count == 1 ? route_parents.first : route_parents) : route_parents
+        route.host = options.delete(:host) if options.key?(:host)
+        route.user_agent = options.delete(:agent) if options.key?(:agent)
+        if options.key?(:default_values)
+          defaults = options.delete(:default_values)
+          route.default_values = defaults if defaults
+        end
+        options.delete_if do |option, captures|
+          if route.significant_variable_names.include?(option)
+            route.capture[option] = Array(captures).first
+            true
           end
+        end
+
+        # Add Sinatra conditions
+        options.each {|o, a| route.respond_to?("#{o}=") ? route.send("#{o}=", a) : send(o, *a) }
+        conditions, @conditions = @conditions, []
+        route.custom_conditions.concat(conditions)
 
-          deferred_routes[priority] << [route, block]
+        invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
 
-          route
+        # Add Application defaults
+        route.before_filters.concat(@filters[:before])
+        route.after_filters.concat(@filters[:after])
+        if @_controller
+          route.use_layout = @layout
+          route.controller = Array(@_controller)[0].to_s
         end
 
-        def provides(*types)
-          @_use_format = true
-          condition do
-            mime_types = types.map {|t| mime_type(t) }.compact
-            url_format = params[:format].to_sym if params[:format]
-            accepts = request.accept.map {|a| a.to_str }
-
-            # per rfc2616-sec14:
-            # Assume */* if no ACCEPT header is given.
-            catch_all = (accepts.delete "*/*" || accepts.empty?)
-            matching_types = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
-            if matching_types.empty? && types.include?(:any)
-              matching_types = accepts
-            end
+        deferred_routes[priority] << [route, block]
 
-            if !url_format && matching_types.first
-              type = ::Rack::Mime::MIME_TYPES.find {|k, v| v == matching_types.first }[0].sub(/\./,'').to_sym
-              accept_format = CONTENT_TYPE_ALIASES[type] || type
-            elsif catch_all && !types.include?(:any)
-              type = types.first
-              accept_format = CONTENT_TYPE_ALIASES[type] || type
-            end
+        route
+      end
 
-            matched_format = types.include?(:any) ||
-                             types.include?(accept_format) ||
-                             types.include?(url_format) ||
-                             ((!url_format) && request.accept.empty? && types.include?(:html))
-            # per rfc2616-sec14:
-            # answer with 406 if accept is given but types to not match any
-            # provided type
-            halt 406 if
-              (!url_format && !accepts.empty? && !matched_format) ||
-              (settings.respond_to?(:treat_format_as_accept) && settings.treat_format_as_accept && url_format && !matched_format)
-
-            if matched_format
-              @_content_type = url_format || accept_format || :html
-              content_type(@_content_type, :charset => 'utf-8')
-            end
+      def provides(*types)
+        @_use_format = true
+        condition do
+          mime_types = types.map {|t| mime_type(t) }.compact
+          url_format = params[:format].to_sym if params[:format]
+          accepts = request.accept.map {|a| a.to_str }
+
+          # per rfc2616-sec14:
+          # Assume */* if no ACCEPT header is given.
+          catch_all = (accepts.delete "*/*" || accepts.empty?)
+          matching_types = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
+          if matching_types.empty? && types.include?(:any)
+            matching_types = accepts
+          end
+
+          if !url_format && matching_types.first
+            type = ::Rack::Mime::MIME_TYPES.find {|k, v| v == matching_types.first }[0].sub(/\./,'').to_sym
+            accept_format = CONTENT_TYPE_ALIASES[type] || type
+          elsif catch_all && !types.include?(:any)
+            type = types.first
+            accept_format = CONTENT_TYPE_ALIASES[type] || type
+          end
 
-            matched_format
+          matched_format = types.include?(:any) ||
+                           types.include?(accept_format) ||
+                           types.include?(url_format) ||
+                           ((!url_format) && request.accept.empty? && types.include?(:html))
+          # per rfc2616-sec14:
+          # answer with 406 if accept is given but types to not match any
+          # provided type
+          halt 406 if
+            (!url_format && !accepts.empty? && !matched_format) ||
+            (settings.respond_to?(:treat_format_as_accept) && settings.treat_format_as_accept && url_format && !matched_format)
+
+          if matched_format
+            @_content_type = url_format || accept_format || :html
+            content_type(@_content_type, :charset => 'utf-8')
           end
+
+          matched_format
         end
+      end
     end
   end
 end

data/lib/howl-router/padrino/ext/instance_methods.rb

@@ -3,63 +3,63 @@ class Howl
   module Padrino
     module InstanceMethods
       private
-        def invoke_route(route, params, options = {})
-          original_params, parent_layout, successful = @params.dup, @layout, false
-          captured_params = params[:captures].is_a?(Array) ? params.delete(:captures) :
-                                                             params.values_at(*route.matcher.names.dup)
 
-          @_response_buffer = nil
-          @route = request.route_obj = route
-          @params.merge!(params) if params.is_a?(Hash)
-          @params.merge!(:captures => captured_params) unless captured_params.empty?
-          @block_params = params
+      def invoke_route(route, params, options = {})
+        original_params, parent_layout, successful = @params.dup, @layout, false
+        captured_params = params[:captures].is_a?(Array) ? params.delete(:captures) :
+                                                           params.values_at(*route.matcher.names.dup)
 
-          filter! :before if options[:first]
+        @_response_buffer = nil
+        @route = request.route_obj = route
+        @params.merge!(params) if params.is_a?(Hash)
+        #@params.merge!(:captures => captured_params) unless captured_params.empty?
+        @params.merge!(:captures => captured_params) if !captured_params.empty? && route.path.is_a?(Regexp)
+        @block_params = params
 
-          catch(:pass) do
-            begin
-              (route.before_filters - settings.filters[:before]).each{|block| instance_eval(&block) }
-              @layout = route.use_layout if route.use_layout
-              route.custom_conditions.each {|block|
-                pass if block.bind(self).call == false
-              } unless route.custom_conditions.empty?
-              halt_response     = catch(:halt){ route_eval{ route.block[self, captured_params] }}
-              @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
-              successful        = true
-              halt(halt_response)
-            ensure
-              (route.after_filters - settings.filters[:after]).each {|block| instance_eval(&block) } if successful
-              @layout, @params = parent_layout, original_params
-            end
+        filter! :before if options[:first]
+
+        catch(:pass) do
+          begin
+            (route.before_filters - settings.filters[:before]).each{|block| instance_eval(&block) }
+            @layout = route.use_layout if route.use_layout
+            route.custom_conditions.each {|block| pass if block.bind(self).call == false }
+            halt_response     = catch(:halt){ route_eval{ route.block[self, captured_params] }}
+            @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
+            successful        = true
+            halt(halt_response)
+          ensure
+            (route.after_filters - settings.filters[:after]).each {|block| instance_eval(&block) } if successful
+            @layout, @params = parent_layout, original_params
           end
         end
+      end
 
-        def route!(base = settings, pass_block = nil)
-          Thread.current['padrino.instance'] = self
-          code, headers, routes = base.compiled_router.call(@request.env)
+      def route!(base = settings, pass_block = nil)
+        Thread.current['padrino.instance'] = self
+        code, headers, routes = base.compiled_router.call(@request.env)
 
-          status(code)
-          if code == 200
-            routes.each_with_index do |(route, howl_params), index|
-              next if route.user_agent && !(route.user_agent =~ @request.user_agent)
-              invoke_route(route, howl_params, :first => index.zero?)
-            end
-          else
-            route_eval do
-              headers.each{|k, v| response[k] = v } unless headers.empty?
-              route_missing if code == 404
-              route_missing if allow = response['Allow'] and allow.include?(request.env['REQUEST_METHOD'])
-            end
+        status(code)
+        if code == 200
+          routes.each_with_index do |(route, howl_params), index|
+            next if route.user_agent && !(route.user_agent =~ @request.user_agent)
+            invoke_route(route, howl_params, :first => index.zero?)
           end
-
-          if base.superclass.respond_to?(:router)
-            route!(base.superclass, pass_block)
-            return
+        else
+          route_eval do
+            headers.each{|k, v| response[k] = v } unless headers.empty?
+            route_missing if code == 404
+            route_missing if allow = response['Allow'] and allow.include?(request.env['REQUEST_METHOD'])
           end
+        end
 
-          route_eval(&pass_block) if pass_block
-          route_missing
+        if base.superclass.respond_to?(:router)
+          route!(base.superclass, pass_block)
+          return
         end
+
+        route_eval(&pass_block) if pass_block
+        route_missing
+      end
     end
   end
 end

data/lib/howl-router/padrino/route.rb

@@ -3,7 +3,8 @@ require 'howl-router/route'
 class Howl
   module Padrino
     class Route < ::Howl::Route
-      attr_accessor :action, :cache, :parent, :use_layout, :controller, :user_agent
+      attr_accessor :action, :cache, :cache_key, :cache_expires_in,
+                    :parent, :use_layout, :controller, :user_agent
   
       def before_filters(&block)
         @_before_filters ||= []
@@ -31,6 +32,10 @@ class Howl
         [verb.to_s.upcase]
       end
 
+      def original_path 
+        @path 
+      end 
+
       def significant_variable_names
         @significant_variable_names ||= if @path.is_a?(String)
           @path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}

data/lib/howl-router/request.rb

@@ -3,9 +3,5 @@ require 'rack'
 class Howl
   class Request < Rack::Request
     attr_accessor :acceptable_methods
-
-    def path_info
-      Rack::Utils.unescape super
-    end
   end
 end

data/lib/howl-router/route.rb

@@ -3,7 +3,17 @@ class Howl
     attr_accessor :block, :capture, :router, :params, :name,
                   :order, :default_values, :path_for_generation, :verb
 
-    def initialize(path, options = {}, &block)
+    # @param [String, Regexp] path The path associate to this route.
+    # @yield The block associate to this route.
+    #
+    # @example
+    #
+    #   howl  = Howl.new
+    #   index = howl.add(:get "/") # returns Howl::Route
+    #   index.name = :index # Naming
+    #   index.verb = :get # Define a http verb.
+    #
+    def initialize(path, &block)
       @path     = path
       @params   = {}
       @capture  = {}
@@ -11,11 +21,19 @@ class Howl
       @block    = block if block_given?
     end
 
+    # Return a matcher which is wrapper of Mustermann or Regexp.
+    #
+    # @return [Howl::Matcher]
+    #
     def matcher
       @matcher ||= Matcher.new(@path, :capture        => @capture,
                                       :default_values => @default_values)
     end
 
+    # Return a block's arity.
+    #
+    # @return [Fixnum]
+    #
     def arity
       @block.arity
     end
@@ -24,12 +42,29 @@ class Howl
       @block.call(*args)
     end
 
+    # Add a block later, and this method define a priority for routing.
+    #
+    # @yield The block associate to this route later.
+    #
     def to(&block)
       @block = block if block_given?
       @order = @router.current_order
       @router.increment_order
     end
 
+    # Return a set path.
+    #
+    # @param [Hash] args[0] The hash for route's params.
+    #
+    # @example
+    #
+    #   howl = Howl.new
+    #   foo  = howl.add(:get, "/foo/:id")
+    #   foo.path #=> "/foo/:id"
+    #   foo.path(:id => 1) #=> "/foo/1"
+    #
+    # @return [String] path pattern or expanded path.
+    #
     def path(*args)
       return @path if args.empty?
       params = args[0]

data/lib/howl-router/router.rb

@@ -34,7 +34,7 @@ class Howl
           params[:captures] = match_data.captures
         else
           params.merge!(route.params).merge!(match_data.names.inject({}){|result, name|
-            result[name.to_sym] = match_data[name]
+            result[name.to_sym] = match_data[name] ? Rack::Utils.unescape(match_data[name]) : nil
             result
           }).merge!(request_params){|key, self_value, new_value| self_value || new_value }
         end

data/lib/howl-router/version.rb

@@ -1,3 +1,3 @@
 class Howl
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/test/padrino_test.rb

@@ -110,6 +110,16 @@ describe "Howl::Padrino" do
     assert_equal 'success!', body    
   end
 
+  should 'parse routes that include encoded slash' do
+    mock_app do
+      get('/:drive_alias/:path', :path => /.*/){
+        "Show #{params[:drive_alias]} and #{params[:path]}"
+      }
+    end
+    get("/drive%2Ffoo/some/path")
+    assert_equal "Show drive/foo and some/path", body
+  end
+
   should 'parse route that contains encoded param.' do
     mock_app do
       get('/foo/:name'){ params[:name] }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: howl-router
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - namusyaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-25 00:00:00.000000000 Z
+date: 2013-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack