http_router_sinatra 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in http_router_sinatra.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    http_router_sinatra (0.0.1)
+      http_router (~> 0.6.1)
+      sinatra (~> 1.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    callsite (0.0.4)
+    code_stats (0.0.1)
+      dirge (>= 0.0.3)
+      rainbow
+    dirge (0.0.5)
+      callsite (>= 0.0.2)
+    http_router (0.6.1)
+      rack (>= 1.0.0)
+      url_mount (~> 0.2.1)
+    minitest (2.0.2)
+    phocus (1.1)
+    rack (1.2.2)
+    rainbow (1.1)
+    rake (0.8.7)
+    rbench (0.2.3)
+    sinatra (1.2.1)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    tilt (1.2.2)
+    url_mount (0.2.1)
+      rack
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  code_stats
+  http_router (~> 0.6.1)
+  http_router_sinatra!
+  minitest (~> 2.0.0)
+  phocus
+  rake
+  rbench
+  sinatra (~> 1.2.0)

data/README.md

@@ -0,0 +1,10 @@
+# HttpRouter for Sinatra
+
+## Usage
+
+In your Sinatra app, register your extension
+
+    register HttpRouter::Sinatra::Extension
+    
+Then, add your routes normally. If you use the :name option when defining your route, you can later generate your route
+with the `generate` method.

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+require 'code_stats'
+
+desc "Run tests"
+task :test do
+  $: << 'lib'
+  require 'http_router_sinatra'
+  require 'test/helper'
+  Dir['test/**/test_*.rb'].each { |test| require test }
+end
+
+require 'rake/rdoctask'
+desc "Generate documentation"
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'rdoc'
+end
+
+Bundler::GemHelper.install_tasks
+CodeStats::Tasks.new(:reporting_depth => 3)

data/http_router_sinatra.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "http_router_sinatra/version"
+
+Gem::Specification.new do |s|
+  s.name        = "http_router_sinatra"
+  s.version     = HttpRouter::Sinatra::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joshua Hull"]
+  s.email       = ["joshbuddy@gmail.com"]
+  s.homepage    = "https://github.com/joshbuddy/http_router_sinatra"
+  s.summary     = %q{Kick ass router for Sinatra based on http_router}
+  s.description = %q{Kick ass router for Sinatra based on http_router.}
+
+  s.rubyforge_project = "http_router_sinatra"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "http_router", "~> 0.6.2"
+  s.add_dependency "sinatra", "~> 1.2.0"
+  s.add_development_dependency 'minitest', '~> 2.0.0'
+  s.add_development_dependency 'code_stats'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rbench'
+  s.add_development_dependency 'phocus'
+  s.add_development_dependency 'bundler',  '~> 1.0.0'
+end

data/lib/http_router_sinatra.rb

@@ -0,0 +1,189 @@
+require 'http_router'
+require 'sinatra'
+
+class HttpRouter
+  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)
+          request.env['sinatra.instance'] = self
+          if base.router and match = base.router.recognize(request.env)
+            if match.respond_to?(:path)
+              throw :halt, @_response_buffer
+            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
+        ensure
+          @_response_buffer = nil
+        end
+
+      module ClassMethods
+
+        def new(*args, &bk)
+          configure! unless @_configured
+          super(*args, &bk)
+        end
+
+        def get(path, *args, &block)
+          conditions = @conditions.dup
+          route('GET', path, *args, &block)
+
+          @conditions = conditions
+          route('HEAD', path, *args, &block)
+        end
+
+        def put(path, *args, &bk);    route 'PUT',    path, *args, &bk end
+        def post(path, *args, &bk);   route 'POST',   path, *args, &bk end
+        def delete(path, *args, &bk); route 'DELETE', path, *args, &bk end
+        def head(path, *args, &bk);   route 'HEAD',   path, *args, &bk end
+
+        def route(verb, path, options={}, &block)
+          name = options.delete(:name)
+
+          path = transform_path(path)
+
+          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.send(verb.downcase.to_sym)
+          route.host(options[:host]) if options.key?(:host)
+          
+          route.name(name) if name
+
+          route.arbitrary_with_continue do |req, params|
+            if req.testing_405?
+              req.continue[true]
+            else
+              req.rack_request.env['sinatra.instance'].instance_eval do
+                handled = false
+                @block_params = req.params
+                (@params ||= {}).merge!(params)
+                pass_block = catch(:pass) do
+                  route_eval(&block)
+                  handled = true
+                end
+                req.continue[handled]
+              end
+            end
+          end
+
+          route.to(block)
+          route
+        end
+
+        def router
+          @router ||= HttpRouter.new
+          yield(@router) if block_given?
+          @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
+
+        private
+        def transform_path(path)
+          if path.is_a?(String)
+            path.gsub!(/\/\?$/, '(/)')
+          end
+          path
+        end
+      end # ClassMethods
+    end # Extension
+  end # Sinatra
+end # HttpRouter

