truss-router 0.0.3 → 0.0.4

data/README.md

@@ -1,5 +1,6 @@
 # Truss Router
 [![Build Status](https://travis-ci.org/truss-io/router.png)](https://travis-ci.org/truss-io/router)
+[![Code Climate](https://codeclimate.com/github/truss-io/router.png)](https://codeclimate.com/github/truss-io/router)
 
 Truss Router is the first released part of Truss - a new wrapper around Rack to make writing performant Ruby web endpoints easier.
 Truss Router is currently considered alpha software, and as such please don't use in any production environment, but feel free to
@@ -7,10 +8,10 @@ explore and see how it handles for you.
 
 Truss supports the following Ruby platforms in Pure Ruby:
 
-* MRI 1.9.3
-* MRI 2.0.0
-* JRuby 1.7
-* RBX 1.9 mode
+* MRI 1.9.3 - [benchmarks](https://github.com/truss-io/router/wiki/Benchmarks-MRI-1.9.3)
+* MRI 2.0.0 - [benchmarks](https://github.com/truss-io/router/wiki/Benchmarks-MRI-2.0.0)
+* JRuby 1.7 - [benchmarks](https://github.com/truss-io/router/wiki/Benchmarks-JRuby)
+* RBX 1.9 mode - [benchmarks](https://github.com/truss-io/router/wiki/Benchmarks-RBX)
 
 ## Installation
 
@@ -83,3 +84,11 @@ MRI 1.9.3, which is worth investigating.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## Thanks and Inspiration
+
+Thanks first and foremost have to go to [Music Glue](http://musicglue.com) where I work for letting me play with amazing projects
+and do what I love for a living. 
+
+The inspiration for this project came from using [joshbuddy](https://github.com/joshboddy)'s [http_router](https://github.com/joshbuddy/http_router)
+project.

data/benchmarks/comparison_bench.rb

@@ -0,0 +1,77 @@
+require 'rack'
+require 'http_router'
+require 'usher'
+require 'benchmark'
+$:.unshift File.expand_path("../../lib", __FILE__)
+require File.expand_path("../../lib/truss-router", __FILE__)
+
+REQUEST = Rack::MockRequest.env_for("/home", method: "GET")
+APP     = ->(env){ [200, {'Content-Type' => 'text/plain'}, ["Hello World"]] }
+TIMES   = 50_000
+
+puts "Running with a single route\n\n"
+
+h = HttpRouter.new
+h.add('/home').to(APP)
+
+r = Usher::Interface.for(:rack) do
+    add('/home').to(APP)
+end
+
+Truss::Router.draw do |r|
+    r.get('/home', APP)
+end
+
+Benchmark.bmbm(12) do |x|
+    x.report("HTTP Router")     { TIMES.times { h.call(REQUEST) } }
+    x.report("Usher Router")    { TIMES.times { r.call(REQUEST) } }
+    x.report("Truss Router")    { TIMES.times { Truss::Router.call(REQUEST) } }
+end
+
+puts "\n\nRunning with 10 routes\n\n"
+BLOG_POST_REQ = Rack::MockRequest.env_for("/blog/posts/9", method: "GET")
+
+a = HttpRouter.new
+a.get('/home').to(APP)
+a.get('/news').to(APP)
+a.get('/articles/:id').to(APP)
+a.get('/staff/:name').to(APP)
+a.get('/contact-us').to(APP)
+a.get('/about-us').to(APP)
+a.post('/login').to(APP)
+a.delete('/logout').to(APP)
+a.get('/blog').to(APP)
+a.get('/blog/posts/:id').to(APP)
+
+routes = Usher::Interface.for(:rack) do
+    add('/home').to(APP)
+    add('/news').to(APP)
+    add('/articles/:id').to(APP)
+    add('/staff/:name').to(APP)
+    add('/contact-us').to(APP)
+    add('/about-us').to(APP)
+    add('/login').to(APP)
+    add('/logout').to(APP)
+    add('/blog').to(APP)
+    add('/blog/posts/:id').to(APP)
+end
+
+Truss::Router.reset!
+Truss::Router.draw do |r|
+    r.get("/home", APP)
+    r.get("/news", APP)
+    r.get("/articles/:id", APP)
+    r.get("/staff/:name", APP)
+    r.get("/contact-us", APP)
+    r.get("/about-us", APP)
+    r.post("/login", APP)
+    r.delete("/logout", APP)
+    r.get("/blog", APP)
+    r.get("/blog/posts/:id", APP)
+end
+
+Benchmark.bmbm(12) do |x|
+    x.report("HTTP Router")     { TIMES.times { a.call(BLOG_POST_REQ) } }
+    x.report("Usher Router")    { TIMES.times { routes.call(BLOG_POST_REQ) } }
+    x.report("Truss Router")    { TIMES.times { Truss::Router.call(BLOG_POST_REQ) } }
+end

data/lib/truss/router/node.rb

@@ -2,11 +2,15 @@ module Truss
     module Router
         class Node
             attr_accessor :request_method, :path, :has_dynamic_segments, 
-                          :endpoint, :matchable_regex, :options
+                          :endpoint, :matchable_regex, :options, :allowed_methods,
+                          :path_segments
+            
             def initialize(method, path, endpoint, options={})
                 @request_method, @path, @endpoint = method, path, endpoint
-                @has_dynamic_segments = false 
+                @has_dynamic_segments = false
                 @matchable_regex = build_matchable_regex(method, path, options)
+                @allowed_methods = discover_allowed_methods(method, path, options)
+                @path_segments   = get_path_segments(path)
                 @options = options
             end
 
@@ -30,23 +34,23 @@ module Truss
             def build_matchable_regex(method, path, options)
                 if path.include?(":")
                     self.has_dynamic_segments = true
-                    /\A#{method_group(method)}#{segment_string(path)}\Z/
+                    /\A#{segment_string(path)}\Z/
                 else
-                    %r[\A#{method_group(method)}#{path}\Z]
+                    %r[\A#{path}\Z]
                 end
             end
 
-            def method_group(method)
-                origin = case method
-                when :get
-                    "(GET|HEAD|OPTIONS)"
-                when :options
-                    "OPTIONS"
-                else
-                    "(#{method.to_s.upcase}|OPTIONS)"
-                end
+            def discover_allowed_methods(method, path, options)
+                allowed = [method.to_s.upcase]
+                allowed << "OPTIONS" if options.has_key?(:cors)
+                allowed << "HEAD" if (method == :get)
+                allowed
             end
 
+            def get_path_segments(path)
+                path.split("/").reject(&:empty?).count
+            end
+                    
             def segment_string(path)
                 components = path.split("/").map do |comp|
                     if comp[0] == ":"

data/lib/truss/router/request.rb

@@ -8,8 +8,10 @@ module Truss
                 super(*args)
             end
 
-            def routing_path
-                "#{request_method}#{path}"
+            def routing_path; path end
+
+            def segment_length
+                @seglength ||= path.split("/").reject(&:empty?).count
             end
         end
     end

data/lib/truss/router/routeset.rb

@@ -3,28 +3,30 @@ module Truss
         class Routeset
    
             attr_accessor :nodes
-            def initialize(nodes=[])
+            def initialize(nodes={})
                 @nodes = nodes
+                %w[GET HEAD OPTIONS POST PATCH PUT DELETE].each do |req|
+                    @nodes[req] ||= []
+                end
             end
 
             def add_node(node)
-                @nodes << node
-            end
-
-            def <<(node)
-                @nodes << node
+                node.allowed_methods.each do |req|
+                    @nodes[req] << node
+                end
             end
 
-            def [](node)
-                @nodes[node]
+            def nodes_for(type)
+                nodes[type]
             end
 
-            def length
-                @nodes.length
+            def total_nodes
+                nodes.map{|k,v| v.count}.flatten.inject(:+)
             end
 
             def find_route request
-                @nodes.detect do |node|
+                req_nodes = nodes_for(request.request_method).select{|n| (n.path_segments == request.segment_length) }
+                req_nodes.detect do |node|
                     node.matches?(request)
                 end
             end

data/lib/truss/router/version.rb

@@ -1,5 +1,5 @@
 module Truss
   module Router
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

data/lib/truss/router.rb

@@ -60,7 +60,7 @@ module Truss
 
         protected
         def build_node method, path, endpoint, opts
-            routeset << Routes.const_get(method).new(path, endpoint, opts)
+            routeset.add_node Routes.const_get(method).new(path, endpoint, opts)
         end
     end
 end

data/spec/lib/truss/draw_routes_spec.rb

@@ -42,13 +42,16 @@ describe Truss::Router do
                 subject.draw(&map)
             end
             it "should have two route" do
-                subject.routeset.length.should eq(2)
+                subject.routeset.total_nodes.should eq(3)
             end
-            it "should have a Get route as the first member of the routeset" do
-                subject.routeset[0].should be_kind_of(Truss::Router::Routes::Get)
+            it "should have a Get routeset with one member" do
+                subject.routeset.nodes_for("GET").length.should eq(1)
             end
-            it "should have a Post route as the second member of the routeset" do
-                subject.routeset[1].should be_kind_of(Truss::Router::Routes::Post)
+            it "should have an Head routeset with one member" do
+                subject.routeset.nodes_for("HEAD").length.should eq(1)
+            end
+            it "should have a Post routeset with one member" do
+                subject.routeset.nodes_for("POST").length.should eq(1)
             end
         end
     end

data/spec/lib/truss/route_dispatch_spec.rb

@@ -17,7 +17,7 @@ describe Truss::Router do
         end
 
         it "should return the first route for a matching path" do
-            subject[0].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("GET")[0].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(env)
         end
 
@@ -30,9 +30,9 @@ describe Truss::Router do
     context "multiple routes present" do
         let(:multiple_map) { ->(r){
                 r.get("/", app)
-                r.get("/home", app)
+                r.get("/home", app, cors: true)
                 r.get("/about", app)
-                r.post("/login", app)
+                r.post("/login", app, cors: true)
                 r.post("/home", app)
             }
         }
@@ -43,49 +43,49 @@ describe Truss::Router do
         end
 
         it "should call the second node given a get request for /home" do
-            subject[1].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
-            described_class.call(env)
+            subject.nodes_for("GET")[1].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            puts described_class.call(env)
         end
 
         it "should call the third node given a get request for /about" do
             about_env = Rack::MockRequest.env_for("/about", method: "GET")
-            subject[2].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("GET")[2].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(about_env)
         end
 
         it "should call the fourth node given a post request for /login" do
             login_env = Rack::MockRequest.env_for("/login", method: "POST")
-            subject[3].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("POST")[0].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(login_env)
         end
 
         it "should call the fifth node given a post request for /home" do
             post_home_env = Rack::MockRequest.env_for("/home", method: "POST")
-            subject[4].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("POST")[1].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(post_home_env)
         end
 
         it "should call the second node given an options request for /home" do
             options_home_env = Rack::MockRequest.env_for("/home", method: "OPTIONS")
-            subject[1].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("OPTIONS")[0].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(options_home_env)
         end
 
         it "should call the second node given a head request for /home" do
             head_home_env = Rack::MockRequest.env_for("/home", method: "HEAD")
-            subject[1].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("HEAD")[1].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(head_home_env)
         end
 
         it "should call the fourth node given an options request for /login" do
             options_login_env = Rack::MockRequest.env_for("/login", method: "OPTIONS")
-            subject[3].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("OPTIONS")[1].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(options_login_env)
         end
 
         it "should call the first node given a get request for /" do
             home_env = Rack::MockRequest.env_for("/", method: "GET")
-            subject[0].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
+            subject.nodes_for("GET")[0].should_receive(:call).exactly(1).times.with(kind_of(Truss::Router::Request))
             described_class.call(home_env)
         end
 

data/spec/lib/truss/router/node_spec.rb

@@ -11,52 +11,66 @@ describe Truss::Router::Node do
     it { should respond_to(:matchable_regex) }
     it { should respond_to(:call) }
 
-    describe "routing regexes" do
+    describe "routing constraints" do
         context "for get requests" do
             subject { Truss::Router::Node.new(:get, "/home", app) }
-            its(:matchable_regex) { should eq(%r[\A(GET|HEAD|OPTIONS)/home\Z]) }
+            its(:matchable_regex) { should eq(%r[\A/home\Z]) }
+            its(:path_segments)   { should eq(1) }
+            its(:allowed_methods) { should eq(%w[GET HEAD]) }
         end
 
         context "for post requests" do
             subject { Truss::Router::Node.new(:post, "/home", app) }
-            its(:matchable_regex) { should eq(%r[\A(POST|OPTIONS)/home\Z]) }
+            its(:matchable_regex) { should eq(%r[\A/home\Z]) }
+            its(:path_segments)   { should eq(1) }
+            its(:allowed_methods) { should eq(%w[POST]) }
         end
 
         context "for put requests" do
             subject { Truss::Router::Node.new(:put, "/home", app) }
-            its(:matchable_regex) { should eq(%r[\A(PUT|OPTIONS)/home\Z]) }
+            its(:matchable_regex) { should eq(%r[\A/home\Z]) }
+            its(:path_segments)   { should eq(1) }
+            its(:allowed_methods) { should eq(%w[PUT]) }
         end
         
         context "for patch requests" do
             subject { Truss::Router::Node.new(:patch, "/home", app) }
-            its(:matchable_regex) { should eq(%r[\A(PATCH|OPTIONS)/home\Z]) }
+            its(:matchable_regex) { should eq(%r[\A/home\Z]) }
+            its(:path_segments)   { should eq(1) }
+            its(:allowed_methods) { should eq(%w[PATCH]) }
         end
         
         context "for head requests" do
             subject { Truss::Router::Node.new(:head, "/home", app) }
-            its(:matchable_regex) { should eq(%r[\A(HEAD|OPTIONS)/home\Z]) }
+            its(:matchable_regex) { should eq(%r[\A/home\Z]) }
+            its(:path_segments)   { should eq(1) }
+            its(:allowed_methods) { should eq(%w[HEAD]) }
         end
         
         context "for options requests" do
             subject { Truss::Router::Node.new(:options, "/home", app) }
-            its(:matchable_regex) { should eq(%r[\AOPTIONS/home\Z]) }
+            its(:matchable_regex) { should eq(%r[\A/home\Z]) }
+            its(:path_segments)   { should eq(1) }
+            its(:allowed_methods) { should eq(%w[OPTIONS]) }
         end
         
         context "for delete requests" do
             subject { Truss::Router::Node.new(:delete, "/home", app) }
-            its(:matchable_regex) { should eq(%r[\A(DELETE|OPTIONS)/home\Z]) }
+            its(:matchable_regex) { should eq(%r[\A/home\Z]) }
+            its(:path_segments)   { should eq(1) }
+            its(:allowed_methods) { should eq(%w[DELETE]) }
         end
     end
 
     describe "dynamic segments" do
         context "single dynamic matcher" do
             subject { Truss::Router::Node.new(:delete, "/:id", app) }
-            its(:matchable_regex) { should eq(/\A(DELETE|OPTIONS)\/(?<id>[\w\-]+)\Z/) }
+            it { subject.matchable_regex.to_s.should eq(/\A\/(?<id>[\w\-]+)\Z/.to_s) }
         end
         
         context "multiple dynamic matchers" do
             subject { Truss::Router::Node.new(:delete, "/posts/:post_id/comments/:id", app) }
-            its(:matchable_regex) { should eq(/\A(DELETE|OPTIONS)\/posts\/(?<post_id>[\w\-]+)\/comments\/(?<id>[\w\-]+)\Z/) }
+            it { subject.matchable_regex.to_s.should eq(/\A\/posts\/(?<post_id>[\w\-]+)\/comments\/(?<id>[\w\-]+)\Z/.to_s) }
         end
    end
 end

data/spec/lib/truss/router/request_spec.rb

@@ -8,4 +8,5 @@ describe Truss::Router::Request do
     it { should respond_to(:routing_path) }
     it { should respond_to(:routing_params) }
     its(:routing_params) { should eq({}) }
+    its(:segment_length) { should eq(1) }
 end

data/spec/lib/truss/router/routeset_spec.rb

@@ -3,18 +3,20 @@ require 'truss/router/node'
 
 describe Truss::Router::Routeset do
     it { should respond_to(:nodes) }
+    it { should respond_to(:nodes_for) }
     it { should respond_to(:add_node) }
+    it { should respond_to(:total_nodes) }
+    it { subject.nodes.keys.sort.should eq(%w[GET HEAD OPTIONS PUT PATCH POST DELETE].sort) } 
 
     context "adding nodes" do
-        subject     { Truss::Router::Routeset.new }
         let(:app)   { ->(env){[200, {'Content-Type' => 'text/plain'}, ["Hello World"]]} }
         let(:node)  { Truss::Router::Node.new(:get, "/home", app, {}) }
         before(:each) { subject.add_node(node) }
 
-        it  { subject.nodes.length.should eq(1) }
+        it  { subject.nodes_for("GET").length.should eq(1) }
         it "can contain multiple nodes" do
             subject.add_node(node)
-            subject.nodes.length.should eq(2)
+            subject.nodes_for("GET").length.should eq(2)
         end
     end
 end

data/truss-router.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["john@musicglue.com"]
   spec.description   = %q{Truss Router is a modular Rack Router for Truss}
   spec.summary       = %q{Truss Router is a modular Rack Router for Truss}
-  spec.homepage      = "http://truss-io.github.io"
+  spec.homepage      = "http://truss-io.github.io/router"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: truss-router
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-05-26 00:00:00.000000000 Z
+date: 2013-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -89,6 +89,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/comparison_bench.rb
 - benchmarks/simple_bench.rb
 - lib/truss-router.rb
 - lib/truss/router.rb
@@ -121,7 +122,7 @@ files:
 - spec/lib/truss/router_spec.rb
 - spec/spec_helper.rb
 - truss-router.gemspec
-homepage: http://truss-io.github.io
+homepage: http://truss-io.github.io/router
 licenses:
 - MIT
 post_install_message: