howl-router 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7762704358bdeef51e547cbcf8fd5c82ed290850
-  data.tar.gz: 6be61141decbb09555cb5419c5b68e1db83369a9
+  metadata.gz: dfff431b9195d8c14a112b7b379afd00c0bf4c04
+  data.tar.gz: 50df61f61b201f3a22d14e0e62a1ddf6d125bc6d
 SHA512:
-  metadata.gz: d2456c6071cad44e55290fcf59db6460a163da793073d0acb76ff36eb14a1c49562efccbb54203d34b7343d9f414dd006590ffffc714b32b186e5bb9e736f535
-  data.tar.gz: 9bcbe7162ef0a76bfe25597233df1b25c753ce2c68435e7e8f324ea7a020be6cb4b755e723ba6a3480ac0ce123e5b7f6ae254eae77196caa0d95e4553869f3b8
+  metadata.gz: 5926b02c4d7cdc8a1d126f6229c9af946b2a1655115ae34545e3acee887eea749c9232375a8a2fb11749b2526197ef7834c5b1a5642c1ded6c724b43c389bacf
+  data.tar.gz: d4bb4df2257a0ac345677c052a4859de0826b0f47f41f51a97f116b9dd6f73d9360a3f6b63a4d15f042c26d21535c94ba6da01fd0567f171658a893f8f37f244

data/lib/howl-router.rb

@@ -16,6 +16,10 @@ class Howl
     :server_error       => 500
   }
 
+  def initialize(&block)
+    instance_eval(&block) if block_given?
+  end
+
   # Generate a route, and add to routes.
   #
   # @param [String, Symbol] verb The verb decide a acceptable request method.
@@ -30,10 +34,8 @@ class Howl
   # @return [Howl::Route] Return a generated Howl::Route instance.
   #
   def add(verb, path, options = {}, &block)
-    verb = verb.downcase.to_sym
-    (router.routes_with_verbs[verb] ||= []) << (route = Route.new(path, &block))
-    route.path_for_generation = options[:path_for_generation] if options[:path_for_generation]
-    route.verb = verb
+    route        = Route.new(path, &block)
+    route.verb   = verb.downcase.to_sym
     route.router = router
     router.routes << route
     route
@@ -149,7 +151,7 @@ class Howl
       else
         params_for_expand = params.dup
       end
-      return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path_for_generation
+      return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path
     end
     raise InvalidRouteException
   end

data/lib/howl-router/matcher.rb

@@ -49,7 +49,7 @@ class Howl
 
     # @return [Boolean] This matcher's handler is mustermann ?
     def mustermann?
-      handler.class == Mustermann::Rails
+      handler.instance_of?(Mustermann::Sinatra)
     end
 
     # @return [Mustermann::Rails] Return a Mustermann::Rails when @path is string.
@@ -57,7 +57,7 @@ class Howl
     def handler
       @handler ||= case @path
       when String