data/lib/http_router_sinatra/version.rb

@@ -0,0 +1,5 @@
+class HttpRouter
+  class Sinatra
+    VERSION = "0.0.1"
+  end
+end

data/test/helper.rb

@@ -0,0 +1,74 @@
+require 'minitest/autorun'
+require 'phocus'
+
+class HttpRouter::Route
+  def default_destination
+    to{|env| Rack::Response.new("Routing to #{to_s}").finish}
+  end
+end
+
+class MiniTest::Unit::TestCase
+  def router(*args, &blk)
+    @router ||= HttpRouter.new(*args, &blk)
+    if blk
+      @router.routes.each do |route|
+        route.default_destination if route.dest.nil?
+      end
+      @router.routes.size > 1 ? @router.routes : @router.routes.first
+    else
+      @router
+    end
+  end
+
+  def assert_body(expect, response)
+    response = router.call(response) if response.is_a?(Hash)
+    body = case expect
+    when Array  then []
+    when String then ""
+    else             raise
+    end
+    response.last.each {|p| body << p}
+    assert_equal expect, body
+  end
+  
+  def assert_header(header, response)
+    response = router.call(response) if response.is_a?(Hash)
+    header.each{|k, v| assert_equal v, response[1][k]}
+  end
+
+  def assert_status(status, response)
+    response = router.call(response) if response.is_a?(Hash)
+    assert_equal status, response.first
+  end
+
+  def assert_route(route, request, params = nil, &blk)
+    if route.is_a?(String)
+      router.reset!
+      route = router.add(route)
+    end
+    route.to{|env| Rack::Response.new("Routing to #{route.to_s}").finish} if route && !route.compiled?
+    request = Rack::MockRequest.env_for(request) if request.is_a?(String)
+    response = @router.call(request)
+    if route
+      dest = "Routing to #{route.to_s}"
+      assert_equal [dest], response.last.body
+      if params
+        assert_equal params.size, request['router.params'].size
+        params.each { |k, v| assert_equal v, request['router.params'][k] }
+      elsif !request['router.params'].nil? and !request['router.params'].empty?
+        raise "Wasn't expecting any parameters, got #{request['router.params'].inspect}"
+      end
+    else
+      assert_equal 404, response.first
+    end
+  end
+  
+  def assert_generate(path, route, *args)
+    if route.is_a?(String)
+      router.reset!
+      route = router.add(route).to(path.to_sym)
+    end
+    route.to{|env| Rack::Response.new("Routing to #{route.to_s}").finish} if route.respond_to?(:compiled?) && !route.compiled?
+    assert_equal path, router.url(route, *args)
+  end
+end

data/test/test_recognize.rb

