jellyfish 0.6.0 → 0.8.0

data/lib/jellyfish/test.rb

@@ -8,8 +8,13 @@ Bacon.summary_on_exit
 shared :jellyfish do
   %w[options get head post put delete patch].each do |method|
     instance_eval <<-RUBY
-      def #{method} path='/', app=app
-        app.call('PATH_INFO' => path, 'REQUEST_METHOD' => '#{method}'.upcase)
+      def #{method} path='/', app=app, env={}
+        File.open(File::NULL) do |input|
+          app.call({'PATH_INFO'      => path              ,
+                    'REQUEST_METHOD' => '#{method}'.upcase,
+                    'SCRIPT_NAME'    => ''                ,
+                    'rack.input'     => input             }.merge(env))
+        end
       end
     RUBY
   end

data/lib/jellyfish/version.rb

@@ -1,4 +1,4 @@
 
 module Jellyfish
-  VERSION = '0.6.0'
+  VERSION = '0.8.0'
 end

data/task/gemgem.rb

@@ -14,6 +14,7 @@ module Gemgem
 
       s.description = description.join
       s.summary     = description.first
+      s.license     = readme['LICENSE'].sub(/.+\n\n/, '').lines.first.strip
 
       s.rubygems_version = Gem::VERSION
       s.date             = Time.now.strftime('%Y-%m-%d')
@@ -33,8 +34,8 @@ module Gemgem
     @readme ||=
       if path
         ps = "##{File.read(path)}".