-        Mustermann.new(@path, :type => :rails, :capture => @capture)
+        Mustermann.new(@path, :capture => @capture)
       when Regexp
         /^(?:#{@path})$/
       end

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

@@ -4,10 +4,9 @@ class Howl
   module Padrino
     class Core < ::Howl
       def add(verb, path, options = {}, &block)
-        verb = verb.downcase.to_sym
-        (router.routes_with_verbs[verb] ||= []) << (route = Route.new(path, &block))
+        route = Route.new(path, &block)
         route.path_for_generation = options[:path_for_generation] if options[:path_for_generation]
-        route.verb = verb
+        route.verb = verb.downcase.to_sym
         route.router = router
         router.routes << route
         route
@@ -16,9 +15,7 @@ class Howl
       def call(env)
         request  = Request.new(env)
         return bad_request unless HTTP_VERBS.include?(request.request_method.downcase.to_sym)
-
         compile unless compiled?
-
         begin
           matched_routes = recognize(request)
           [200, {}, matched_routes]
@@ -31,6 +28,27 @@ class Howl
         end
       end
 
+      def path(name, *args)
+        params = args.delete_at(args.last.is_a?(Hash) ? -1 : 0) || {}
+        saved_args = args.dup
+        router.routes.each do |route|
+          next unless route.name == name
+          matcher = route.matcher
+          if !args.empty? and matcher.mustermann?
+            matcher_names = matcher.names
+            params_for_expand = Hash[matcher_names.map{|matcher_name|
+              [matcher_name.to_sym, (params[matcher_name.to_sym] || args.shift)]
+            }]
+            params_for_expand.merge!(Hash[params.select{|k, v| !matcher_names.include?(name.to_sym) }])
+            args = saved_args.dup
+          else
+            params_for_expand = params.dup
+          end
+          return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path_for_generation
+        end
+        raise InvalidRouteException
+      end
+
       private
 
       def generate_response(key, headers = {})

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

@@ -2,7 +2,7 @@
 class Howl
   module Padrino
     module ClassMethods
-      CONTENT_TYPE_ALIASES = { :htm => :html } unless defined?(CONTENT_TYPE_ALIASES)
+      CONTENT_TYPE_ALIASES = {:htm => :html} unless defined?(CONTENT_TYPE_ALIASES)
       ROUTE_PRIORITY       = {:high => 0, :normal => 1, :low => 2} unless defined?(ROUTE_PRIORITY)
 
       def router
@@ -92,7 +92,7 @@ class Howl
         invoke_hook(:route_added, verb, path, block)
 
         # Howl route construction
-        path[0, 0] = "/" if path == "(.:format)"
+        path[0, 0] = "/" if path == "(.:format)?"
         route = router.add(verb.downcase.to_sym, path, route_options)
         route.name = name if name
         route.action = action
@@ -139,6 +139,7 @@ class Howl
           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 }
+          accepts = [] if accepts == ["*/*"]
 
           # per rfc2616-sec14:
           # Assume */* if no ACCEPT header is given.
@@ -175,6 +176,21 @@ class Howl
           matched_format
         end
       end
+
+      def process_path_for_parent_params(path, parent_params)
+        parent_prefix = parent_params.flatten.compact.uniq.map do |param|
+          map = (param.respond_to?(:map) && param.map ? param.map : param.to_s)
+          part = "#{map}/:#{param.to_s.singularize}_id/"
+          part = "(#{part})?" if param.respond_to?(:optional) && param.optional?
+          part
+        end
+
+        [parent_prefix, path].flatten.join("")
+      end
+
+      def process_path_for_provides(path, format_params)
+        path << "(.:format)?" unless path[-11, 11] == '(.:format)?'
+      end
     end
   end
 end

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

@@ -3,8 +3,8 @@ require 'howl-router/route'
 class Howl
   module Padrino
     class Route < ::Howl::Route
-      attr_accessor :action, :cache, :cache_key, :cache_expires_in,
-                    :parent, :use_layout, :controller, :user_agent
+      attr_accessor :action, :cache, :cache_key, :cache_expires_in, :parent,
+                    :use_layout, :controller, :user_agent, :path_for_generation
   
       def before_filters(&block)
         @_before_filters ||= []

data/lib/howl-router/route.rb

@@ -1,7 +1,7 @@
 class Howl
   class Route
-    attr_accessor :block, :capture, :router, :params, :name,
-                  :order, :default_values, :path_for_generation, :verb
+    attr_accessor :block, :capture, :router, :name,
+                  :order, :default_values, :verb
 
     # @param [String, Regexp] path The path associate to this route.
     # @yield The block associate to this route.
@@ -15,7 +15,6 @@ class Howl
     #
     def initialize(path, &block)
       @path     = path
-      @params   = {}
       @capture  = {}
       @order    = 0
       @block    = block if block_given?

data/lib/howl-router/router.rb

@@ -1,47 +1,33 @@
 class Howl
   class Router
-    attr_reader :current_order, :routes, :routes_with_verbs
+    attr_reader :current_order, :routes
 
     def initialize
       reset!
     end
 
     def recognize(request)
