RubyGems - http_router - Versions diffs - 0.5.4 → 0.6.0 - Mend

http_router 0.5.4 → 0.6.0

Files changed (37) hide show

data/lib/http_router.rb +58 -210
data/lib/http_router/node.rb +124 -226
data/lib/http_router/node/arbitrary.rb +16 -0
data/lib/http_router/node/free_regex.rb +19 -0
data/lib/http_router/node/glob.rb +16 -0
data/lib/http_router/node/glob_regex.rb +9 -0
data/lib/http_router/node/regex.rb +26 -0
data/lib/http_router/node/request.rb +44 -0
data/lib/http_router/node/spanning_regex.rb +16 -0
data/lib/http_router/node/variable.rb +11 -0
data/lib/http_router/optional_compiler.rb +8 -15
data/lib/http_router/path.rb +36 -49
data/lib/http_router/regex_route.rb +20 -0
data/lib/http_router/request.rb +26 -0
data/lib/http_router/response.rb +13 -0
data/lib/http_router/route.rb +121 -299
data/lib/http_router/version.rb +1 -1
data/test/helper.rb +11 -9
data/test/rack/test_urlmap.rb +9 -9
data/test/test_arbitrary.rb +18 -10
data/test/test_misc.rb +28 -28
data/test/test_mounting.rb +81 -81
data/test/test_request.rb +6 -0
data/test/test_trailing_slash.rb +0 -4
data/test/test_variable.rb +1 -9
metadata +16 -16
data/lib/http_router/glob.rb +0 -20
data/lib/http_router/interface/sinatra.rb +0 -149
data/lib/http_router/parts.rb +0 -24
data/lib/http_router/rack.rb +0 -18
data/lib/http_router/rack/builder.rb +0 -60
data/lib/http_router/rack/url_map.rb +0 -10
data/lib/http_router/root.rb +0 -36
data/lib/http_router/static.rb +0 -5
data/lib/http_router/variable.rb +0 -30
data/test/sinatra/recognize_spec.rb +0 -168
data/test/sinatra/test_recognize.rb +0 -150

data/lib/http_router/glob.rb DELETED Viewed

@@ -1,20 +0,0 @@
-class HttpRouter
-  class Glob < Variable
-    def matches?(parts)
-      return if @matches_with.nil? or parts.empty? or !match.begin(0)
-      @matches_with.match(parts.first)
-    end
-    def consume(match, parts)
-      if @matches_with
-        params = [parts.shift]
-        params << parts.shift while matches?(parts)
-        params
-      else
-        params = parts.dup
-        parts.clear
-        params
-      end
-    end
-  end
-end

data/lib/http_router/interface/sinatra.rb DELETED Viewed

