roda 0.9.0

data/lib/roda/plugins/streaming.rb

@@ -0,0 +1,165 @@
+class Roda
+  module RodaPlugins
+    # The streaming plugin adds support for streaming responses
+    # from roda using the +stream+ method:
+    #
+    #   plugin :streaming
+    #
+    #   route do |r|
+    #     stream do |out|
+    #       ['a', 'b', 'c'].each{|v| out << v; sleep 1}
+    #     end
+    #   end
+    #
+    # In order for streaming to work, any webservers used in
+    # front of the roda app must not buffer responses.
+    #
+    # The stream method takes the following options:
+    #
+    # :callback :: A callback proc to call when the connection is
+    #              closed.
+    # :keep_open :: Whether to keep the connection open after the
+    #               stream block returns, default is false.
+    # :loop :: Whether to call the stream block continuously until
+    #          the connection is closed.
+    #
+    # The implementation was originally taken from Sinatra,
+    # which is also released under the MIT License:
+    #
+    # Copyright (c) 2007, 2008, 2009 Blake Mizerany
+    # Copyright (c) 2010, 2011, 2012, 2013, 2014 Konstantin Haase
+    # 
+    # Permission is hereby granted, free of charge, to any person
+    # obtaining a copy of this software and associated documentation
+    # files (the "Software"), to deal in the Software without
+    # restriction, including without limitation the rights to use,
+    # copy, modify, merge, publish, distribute, sublicense, and/or sell
+    # copies of the Software, and to permit persons to whom the
+    # Software is furnished to do so, subject to the following
+    # conditions:
+    # 
+    # The above copyright notice and this permission notice shall be
+    # included in all copies or substantial portions of the Software.
+    # 
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+    # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+    # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+    # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    # OTHER DEALINGS IN THE SOFTWARE.
+    module Streaming
+      # Class of the response body in case you use #stream.
+      #
+      # Three things really matter: The front and back block (back being the
+      # block generating content, front the one sending it to the client) and
+      # the scheduler, integrating with whatever concurrency feature the Rack
+      # handler is using.
+      #
+      # Scheduler has to respond to defer and schedule.
+      class Stream
+        include Enumerable
+
+        # The default scheduler to used when streaming, useful for code
+        # using ruby's default threading support.
+        class Scheduler
+          # Store the stream to schedule.
+          def initialize(stream)
+            @stream = stream
+          end
+
+          # Immediately yield.
+          def defer(*)
+            yield
+          end
+
+          # Close the stream if there is an exception when scheduling,
+          # and reraise the exception if so.
+          def schedule(*)
+            yield
+          rescue Exception
+            @stream.close
+            raise
+          end
+        end
+
+        # Handle streaming options, see Streaming for details.
+        def initialize(opts={}, &back)
+          @scheduler = opts[:scheduler] || Scheduler.new(self)
+          @back = back.to_proc
+          @keep_open = opts[:keep_open]
+          @callbacks = []
+          @closed = false
+
+          if opts[:callback]
+            callback(&opts[:callback])
+          end
+        end
+
+        # Add output to the streaming response body.
+        def <<(data)
+          @scheduler.schedule{@front.call(data.to_s)}
+          self
+        end
+
+        # Add the given block as a callback to call when the block closes.
+        def callback(&block)
+          return yield if closed?
+          @callbacks << block
+        end
+
+        # Alias to callback for EventMachine compatibility.
+        alias errback callback
+
+        # If not already closed, close the connection, and call
+        # any callbacks.
+        def close
+          return if closed?
+          @closed = true
+          @scheduler.schedule{@callbacks.each{|c| c.call}}
+        end
+
+        # Whether the connection has already been closed.
+        def closed?
+          @closed
+        end
+
+        # Yield values to the block as they are passed in via #<<.
+        def each(&front)
+          @front = front
+          @scheduler.defer do
+            begin
+              @back.call(self)
+            rescue Exception => e
+              @scheduler.schedule{raise e}
+            end
+            close unless @keep_open
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Immediately return a streaming response using the current response
+        # status and headers, calling the block to get the streaming response.
+        # See Streaming for details.
+        def stream(opts={}, &block)
+          opts = opts.merge(:scheduler=>EventMachine) if !opts.has_key?(:scheduler) && env['async.callback']
+
+          if opts[:loop]
+            block = proc do |out|
+              until out.closed?
+                yield(out)
+              end
+            end
+          end
+
+          res = response
+          request.halt [res.status || 200, res.headers, Stream.new(opts, &block)]
+        end
+      end
+    end
+
+    register_plugin(:streaming, Streaming)
+  end
+end