-             scan(/((#+)[^\n]+\n\n.+?(?=\n\n\2[^#\n]+\n))/m).map(&:first)
-        ps.inject({'HEADER' => ps.first}){ |r, s, i|
+             scan(/((#+)[^\n]+\n\n.+?(?=(\n\n\2[^#\n]+\n)|\Z))/m).map(&:first)
+        ps.inject('HEADER' => ps.first){ |r, s, i|
           r[s[/\w+/]] = s
           r
         }
@@ -44,7 +45,7 @@ module Gemgem
   end
 
   def description
-    @description ||= (readme['DESCRIPTION']||'').sub(/.+\n\n/, '').lines.to_a
+    @description ||= (readme['DESCRIPTION']||'').sub(/.+\n\n/, '').lines
   end
 
   def changes
@@ -104,9 +105,9 @@ module Gemgem
   end
 
   def split_lines ruby
-    ruby.gsub(/(.+?)\[(.+?)\]/){ |s|
+    ruby.gsub(/(.+?)\s*=\s*\[(.+?)\]/){ |s|
       if $2.index(',')
-        "#{$1}[\n  #{$2.split(',').map(&:strip).join(",\n  ")}]"
+        "#{$1} = [\n  #{$2.split(',').map(&:strip).join(",\n  ")}]"
       else
         s
       end
@@ -179,7 +180,7 @@ namespace :gem do
 
 desc 'Install gem'
 task :install => [:build] do
-  sh("#{Gem.ruby} -S gem install pkg/#{Gemgem.gem_tag}")
+  sh("#{Gem.ruby} -S gem install pkg/#{Gemgem.gem_tag}.gem")
 end
 
 desc 'Build gem'

data/test/sinatra/test_base.rb

@@ -0,0 +1,110 @@
+
+require 'jellyfish/test'
+
+# stolen from sinatra
+describe 'Sinatra base_test.rb' do
+  behaves_like :jellyfish
+
+  should 'process requests with #call' do
+    app = Class.new{
+      include Jellyfish
+      get '/' do
+        'Hello World'
+      end
+    }.new
+    app.respond_to?(:call).should.eq true
+    status, _, body = get('/', app)
+    status.should.eq 200
+    body  .should.eq ['Hello World']
+  end
+
+  should 'not maintain state between requests' do
+    app = Class.new{
+      include Jellyfish
+      get '/state' do
+        @foo ||= 'new'
+        body = "Foo: #{@foo}"
+        @foo = 'discard'
+        body
+      end
+    }.new
+
+    2.times do
+      status, _, body = get('/state', app)
+      status.should.eq 200
+      body  .should.eq ['Foo: new']
+    end
+  end
+
+  describe 'Jellyfish as a Rack middleware' do
+    behaves_like :jellyfish
+
+    def app
+      @app ||= Class.new{
+        include Jellyfish
+        get '/' do
+          'Hello from middleware'
+        end
+
+        get '/low-level-forward' do
+          status, headers, body = jellyfish.app.call(env)
+          self.status  status
+          self.headers headers
+          body
+        end
+
+        get '/explicit-forward' do
+          headers_merge 'X-Middleware' => 'true'
+          status, headers, _ = jellyfish.app.call(env)
+          self.status  status
+          self.headers headers
+          'Hello after explicit forward'
+        end
+      }.new(inner_app)
+    end
+
+    def inner_app
+      @inner_app ||= lambda{ |env|
+        [210, {'X-Downstream' => 'true'}, ['Hello from downstream']]
+      }
+    end
+
+    should 'create a middleware that responds to #call with .new' do
+      app.respond_to?(:call).should.eq true
+    end
+
+    should 'expose the downstream app' do
+      app.app.object_id.should.eq inner_app.object_id
+    end
+
+    should 'intercept requests' do
+      status, _, body = get('/')
+      status.should.eq 200
+      body  .should.eq ['Hello from middleware']
+    end
+
+    should 'forward requests downstream when no matching route found' do
+      status, headers, body = get('/missing')
+      status                 .should.eq 210
+      headers['X-Downstream'].should.eq 'true'
+      body                   .should.eq ['Hello from downstream']
+    end
+
+    should 'call the downstream app directly and return result' do
+      status, headers, body = get('/low-level-forward')
+      status                 .should.eq 210
+      headers['X-Downstream'].should.eq 'true'
+      body                   .should.eq ['Hello from downstream']
+    end
+
+    should 'forward the request and integrate the response' do
+      status, headers, body =
+        get('/explicit-forward', Rack::ContentLength.new(app))
+
+      status                   .should.eq 210
+      headers['X-Downstream']  .should.eq 'true'
+      headers['Content-Length'].should.eq '28'
+      body                     .should.eq ['Hello after explicit forward']
+    end
+  end
+end

data/test/sinatra/test_chunked_body.rb

@@ -0,0 +1,43 @@
+
+require 'jellyfish/test'
+
+# stolen from sinatra
+describe 'Sinatra streaming_test.rb' do
+  behaves_like :jellyfish
+
+  should 'return the concatinated body' do
+    app = Class.new{
+      include Jellyfish
+      get '/' do
+        Jellyfish::ChunkedBody.new{ |out|
+          out['Hello']
+          out[' ']
+          out['World!']
+        }
+      end
+    }.new
+    _, _, body = get('/', app)
+    body.to_a.join.should.eq 'Hello World!'
+  end
+
+  should 'postpone body generation' do
+    stream = Jellyfish::ChunkedBody.new{ |out|
+      10.times{ |i| out[i] }
+    }
+
+    stream.each.with_index do |s, i|
+      s.should.eq i
+    end
+  end
+
+  should 'give access to route specific params' do
+    app = Class.new{
+      include Jellyfish
+      get(%r{/(?<name>\w+)}){ |m|
+        Jellyfish::ChunkedBody.new{ |o| o[m[:name]] }
+      }
+    }.new
+    _, _, body = get('/foo', app)
+    body.to_a.join.should.eq 'foo'
+  end
+end

data/test/sinatra/test_error.rb

@@ -0,0 +1,145 @@
+
+require 'jellyfish/test'
+
+describe 'Sinatra mapped_error_test.rb' do
+  behaves_like :jellyfish
+
+  exp = Class.new(RuntimeError)
+
+  should 'invoke handlers registered with handle when raised' do
+    app = Class.new{
+      include Jellyfish
+      handle(exp){ 'Foo!' }
+      get '/' do
+        raise exp
+      end
+    }.new
+
+    status, _, body = get('/', app)
+    status.should.eq 200
+    body  .should.eq ['Foo!']
+  end
+
+  should 'pass the exception object to the error handler' do
+    app = Class.new{
+      include Jellyfish
+      handle(exp){ |e| e.should.kind_of?(exp) }
+      get('/'){ raise exp }
+    }.new
+    get('/', app)
+  end
+
+  should 'use the Exception handler if no matching handler found' do
+    app = Class.new{
+      include Jellyfish
+      handle(Exception){ 'Exception!' }
+      get('/'){ raise exp }
+    }.new
+
+    status, _, body = get('/', app)
+    status.should.eq 200
+    body  .should.eq ['Exception!']
+  end
+
+  should 'favour subclass handler over superclass handler if available' do
+    app = Class.new{
+      include Jellyfish
+      handle(Exception)   { 'Exception!'     }
+      handle(RuntimeError){ 'RuntimeError!'  }
+      get('/'){ raise exp }
+    }.new
+
+    status, _, body = get('/', app)
+    status.should.eq 200
+    body  .should.eq ['RuntimeError!']
+
+    handlers = app.class.handlers
+    handlers.size.should.eq 3
+    handlers[exp].should.eq handlers[RuntimeError]
+  end
+
+  should 'pass the exception to the handler' do
+    app = Class.new{
+      include Jellyfish
+      handle(exp){ |e|
+        e.should.kind_of?(exp)
+        'looks good'
+      }
+      get('/'){ raise exp }
+    }.new
+
+    _, _, body = get('/', app)
+    body.should.eq ['looks good']
+  end
+
+  should 'raise errors from the app when handle_exceptions is false' do
+    app = Class.new{
+      include Jellyfish
+      handle_exceptions false
+      get('/'){ raise exp }
+    }.new
+
+    lambda{ get('/', app) }.should.raise(exp)
+  end
+
+  should 'call error handlers even when handle_exceptions is false' do
+    app = Class.new{
+      include Jellyfish
+      handle_exceptions false
+      handle(exp){ "she's there." }
+      get('/'){ raise exp }
+    }.new
+
+    _, _, body = get('/', app)
+    body.should.eq ["she's there."]
+  end
+
+  should 'never raises Jellyfish::NotFound beyond the application' do
+    app = Class.new{
+      include Jellyfish
+      get('/'){ raise Jellyfish::NotFound }
+    }.new
+
+    status, _, _ = get('/', app)
+    status.should.eq 404
+  end
+
+  should 'cascade for subclasses of Jellyfish::NotFound' do
+    e   = Class.new(Jellyfish::NotFound)
+    app = Class.new{
+      include Jellyfish
+      get('/'){ raise e }
+    }.new
+
+    status, _, body = get('/', app)
+    status.should.eq 404
+  end
+
+  should 'inherit error mappings from base class' do
+    sup = Class.new{
+      include Jellyfish
+      handle(exp){ 'sup' }
+    }
+    app = Class.new(sup){
+      get('/'){ raise exp }
+    }.new
+
+    _, _, body = get('/', app)
+    body.should.eq ['sup']
+  end
+
+  should 'override error mappings in base class' do
+    sup = Class.new{
+      include Jellyfish
+      handle(exp){ 'sup' }
+    }
+    app = Class.new(sup){
+      handle(exp){ 'sub' }
+      get('/'){ raise exp }
+    }.new
+
+
+    _, _, body = get('/', app)
+    body.should.eq ['sub']
+  end
+end

data/test/sinatra/test_multi_actions.rb

@@ -0,0 +1,217 @@
+
+require 'jellyfish/test'
+
+# stolen from sinatra
+describe 'Sinatra filter_test.rb' do
+  behaves_like :jellyfish
+
+  def new_app base=Object, &block
+    Class.new(base){
+      include Jellyfish
+      controller_include(Jellyfish::MultiActions)
+      instance_eval(&block)
+    }.new
+  end
+
+  should 'executes filters in the order defined' do
+    count = 0
+    app = new_app{
+      get     { count.should.eq 0; count = 1 }
+      get     { count.should.eq 1; count = 2 }
+      get('/'){ 'Hello World' }
+    }
+
+    status, _, body = get('/', app)
+    status.should.eq 200
+    count .should.eq 2
+    body  .should.eq ['Hello World']
+  end
+
+  should 'modify env' do
+    app = new_app{
+      get{ env['BOO'] = 'MOO' }
+      get('/foo'){ env['BOO'] }
+    }
+
+    status, _, body = get('/foo', app)
+    status.should.eq 200
+    body  .should.eq ['MOO']
+  end
+
+  should 'modify instance variables available to routes' do
+    app = new_app{
+      get{ @foo = 'bar' }
+      get('/foo') { @foo }
+    }
+
+    status, _, body = get('/foo', app)
+    status.should.eq 200
+    body  .should.eq ['bar']
+  end
+
+  should 'allows redirects' do
+    app = new_app{
+      get{ found '/bar' }
+      get('/foo') do
+        fail 'before block should have halted processing'
+        'ORLY?!'
+      end
+    }
+
+    status, headers, body = get('/foo', app)
+    status             .should.eq 302
+    headers['Location'].should.eq '/bar'
+    body.join          .should =~ %r{<h1>Jellyfish found: /bar</h1>}
+  end
+
+  should 'not modify the response with its return value' do
+    app = new_app{
+      get{ 'Hello World!' }
+      get '/foo' do
+        body.should.eq nil
+        'cool'
+      end
+    }
+
+    status, _, body = get('/foo', app)
+    status.should.eq 200
+    body  .should.eq ['cool']
+  end
+
+  should 'modify the response with halt' do
+    app = new_app{
+      get('/foo'){ halt [302, {}, ['Hi']] }
+      get('/foo'){ 'should not happen' }
+      get('/bar'){ status 402; body 'Ho'; halt }
+      get('/bar'){ 'should not happen' }
+    }
+
+    get('/foo', app).should.eq [302, {}, ['Hi']]
+    get('/bar', app).should.eq [402, {}, ['Ho']]
+  end
+
+  should 'give you access to params' do
+    app = new_app{
+      get{ @foo = Rack::Request.new(env).params['foo'] }
+      get('/foo'){ @foo.reverse }
+    }
+
+    status, _, body = get('/foo', app, 'QUERY_STRING' => 'foo=cool')
+    status.should.eq 200
+    body  .should.eq ['looc']
+  end
+
+  should 'run filters defined in superclasses' do
+    sup = new_app{ get{ @foo = 'hello from superclass' } }.class
+    app = new_app(sup){ get('/foo'){ @foo } }
+
+    _, _, body = get('/foo', app)
+    body.should.eq ['hello from superclass']
+
+    sup      .routes['get'].size.should.eq 1
+    app.class.routes['get'].size.should.eq 2
+  end
+
+  should 'take an optional route pattern' do
+    ran_filter = false
+    app = new_app{
+      get(%r{^/b}){ ran_filter = true }
+      get('/foo') {}
+      get('/bar') {}
+    }
+    get('/foo', app)
+    ran_filter.should.eq false
+    get('/bar', app)
+    ran_filter.should.eq true
+  end
+
+  should 'generate block arguments from route pattern' do
+    subpath = nil
+    app = new_app{
+      get(%r{^/foo/(\w+)}){ |m| subpath = m[1] }
+    }
+    get('/foo/bar', app)
+    subpath.should.eq 'bar'
+  end
+
+  should 'execute before and after filters in correct order' do
+    invoked = 0
+    app = new_app{
+      get     { invoked  = 2 }
+      get('/'){ invoked += 2; body 'hello' }
+      get     { invoked *= 2 }
+    }
+
+    status, _, body = get('/', app)
+    status .should.eq 200
+    body   .should.eq ['hello']
+    invoked.should.eq 8
+  end
+
+  should 'execute filters in the order defined' do
+    count = 0
+    app = new_app{
+      get('/'){ body 'Hello World' }
+      get{
+        count.should.eq 0
+        count = 1
+      }
+      get{
+        count.should.eq 1
+        count = 2
+      }
+    }
+
+    status, _, body = get('/', app)
+    status.should.eq 200
+    count .should.eq 2
+    body  .should.eq ['Hello World']
+  end
+
+  should 'allow redirects' do
+    app = new_app{
+      get('/foo'){ 'ORLY' }
+      get        { found '/bar' }
+    }
+
+    status, headers, body = get('/foo', app)
+    status             .should.eq 302
+    headers['Location'].should.eq '/bar'
+    body.join          .should =~ %r{<h1>Jellyfish found: /bar</h1>}
+  end
+
+  should 'not modify the response with its return value' do
+    app = new_app{
+      get('/foo'){ body 'cool' }
+      get        { 'Hello World!' }
+    }
+
+    status, _, body = get('/foo', app)
+    status.should.eq 200
+    body  .should.eq ['cool']
+  end
+
+  should 'modify the response with halt' do
+    app = new_app{
+      get('/foo'){ 'should not be returned' }
+      get{ halt [302, {}, ['Hi']] }
+    }
+
+    status, _, body = get('/foo', app)
+    status.should.eq 302
+    body  .should.eq ['Hi']
+  end
+
+  should 'take an optional route pattern' do
+    ran_filter = false
+    app = new_app{
+      get('/foo') {}
+      get('/bar') {}
+      get(%r{^/b}){ ran_filter = true }
+    }
+    get('/foo', app)
+    ran_filter.should.eq false
+    get('/bar', app)
+    ran_filter.should.eq true
+  end
+end