@@ -0,0 +1,145 @@
+module CallWithMockRequestMixin
+  def call_with_mock_request(url = "/sample", method = "GET")
+    Rack::MockRequest.new(self).request(method, url)
+  end
+end
+
+class TestRecognize < MiniTest::Unit::TestCase
+
+  def setup
+    @app = Sinatra.new { register HttpRouter::Sinatra::Extension }
+    @app.extend(CallWithMockRequestMixin)
+    @app.reset!
+  end
+
+  def test_basic
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 404, response.status
+  end
+  
+  def test_map_index
+    @app.get("/") { "index" }
+    response = @app.call_with_mock_request('/')
+    assert_equal 200, response.status
+    assert_equal "index", response.body
+  end
+  
+  def test_trailing_slash
+    @app.get("/foo") { "foo" }
+    response = @app.call_with_mock_request('/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+  end
+  
+  def test_trailing_slash2
+    @app.get("/foo") { "foo" }
+    @app.get("/foo/bar") { "bar" }
+    response = @app.call_with_mock_request('/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/bar')
+    assert_equal 200, response.status
+    assert_equal "bar", response.body
+    response = @app.call_with_mock_request('/foo/')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/bar/')
+    assert_equal 200, response.status
+    assert_equal "bar", response.body
+  end
+  
+  def test_trailing_slash_with_optional_param
+    @app.get("/foo/(:bar)") { params[:bar] }
+    @app.get("/bar(/:foo)") { params[:foo] }
+    response = @app.call_with_mock_request('/foo/bar')
+    assert_equal 200, response.status
+    assert_equal "bar", response.body
+    response = @app.call_with_mock_request('/bar/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 200, response.status
+    assert_equal "", response.body
+    response = @app.call_with_mock_request('/bar/')
+    assert_equal 200, response.status
+    assert_equal "", response.body
+  end
+
+  def test_trailing_question_mark
+    @app.get("/foo/?") { "foo" }
+    response = @app.call_with_mock_request('/foo')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+    response = @app.call_with_mock_request('/foo/')
+    assert_equal 200, response.status
+    assert_equal "foo", response.body
+  end
+  
+  def test_map_basic
+    @app.get('/hi', :name => :hi) { generate(:hi) }
+    response = @app.call_with_mock_request('/hi')
+    assert_equal 200, response.status
+    assert_equal "/hi", response.body
+  end
+
+  def test_map_basic2
+    @app.get('/hi', :name => :hi) { generate(:hi) }
+    response = @app.call_with_mock_request('/hi/')
+    assert_equal 200, response.status
+    assert_equal "/hi", response.body
+  end
+  
+  def test_map_param
+    @app.get('/hi/:id', :name => :hi) { generate(:hi, :id => 18) }
+    response = @app.call_with_mock_request('/hi/1')
+    assert_equal 200, response.status
+    assert_equal "/hi/18", response.body
+  end
+  
+  def test_map_param2
+    @app.get('/hi-:id', :name => :hi) { generate(:hi, :id => 18) }
+    response = @app.call_with_mock_request('/hi-1')
+    assert_equal 200, response.status
+    assert_equal "/hi-18", response.body
+  end
+  
+  def test_map_complex
+    @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')
+    assert_equal 200, response.status
+    assert_equal "/foo/bar/baz/", response.body
+    response = @app.call_with_mock_request('/hi/foo/bar-bax/baz')
+    assert_equal 200, response.status
+    assert_equal "/foo/bar-bax/baz/", response.body
+  end
+
+  def test_map_regexp
+    @app.get('/numbers/:digits', :matching => { :digits => /\d+/ }) { params[:digits] }
+    response = @app.call_with_mock_request('/numbers/2010')
+    assert_equal 200, response.status
+    assert_equal "2010", response.body
+  end
+
+  def test_not_map_regex
+    @app.get('/numbers/:digits', :matching => { :digits => /\d+/ }) { params[:digits] }
+    response = @app.call_with_mock_request('/numbers/nan')
+    assert_equal 404, response.status
+  end
+
+  def test_404
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 404, response.status
+    assert_match response.body, /Sinatra doesn't know this ditty/
+  end
+
+  def test_405
+    @app.post('/bar') { 'foundpost' }
+    @app.put('/bar') { 'foundput' }
+    response = @app.call_with_mock_request('/bar')
+    assert_equal 405, response.status
+    assert_equal ['POST', 'PUT'], response.headers['Allow'].split(/\s*,\s*/).sort
+  end
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification 
+name: http_router_sinatra
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joshua Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: http_router
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 6
+        - 2
+        version: 0.6.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: code_stats
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rbench
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: phocus
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id008
+description: Kick ass router for Sinatra based on http_router.
+email: 
+- joshbuddy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- http_router_sinatra.gemspec
+- lib/http_router_sinatra.rb
+- lib/http_router_sinatra/version.rb
+- test/helper.rb
+- test/test_recognize.rb
+has_rdoc: true
+homepage: https://github.com/joshbuddy/http_router_sinatra
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: http_router_sinatra
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Kick ass router for Sinatra based on http_router
+test_files: 
+- test/helper.rb
+- test/test_recognize.rb