data/spec/composition_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path("spec_helper", File.dirname(__FILE__))
+
+describe "r.run" do
+  it "should allow composition of apps" do
+    a = app do |r|
+      r.on "services/:id" do |id|
+        "View #{id}"
+      end
+    end
+
+    app(:new) do |r|
+      r.on "provider" do
+        r.run a
+      end
+    end
+
+    body("/provider/services/101").should == 'View 101'
+  end
+end

data/spec/env_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path("spec_helper", File.dirname(__FILE__))
+
+describe "Roda#env" do
+  it "should return the environment" do
+    app do |r|
+      env['PATH_INFO']
+    end
+
+    body("/foo").should ==  "/foo"
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path("spec_helper", File.dirname(__FILE__))
+
+describe "integration" do 
+  before do
+    @c = Class.new do
+      def initialize(app, first, second, &block)
+        @app, @first, @second, @block = app, first, second, block
+      end
+
+      def call(env)
+        env["m.first"] = @first
+        env["m.second"] = @second
+        env["m.block"] = @block.call
+
+        @app.call(env)
+      end
+    end
+
+  end
+
+  it "should setup middleware using use " do
+    c = @c
+    app(:bare) do 
+      use c, "First", "Second" do
+        "Block"
+      end
+
+      route do |r|
+        r.get "hello" do
+          "D #{r.env['m.first']} #{r.env['m.second']} #{r.env['m.block']}"
+        end
+      end
+    end
+
+    body('/hello').should == 'D First Second Block'
+  end
+
+  it "should inherit middleware in subclass " do
+    c = @c
+    @app = Class.new(app(:bare){use(c, '1', '2'){"3"}})
+    @app.route do  |r|
+      r.get "hello" do
+        "D #{r.env['m.first']} #{r.env['m.second']} #{r.env['m.block']}"
+      end
+    end
+
+    body('/hello').should == 'D 1 2 3'
+  end
+
+  it "should not have future middleware additions to parent class affect subclass " do
+    c = @c
+    a = app
+    @app = Class.new(a)
+    @app.route do  |r|
+      r.get "hello" do
+        "D #{r.env['m.first']} #{r.env['m.second']} #{r.env['m.block']}"
+      end
+    end
+    a.use(c, '1', '2'){"3"}
+
+    body('/hello').should == 'D   '
+  end
+end

data/spec/matchers_spec.rb