-      path_info, verb, request_params = request.is_a?(Hash) ? [request['PATH_INFO'], request['REQUEST_METHOD'], {}] :
-                                                              [request.path_info, request.request_method, request.params]
-      verb = verb.downcase.to_sym
+      path_info, verb, request_params = parse_request(request)
       ignore_slash_path_info = path_info
       ignore_slash_path_info = path_info[0..-2] if path_info != "/" and path_info[-1] == "/"
-
-      # Convert hash key into symbol.
-      request_params = request_params.inject({}) do |result, entry|
-        result[entry[0].to_sym] = entry[1]
-        result
-      end
-
-      all_matched_routes = @routes.select do |route|
-        matcher = route.matcher
-        matcher.match(matcher.mustermann? ? ignore_slash_path_info : path_info)
-      end
-      raise NotFound if all_matched_routes.empty? 
-
-      raise_method_not_allowed(request, all_matched_routes) unless routes_with_verbs.has_key?(verb)
-      result = all_matched_routes.map{|route|
+      matched_routes = scan_routes(path_info, ignore_slash_path_info)
+      raise NotFound if matched_routes.empty?
+      raise_method_not_allowed(request, matched_routes) unless matched_routes.find{|r|r.verb == verb}
+      result = matched_routes.map do |route|
         next unless verb == route.verb
         params, matcher = {}, route.matcher
         match_data = matcher.match(matcher.mustermann? ? ignore_slash_path_info : path_info)
         if match_data.names.empty?
           params[:captures] = match_data.captures
         else
-          params.merge!(route.params).merge!(match_data.names.inject({}){|result, name|
+          params.merge!(match_data.names.inject({}){|result, 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
         [route, params]
-      }.compact
-      raise_method_not_allowed(request, all_matched_routes) if result.empty?
-      result
+      end.compact
+      result.empty? ? raise_method_not_allowed(request, matched_routes) : result
     end
 
     def increment_order
@@ -50,18 +36,38 @@ class Howl
 
     def compile
       return if @current_order.zero?
-      @routes_with_verbs.each_value{|routes_with_verb|
-        routes_with_verb.sort!{|a, b| a.order <=> b.order }
-      }
       @routes.sort!{|a, b| a.order <=> b.order }
     end
 
     def reset!
       @routes            = []
-      @routes_with_verbs = {}
       @current_order     = 0
     end
 
+    private
+
+    def scan_routes(path_info, ignore_slash_path_info)
+      @routes.select do |route|
+        matcher = route.matcher
+        matcher.match(matcher.mustermann? ? ignore_slash_path_info : path_info)
+      end
+    end
+
+    def parse_request(request)
+      if request.is_a?(Hash)
+        [request['PATH_INFO'], request['REQUEST_METHOD'].downcase.to_sym, {}]
+      else
+        [request.path_info, request.request_method.downcase.to_sym, parse_request_params(request.params)]
+      end
+    end
+
+    def parse_request_params(params)
+      params.inject({}) do |result, entry|
+        result[entry[0].to_sym] = entry[1]
+        result
+      end
+    end
+
     def raise_method_not_allowed(request, matched_routes)
       request.acceptable_methods = matched_routes.map(&:verb)
       raise MethodNotAllowed

data/lib/howl-router/version.rb

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

data/test/howl_test.rb

@@ -84,7 +84,7 @@ describe Howl do
   describe "generate path" do
     before(:each){ @howl.reset! }
 
-    should "basic route of regexp" do
+    should "basic route" do
       index = @howl.add(:get, "/"){}
       index.name = :index
       foo_bar = @howl.add(:post, "/foo/bar"){}
@@ -97,7 +97,32 @@ describe Howl do
       assert_equal @howl.path(:users, :user_id => 1), "/users/1"
       assert_equal @howl.path(:users, :user_id => 1, :query => "string"), "/users/1?query=string"
     end
-  end
 
+    should "regexp" do
+      index = @howl.add(:get, /.+?/){}
+      index.name = :index
+      foo_bar = @howl.add(:post, /\d+/){}
+      foo_bar.name = :foo_bar
+
+      assert_equal @howl.path(:index), /.+?/
+      assert_equal @howl.path(:foo_bar), /\d+/
+    end
+  end
 
+  describe "#new allows block" do
+    should "#new support for block." do
+      @app = Howl.new do
+        foo = add(:get, "/"){"foo"}
+        bar = add(:post, "/"){"bar"}
+        foo.name = :foo
+        bar.name = :bar
+      end
+      get("/")
+      assert_equal "foo", body
+      post("/")
+      assert_equal "bar", body
+      assert_equal @app.path(:foo), "/"
+      assert_equal @app.path(:bar), "/"
+    end
+  end
 end

data/test/padrino_test.rb

@@ -448,14 +448,14 @@ describe "Howl::Padrino" do
   should "should inject the action name into the request" do
     mock_app do
       controller :posts do
-        get('/omnomnom(/:id)') { request.action.inspect }
+        get('/omnomnom(/:id)?') { request.action.inspect }
         controller :mini do
           get([:a, :b, :c]) { request.action.inspect }
         end
       end
     end
     get "/posts/omnomnom"
-    assert_equal "\"/omnomnom(/:id)\"", body
+    assert_equal "\"/omnomnom(/:id)?\"", body
     get "/mini/a/b/c"
     assert_equal ":a", body
   end
@@ -873,7 +873,7 @@ describe "Howl::Padrino" do
 
   should 'allow optionals' do
     mock_app do
-      get(:show, :map => "/stories/:type(/:category)") do
+      get(:show, :map => "/stories/:type(/:category)?") do
         "#{params[:type]}/#{params[:category]}"
       end
     end
@@ -1129,17 +1129,17 @@ describe "Howl::Padrino" do
     mock_app do
       provides :xml
 
-      get("/foo"){ "Foo in #{content_type}" }
-      get("/bar"){ "Bar in #{content_type}" }
+      get("/foo"){ "Foo in #{content_type.inspect}" }
+      get("/bar"){ "Bar in #{content_type.inspect}" }
     end
 
     get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-    assert_equal 'Foo in xml', body
+    assert_equal 'Foo in :xml', body
     get '/foo'
-    assert_equal 'Foo in xml', body
+    assert_equal 'Foo in :xml', body
 
     get '/bar', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-    assert_equal 'Bar in html', body
+    assert_equal 'Bar in nil', body
   end
 
   should "does not allow global provides in controller" do
@@ -1147,18 +1147,18 @@ describe "Howl::Padrino" do
       controller :base do
         provides :xml
 
-        get(:foo, "/foo"){ "Foo in #{content_type}" }
-        get(:bar, "/bar"){ "Bar in #{content_type}" }
+        get(:foo, "/foo"){ "Foo in #{content_type.inspect}" }
+        get(:bar, "/bar"){ "Bar in #{content_type.inspect}" }
       end
     end
 
     get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-    assert_equal 'Foo in xml', body
+    assert_equal 'Foo in :xml', body
     get '/foo'
-    assert_equal 'Foo in xml', body
+    assert_equal 'Foo in :xml', body
 
     get '/bar', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-    assert_equal 'Bar in html', body
+    assert_equal 'Bar in nil', body
   end
 
   should "map non named routes in controllers" do
@@ -1385,7 +1385,7 @@ describe "Howl::Padrino" do
 
   should 'works with optionals params' do
     mock_app do
-      get("/foo(/:bar)") { params[:bar] }
+      get("/foo(/:bar)?") { params[:bar] }
     end
 
     get "/foo/bar"
@@ -1488,7 +1488,7 @@ describe "Howl::Padrino" do
 
   should "use optionals params" do
     mock_app do
-      get(:index, :map => "/(:foo(/:bar))") { "#{params[:foo]}-#{params[:bar]}" }
+      get(:index, :map => "/:foo(/:bar)?") { "#{params[:foo]}-#{params[:bar]}" }
     end
     get "/foo"
     assert_equal "foo-", body

metadata

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