@@ -1,149 +0,0 @@
-require 'http_router'
-class HttpRouter
-  module Interface
-    class Sinatra
-      def initialize
-        ::Sinatra.send(:include, Extension)
-      end
-      module Extension
-        def self.registered(app)
-          app.send(:include, Extension)
-        end
-        def self.included(base)
-          base.extend ClassMethods
-        end
-        def generate(name, *params)
-          self.class.generate(name, *params)
-        end
-        private
-          def route!(base=self.class, pass_block=nil)
-            if base.router and match = base.router.recognize(@request)
-              if match.first.respond_to?(:path)
-                @block_params = match.first.param_values
-                (@params ||= {}).merge!(match.first.params)
-                pass_block = catch(:pass) do
-                  route_eval(&match.first.path.route.dest)
-                end
-              elsif match.is_a?(Array)
-                route_eval {
-                  match[1].each{|k,v| response[k] = v}
-                  status match[0]
-                }
-              end
-            end
-            # Run routes defined in superclass.
-            if base.superclass.respond_to?(:router)
-              route! base.superclass, pass_block
-              return
-            end
-            route_eval(&pass_block) if pass_block
-            route_missing
-          end
-        module ClassMethods
-          def new(*args, &bk)
-            configure! unless @_configured
-            super(*args, &bk)
-          end
-          def route(verb, path, options={}, &block)
-            name = options.delete(:name)
-            define_method "#{verb} #{path}", &block
-            unbound_method = instance_method("#{verb} #{path}")
-            block = block.arity.zero? ?
-              proc { unbound_method.bind(self).call } :
-              proc { unbound_method.bind(self).call(*@block_params) }
-            invoke_hook(:route_added, verb, path, block)
-            route = router.add(path)
-            route.matching(options[:matching]) if options.key?(:matching)
-            route.request_method(verb)
-            route.host(options[:host]) if options.key?(:host)
-            route.name(name) if name
-            route.to(block)
-            route
-          end
-          def router
-            @router ||= HttpRouter.new
-            block_given? ? yield(@router) : @router
-          end
-          def generate(name, *params)
-            router.url(name, *params)
-          end
-          def reset!
-            router.reset!
-            super
-          end
-          def configure!
-            configure :development do
-              error 404 do
-                content_type 'text/html'
-                (<<-HTML).gsub(/^ {17}/, '')
-                <!DOCTYPE html>
-                <html>
-                <head>
-                  <style type="text/css">
-                  body { text-align:center;font-family:helvetica,arial;font-size:22px;
-                    color:#888;margin:20px}
-                  #c {margin:0 auto;width:500px;text-align:left}
-                  </style>
-                </head>
-                <body>
-                  <h2>Sinatra doesn't know this ditty.</h2>
-                  <div id="c">
-                    Try this:
-                    <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  "Hello World"\nend</pre>
-                  </div>
-                </body>
-                </html>
-                HTML
-              end
-              error 405 do
-                content_type 'text/html'
-                (<<-HTML).gsub(/^ {17}/, '')
-                <!DOCTYPE html>
-                <html>
-                <head>
-                  <style type="text/css">
-                  body { text-align:center;font-family:helvetica,arial;font-size:22px;
-                    color:#888;margin:20px}
-                  #c {margin:0 auto;width:500px;text-align:left}
-                  </style>
-                </head>
-                <body>
-                  <h2>Sinatra sorta knows this ditty, but the request method is not allowed.</h2>
-                </body>
-                </html>
-                HTML
-              end
-            end
-            @_configured = true
-          end
-        end # ClassMethods
-      end # Extension
-    end # Sinatra
-  end # Interface
-end # HttpRouter

data/lib/http_router/parts.rb DELETED Viewed

@@ -1,24 +0,0 @@
-class HttpRouter
-  class Parts < Array
-    SLASH = '/'.freeze
-    SLASH_RX = Regexp.new(SLASH)
-    def initialize(path)
-      super((path[0] == ?/ ? path[1, path.size] : path).split(SLASH_RX))
-    end
-    def whole_path
-      @whole_path ||= join(SLASH)
-    end
-    def shift
-      @whole_path = nil
-      super
-    end
-    def replace(ary)
-      @whole_path = nil
-      super
-    end
-  end
-end

data/lib/http_router/rack.rb DELETED Viewed

@@ -1,18 +0,0 @@
-class HttpRouter
-  module Rack
-    autoload :URLMap,  'http_router/rack/url_map'
-    autoload :Builder, 'http_router/rack/buidler'
-    # Monkey-patches Rack::Builder to use HttpRouter.
-    # See examples/rack_mapper.rb
-    def self.override_rack_builder!
-      ::Rack.class_eval("OriginalBuilder = Builder; HttpRouterBuilder = HttpRouter::Rack::Builder; remove_const :Builder; Builder = HttpRouterBuilder")
-    end
-    # Monkey-patches Rack::URLMap to use HttpRouter.
-    # See examples/rack_mapper.rb
-    def self.override_rack_urlmap!
-      ::Rack.class_eval("OriginalURLMap = URLMap; HttpRouterURLMap = HttpRouter::Rack::URLMap; remove_const :URLMap; URLMap = HttpRouterURLMap")
-    end
-  end
-end

data/lib/http_router/rack/builder.rb DELETED Viewed

@@ -1,60 +0,0 @@
-# Replacement for {Rack::Builder} which using HttpRouter to map requests instead of a simple Hash.
-# As well, add convenience methods for the request methods.
-class HttpRouter::Rack::Builder < ::Rack::Builder
-  def initialize(&block)
-    super
-  end
-  def router
-    @router ||= HttpRouter.new
-  end
-  # Maps a path to a block.
-  # @param path [String] Path to map to.
-  # @param options [Hash] Options for added path.
-  # @see HttpRouter#add
-  def map(path, options = nil, &block)
-    router.add(path).with_options(options).to(&block)
-    @ins << router unless @ins.last == router
-  end
-  # Maps a path with request methods `HEAD` and `GET` to a block.
-  # @param path [String] Path to map to.
-  # @param options [Hash] Options for added path.
-  # @see HttpRouter#add
-  def get(path, options = nil, &block)
-    router.get(path).with_options(options).to(&block)
-  end
-  # Maps a path with request methods `POST` to a block.
-  # @param path [String] Path to map to.
-  # @param options [Hash] Options for added path.
-  # @see HttpRouter#add
-  def post(path, options = nil, &block)
-    router.post(path).with_options(options).to(&block)
-  end
-  # Maps a path with request methods `PUT` to a block.
-  # @param path [String] Path to map to.
-  # @param options [Hash] Options for added path.
-  # @see HttpRouter#add
-  def put(path, options = nil, &block)
-    router.put(path).with_options(options).to(&block)
-  end
-  # Maps a path with request methods `DELETE` to a block.
-  # @param path [String] Path to map to.
-  # @param options [Hash] Options for added path.
-  # @see HttpRouter#add
-  def delete(path, options = nil, &block)
-    router.delete(path).with_options(options).to(&block)
-  end
-  # Maps a path with request methods `HEAD` to a block.
-  # @param path [String] Path to map to.
-  # @param options [Hash] Options for added path.
-  # @see HttpRouter#add
-  def head(path, options = nil, &block)
-    router.head(path).with_options(options).to(&block)
-  end
-end

data/lib/http_router/rack/url_map.rb DELETED Viewed

@@ -1,10 +0,0 @@
-class HttpRouter::Rack::URLMap < ::Rack::URLMap
-  def initialize(map = {})
-    @router = HttpRouter.new
-    map.each { |path, app| (path =~ /^(https?):\/\/(.*?)(\/.*)/ ? @router.add($3).host($2).scheme($1) : @router.add(path)).partial.to(app) }
-  end
-  def call(env)
-    @router.call(env)
-  end
-end

data/lib/http_router/root.rb DELETED Viewed

@@ -1,36 +0,0 @@
-class HttpRouter
-  class Root < Node
-    class AlternativeRequestMethods < Array
-      attr_accessor :request_method_found
-    end
-    def add_path(path)
-      node = path.parts.inject(self) { |node, part| node.add(part) }
-      node
-    end
-    def recognize(request)
-      call(request, :nocall)
-    end
-    def call(request, action = :call)
-      request = ::Rack::Request.new(request) if request.is_a?(Hash)
-      catch(:response) { find_on_parts(request, get_parts(request), action) } || construct_unmatched(request)
-    end
-    def construct_unmatched(request)
-      alternate_methods = (router.request_methods_specified - [request.request_method]).select do |alternate_method|
-        test_request = ::Rack::Request.new(request.env.dup)
-        test_request.env['REQUEST_METHOD'] = alternate_method
-        catch(:response) { find_on_parts(test_request, get_parts(request), :nocall) }
-      end
-      alternate_methods.empty? ? nil : ::Rack::Response.new("Method not found", 405, {"Allow" => alternate_methods.join(", ")}).finish
-    end
-    def get_parts(request)
-      parts = router.split(request.path_info)
-      parts << '' if request.path_info.size > 1 && request.path_info[-1] == ?/
-      parts
-    end
-  end
-end

data/lib/http_router/static.rb DELETED Viewed

@@ -1,5 +0,0 @@
-class HttpRouter
-  class Static < Regexp
-    attr_accessor :priority
-  end
-end

data/lib/http_router/variable.rb DELETED Viewed

@@ -1,30 +0,0 @@
-class HttpRouter
-  class Variable
-    attr_reader :name, :matches_with
-    attr_accessor :priority
-    def initialize(router, name, matches_with = nil, priority = 0)
-      @router, @name, @matches_with, @priority = router, name, matches_with, priority
-    end
-    def matches?(parts)
-      @matches_with.nil? or (@matches_with and match = @matches_with.match(parts.whole_path) and match.begin(0) == 0) ? match : nil
-    end
-    def consume(match, parts)
-      if @matches_with
-        parts.replace(router.split(parts.whole_path[match.end(0), parts.whole_path.size]))
-        match[0]
-      else
-        parts.shift
-      end
-    end
-    def ===(part)
-      @matches_with.nil?
-    end
-    protected
-      attr_reader :router
-  end
-end

data/test/sinatra/recognize_spec.rb DELETED Viewed

@@ -1,168 +0,0 @@
-require 'spec_helper'
-require "sinatra"
-require "http_router/interface/sinatra"
-describe "HttpRouter (for Sinatra) route recognition" do
-  before(:each) do
-    @app = Sinatra.new { register HttpRouter::Interface::Sinatra::Extension }
-    @app.extend(CallWithMockRequestMixin)
-    @app.reset!
-  end
-  describe "basic functionality" do
-    it "should map not found" do
-      response = @app.call_with_mock_request('/bar')
-      response.status.should == 404
-    end
-    it "should map index" do
-      @app.get("/") { "index" }
-      response = @app.call_with_mock_request('/')
-      response.status.should == 200
-      response.body.should == "index"
-    end
-    it "should ignore trailing delimiters" do
-      @app.get("/foo") { "foo" }
-      response = @app.call_with_mock_request('/foo')
-      response.status.should == 200
-      response.body.should == "foo"
-      response = @app.call_with_mock_request('/foo/')
-      response.status.should == 200
-      response.body.should == "foo"
-    end
-    it "should ignore trailing delimiters in a more advanced route" do
-      @app.get("/foo") { "foo" }
-      @app.get("/foo/bar") { "bar" }
-      response = @app.call_with_mock_request('/foo')
-      response.status.should == 200
-      response.body.should == "foo"
-      response = @app.call_with_mock_request('/foo/bar')
-      response.status.should == 200
-      response.body.should == "bar"
-      response = @app.call_with_mock_request('/foo/')
-      response.status.should == 200
-      response.body.should == "foo"
-      response = @app.call_with_mock_request('/foo/bar/')
-      response.status.should == 200
-      response.body.should == "bar"
-    end
-    it "should ignore trailing delimiters with an optional param" do
-      @app.get("/foo/(:bar)") { params[:bar] }
-      @app.get("/bar(/:foo)") { params[:foo] }
-      response = @app.call_with_mock_request('/foo/bar')
-      response.status.should == 200
-      response.body.should == "bar"
-      response = @app.call_with_mock_request('/bar/foo')
-      response.status.should == 200
-      response.body.should == "foo"
-      response = @app.call_with_mock_request('/bar')
-      response.status.should == 200
-      response.body.should == ""
-      response = @app.call_with_mock_request('/bar/')
-      response.status.should == 200
-      response.body.should == ""
-    end
-    it "should use sinatra optionals trailing delimiters" do
-      @app.get("/foo/?") { "foo" }
-      response = @app.call_with_mock_request('/foo')
-      response.status.should == 200
-      response.body.should == "foo"
-      response = @app.call_with_mock_request('/foo/')
-      response.status.should == 200
-      response.body.should == "foo"
-    end
-  end
-  describe "mapping functionality" do
-    it "should map a basic route" do
-      @app.get('/hi', :name => :hi) { generate(:hi) }
-      response = @app.call_with_mock_request('/hi')
-      response.status.should == 200
-      response.body.should == "/hi"
-    end
-    it "should map a basic route ignoring trailing delimiters" do
-      @app.get('/hi', :name => :hi) { generate(:hi) }
-      response = @app.call_with_mock_request('/hi/')
-      response.status.should == 200
-      response.body.should == "/hi"
-    end
-    it "should map a basic route with params" do
-      @app.get('/hi/:id', :name => :hi) { generate(:hi, :id => 18) }
-      response = @app.call_with_mock_request('/hi/1')
-      response.status.should == 200
-      response.body.should == "/hi/18"
-    end
-    it "should map route with params" do
-      @app.get('/hi-:id', :name => :hi) { generate(:hi, :id => 18) }
-      response = @app.call_with_mock_request('/hi-1')
-      response.status.should == 200
-      response.body.should == "/hi-18"
-    end
-    it "should map route with complex params" do
-      @app.get('/hi/:foo/:bar/:baz(.:format)') { "/#{params[:foo]}/#{params[:bar]}/#{params[:baz]}/#{params[:format]}" }
-      response = @app.call_with_mock_request('/hi/foo/bar/baz')
-      response.status.should == 200
-      response.body.should == "/foo/bar/baz/"
-      response = @app.call_with_mock_request('/hi/foo/bar-bax/baz')
-      response.status.should == 200
-      response.body.should == "/foo/bar-bax/baz/"
-    end
-  end
-  describe "matching by regexp" do
-    before :each do
-      @app.get('/numbers/:digits', :matching => { :digits => /\d+/ }) { params[:digits] }
-    end
-    describe "when regexp is matched" do
-      before :each do
-        @response = @app.call_with_mock_request('/numbers/2010')
-      end
-      it "should map successfully" do
-        @response.status.should == 200
-        @response.body.should == "2010"
-      end
-    end
-    describe "when regexp is not matched" do
-      before :each do
-        @response = @app.call_with_mock_request('/numbers/boobs')
-      end
-      it "should not map" do
-        @response.status.should == 404
-      end
-    end
-  end
-  describe "not found" do
-    it "should correctly generate a not found page without images" do
-      response = @app.call_with_mock_request('/bar')
-      response.status.should == 404
-      response.body.should_not match(/__sinatra__/)
-    end
-  end
-  describe "method not allowed" do
-    it "should correctly generate a not found page without images and return a 405" do
-      @app.post('/bar') { 'found' }
-      @app.put('/bar') { 'found' }
-      response = @app.call_with_mock_request('/bar')
-      response.status.should == 405
-      response.headers['Allow'].should == 'POST, PUT'
-      response.body.should_not match(/__sinatra__/)
-    end
-  end
-end