@@ -0,0 +1,658 @@
+require File.expand_path("spec_helper", File.dirname(__FILE__))
+
+describe "capturing" do
+  it "doesn't yield the verb" do
+    app do |r|
+      r.get do |*args|
+        args.size.to_s
+      end
+    end
+
+    body.should == '0'
+  end
+
+  it "doesn't yield the path" do
+    app do |r|
+      r.get "home" do |*args|
+        args.size.to_s
+      end
+    end
+
+    body('/home').should == '0'
+  end
+
+  it "yields the segment" do
+    app do |r|
+      r.get "user", :id do |id|
+        id
+      end
+    end
+
+    body("/user/johndoe").should == 'johndoe'
+  end
+
+  it "yields a number" do
+    app do |r|
+      r.get "user", :id do |id|
+        id
+      end
+    end
+
+    body("/user/101").should == '101'
+  end
+
+  it "yields a segment per nested block" do
+    app do |r|
+      r.on :one do |one|
+        r.on :two do |two|
+          r.on :three do |three|
+            one + two + three
+          end
+        end
+      end
+    end
+
+    body("/one/two/three").should == "onetwothree"
+  end
+
+  it "regex captures in regex format" do
+    app do |r|
+      r.get %r{posts/(\d+)-(.*)} do |id, slug|
+        id + slug
+      end
+    end
+
+    body("/posts/123-postal-service").should == "123postal-service"
+  end
+end
+
+describe "r.is" do 
+  it "ensures the patch is matched fully" do
+    app do |r|
+      r.is "" do
+        "+1"
+      end
+    end
+
+    body.should == '+1'
+    status('//').should == 404
+  end
+
+  it "handles no arguments" do
+    app do |r|
+      r.on "" do
+        r.is do
+          "+1"
+        end
+      end
+    end
+
+    body.should == '+1'
+    status('//').should == 404
+  end
+
+  it "matches strings" do
+    app do |r|
+      r.is "123" do
+        "+1"
+      end
+    end
+
+    body("/123").should == '+1'
+    status("/123/").should == 404
+  end
+
+  it "matches regexps" do
+    app do |r|
+      r.is /(\w+)/ do |id|
+        id
+      end
+    end
+
+    body("/123").should == '123'
+    status("/123/").should == 404
+  end
+
+  it "matches segments" do
+    app do |r|
+      r.is :id do |id|
+        id
+      end
+    end
+
+    body("/123").should == '123'
+    status("/123/").should == 404
+  end
+end
+
+describe "matchers" do
+  it "should handle string with embedded param" do
+    app do |r|
+      r.on "posts/:id" do |id|
+        id
+      end
+    end
+
+    body('/posts/123').should == '123'
+    status('/post/123').should == 404
+  end
+
+  it "should handle multiple params in single string" do
+    app do |r|
+      r.on "u/:uid/posts/:id" do |uid, id|
+        uid + id
+      end
+    end
+
+    body("/u/jdoe/posts/123").should == 'jdoe123'
+    status("/u/jdoe/pots/123").should == 404
+  end
+
+  it "should escape regexp metacharaters in string" do
+    app do |r|
+      r.on "u/:uid/posts?/:id" do |uid, id|
+        uid + id
+      end
+    end
+
+    body("/u/jdoe/posts?/123").should == 'jdoe123'
+    status("/u/jdoe/post/123").should == 404
+  end
+
+  it "should handle colons by themselves" do
+    app do |r|
+      r.on "u/:/:uid/posts/::id" do |uid, id|
+        uid + id
+      end
+    end
+
+    body("/u/:/jdoe/posts/:123").should == 'jdoe123'
+    status("/u/a/jdoe/post/b123").should == 404
+  end
+
+  it "should handle regexes and nesting" do
+    app do |r|
+      r.on(/u\/(\w+)/) do |uid|
+        r.on(/posts\/(\d+)/) do |id|
+          uid + id
+        end
+      end
+    end
+
+    body("/u/jdoe/posts/123").should == 'jdoe123'
+    status("/u/jdoe/pots/123").should == 404
+  end
+
+  it "should handle regex nesting colon param style" do
+    app do |r|
+      r.on(/u:(\w+)/) do |uid|
+        r.on(/posts:(\d+)/) do |id|
+          uid + id
+        end
+      end
+    end
+
+    body("/u:jdoe/posts:123").should == 'jdoe123'
+    status("/u:jdoe/poss:123").should == 404
+  end
+
+  it "symbol matching" do
+    app do |r|
+      r.on "user", :id do |uid|
+        r.on "posts", :pid do |id|
+          uid + id
+        end
+      end
+    end
+
+    body("/user/jdoe/posts/123").should == 'jdoe123'
+    status("/user/jdoe/pots/123").should == 404
+  end
+
+  it "paths and numbers" do
+    app do |r|
+      r.on "about" do
+        r.on :one, :two do |one, two|
+          one + two
+        end
+      end
+    end
+
+    body("/about/1/2").should == '12'
+    status("/about/1").should == 404
+  end
+
+  it "paths and decimals" do
+    app do |r|
+     r.on "about" do
+        r.on(/(\d+)/) do |one|
+          one
+        end
+      end
+    end
+
+    body("/about/1").should == '1'
+    status("/about/1.2").should == 404
+  end
+
+  it "should allow arrays to match any value" do
+    app do |r|
+      r.on [/(\d+)/, /\d+(bar)?/] do |id|
+        id
+      end
+    end
+
+    body('/123').should == '123'
+    body('/123bar').should == 'bar'
+    status('/123bard').should == 404
+  end
+
+  it "should have array capture match string if match" do
+    app do |r|
+      r.on %w'p q' do |id|
+        id
+      end
+    end
+
+    body('/p').should == 'p'
+    body('/q').should == 'q'
+    status('/r').should == 404
+  end
+end
+
+describe "r.on" do 
+  it "executes on no arguments" do
+    app do |r|
+      r.on do
+        "+1"
+      end
+    end
+
+    body.should == '+1'
+  end
+
+  it "executes on true" do
+    app do |r|
+      r.on true do
+        "+1"
+      end
+    end
+
+    body.should == '+1'
+  end
+
+  it "executes on non-false" do
+    app do |r|
+      r.on "123" do
+        "+1"
+      end
+    end
+
+    body("/123").should == '+1'
+  end
+
+  it "ensures SCRIPT_NAME and PATH_INFO are reverted" do
+    app do |r|
+      r.on lambda { r.env["SCRIPT_NAME"] = "/hello"; false } do
+        "Unreachable"
+      end
+      
+      r.on do
+        r.env["SCRIPT_NAME"] + ':' + r.env["PATH_INFO"]
+      end
+    end
+
+    body("/hello").should == ':/hello'
+  end
+
+  it "doesn't mutate SCRIPT_NAME or PATH_INFO after request is returned" do
+    app do |r|
+      r.on 'login', 'foo' do 
+        "Unreachable"
+      end
+      
+      r.on do
+        r.env["SCRIPT_NAME"] + ':' + r.env["PATH_INFO"]
+      end
+    end
+
+    pi, sn = '/login', ''
+    env = {"REQUEST_METHOD" => "GET", "PATH_INFO" => pi, "SCRIPT_NAME" => sn}
+    app.call(env)[2].join.should == ":/login"
+    env["PATH_INFO"].should equal(pi)
+    env["SCRIPT_NAME"].should equal(sn)
+  end
+
+  it "skips consecutive matches" do
+    app do |r|
+      r.on do
+        "foo"
+      end
+
+      r.on do
+        "bar"
+      end
+    end
+
+    body.should == "foo"
+  end
+
+  it "finds first match available" do
+    app do |r|
+      r.on false do
+        "foo"
+      end
+
+      r.on do
+        "bar"
+      end
+    end
+
+    body.should == "bar"
+  end
+
+  it "reverts a half-met matcher" do
+    app do |r|
+      r.on "post", false do
+        "Should be unmet"
+      end
+
+      r.on do
+        r.env["SCRIPT_NAME"] + ':' + r.env["PATH_INFO"]
+      end
+    end
+
+    body("/hello").should == ':/hello'
+  end
+
+  it "doesn't write to body if body already written to" do
+    app do |r|
+      r.on do
+        response.write "a"
+        "b"
+      end
+    end
+
+    body.should == 'a'
+  end
+end
+
+describe "param! matcher" do
+  it "should yield a param only if given and not empty" do
+    app do |r|
+      r.get "signup", :param! => "email" do |email|
+        email
+      end
+
+      r.on do
+        "No email"
+      end
+    end
+
+    io = StringIO.new
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").should == 'john@doe.com'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "").should == 'No email'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").should == 'No email'
+  end
+end
+
+describe "param matcher" do
+  it "should yield a param only if given" do
+    app do |r|
+      r.get "signup", :param=>"email" do |email|
+        email
+      end
+
+      r.on do
+        "No email"
+      end
+    end
+
+    io = StringIO.new
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").should == 'john@doe.com'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "").should == 'No email'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").should == ''
+  end
+end
+
+describe "path matchers" do 
+  it "one level path" do
+    app do |r|
+      r.on "about" do
+        "About"
+      end
+    end
+
+    body('/about').should == "About"
+    status("/abot").should == 404
+  end
+
+  it "two level nested paths" do
+    app do |r|
+      r.on "about" do
+        r.on "1" do
+          "+1"
+        end
+
+        r.on "2" do
+          "+2"
+        end
+      end
+    end
+
+    body('/about/1').should == "+1"
+    body('/about/2').should == "+2"
+    status('/about/3').should == 404
+  end
+
+  it "two level inlined paths" do
+    app do |r|
+      r.on "a/b" do
+        "ab"
+      end
+    end
+
+    body('/a/b').should == "ab"
+    status('/a/d').should == 404
+  end
+
+  it "a path with some regex captures" do
+    app do |r|
+      r.on /user(\d+)/ do |uid|
+        uid
+      end
+    end
+
+    body('/user123').should == "123"
+    status('/useradf').should == 404
+  end
+
+  it "matching the root" do
+    app do |r|
+      r.on "" do
+        "Home"
+      end
+    end
+
+    body.should == 'Home'
+    status("/foo").should == 404
+  end
+end
+
+describe "root/empty segment matching" do
+  it "matching an empty segment" do
+    app do |r|
+      r.on "" do
+        r.path
+      end
+    end
+
+    body.should == '/'
+    status("/foo").should == 404
+  end
+
+  it "nested empty segments" do
+    app do |r|
+      r.on "" do
+        r.on "" do
+          r.on "1" do
+            r.path
+          end
+        end
+      end
+    end
+
+    body("///1").should == '///1'
+    status("/1").should == 404
+    status("//1").should == 404
+  end
+
+  it "/events/? scenario" do
+    a = app do |r|
+      r.on "" do
+        "Hooray"
+      end
+
+      r.is do
+        "Foo"
+      end
+    end
+
+    app(:new) do |r|
+      r.on "events" do
+        r.run a
+      end
+    end
+
+    body("/events").should == 'Foo'
+    body("/events/").should == 'Hooray'
+    status("/events/foo").should == 404
+  end
+end
+
+describe "segment handling" do
+  before do
+    app do |r|
+      r.on "post" do
+        r.on :id do |id|
+          id
+        end
+      end
+    end
+  end
+
+  it "matches numeric ids" do
+    body('/post/1').should == '1'
+  end
+
+  it "matches decimal numbers" do
+    body('/post/1.1').should == '1.1'
+  end
+
+  it "matches slugs" do
+    body('/post/my-blog-post-about-cuba').should == 'my-blog-post-about-cuba'
+  end
+
+  it "matches only the first segment available" do
+    body('/post/one/two/three').should == 'one'
+  end
+end
+
+describe "request verb methods" do 
+  it "executes if verb matches" do
+    app do |r|
+      r.get do
+        "g"
+      end
+      r.post do
+        "p"
+      end
+    end
+
+    body.should == 'g'
+    body('REQUEST_METHOD'=>'POST').should == 'p'
+  end
+
+  it "requires exact match if given arguments" do
+    app do |r|
+      r.get "" do
+        "g"
+      end
+      r.post "" do
+        "p"
+      end
+    end
+
+    body.should == 'g'
+    body('REQUEST_METHOD'=>'POST').should == 'p'
+    status("/a").should == 404
+    status("/a", 'REQUEST_METHOD'=>'POST').should == 404
+  end
+
+  it "does not require exact match if given arguments" do
+    app do |r|
+      r.get do
+        r.is "" do
+          "g"
+        end
+
+        "get"
+      end
+      r.post do
+        r.is "" do
+          "p"
+        end
+
+        "post"
+      end
+    end
+
+    body.should == 'g'
+    body('REQUEST_METHOD'=>'POST').should == 'p'
+    body("/a").should == 'get'
+    body("/a", 'REQUEST_METHOD'=>'POST').should == 'post'
+  end
+end
+
+describe "extension matcher" do
+  it "should match given file extensions" do
+    app do |r|
+      r.on "styles" do
+        r.on :extension=>"css" do |file|
+          file
+        end
+      end
+    end
+
+    body("/styles/reset.css").should == 'reset'
+    status("/styles/reset.bar").should == 404
+  end
+end
+
+describe "method matcher" do
+  it "should match given request types" do
+    app do |r|
+      r.is "", :method=>:get do
+        "foo"
+      end
+      r.is "", :method=>[:patch, :post] do
+        "bar"
+      end
+    end
+
+    body("REQUEST_METHOD"=>"GET").should == 'foo'
+    body("REQUEST_METHOD"=>"PATCH").should == 'bar'
+    body("REQUEST_METHOD"=>"POST").should == 'bar'
+    status("REQUEST_METHOD"=>"DELETE").should == 404
+  end
+end
+
+describe "route block that returns string" do
+  it "should be treated as if an on block returned string" do
+    app do |r|
+      "+1"
+    end
+
+    body.should == '+1'
+  end
+end