jellyfish 0.6.0 → 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30753a754648b5b6d9a72d9165c763b3e4db9383
+  data.tar.gz: dc78ee33ce6341c19ff571bb78ab2485ef5f2fbd
+SHA512:
+  metadata.gz: aa1d7ff64073a23ffb0b8d4d218e5e2f3ec898c102ad2ee7786c2af062792be705b2941ca98f7fc3e59b095ec88945b3788b065eb22b48e00eae041be930843e
+  data.tar.gz: 1f33f9aa6f449b034e81c1fb33e30e91c91a580e1310230e487649606add2afeaddf13fa10ea9a9daac1dc878797a390d6211e7486315ff9ee19b34012acb225

data/.gitignore

@@ -1,3 +1,2 @@
 pkg
 *.rbc
-sinatra

data/.travis.yml

@@ -6,5 +6,6 @@ env:
 
 rvm:
   - 1.9.3
+  - 2.0.0
   - rbx-head
   - jruby-head

data/CHANGES.md

@@ -1,5 +1,76 @@
 # CHANGES
 
+## Jellyfish 0.8.0
+
+### Incompatible changes
+
+* Now there's no longer Jellyfish#controller but Jellyfish.controller,
+  as there's no much point for making the controller per-instance.
+  You do this to override the controller method instead:
+
+``` ruby
+class MyApp
+  include Jellyfish
+  def self.controller
+    MyController
+  end
+  class MyController < Jellyfish::Controller
+    def hi
+      'hi'
+    end
+  end
+  get{ hi }
+end
+```
+
+* You can also change the controller by assigning it. The same as above:
+
+``` ruby
+class MyApp
+  include Jellyfish
+  class MyController < Jellyfish::Controller
+    def hi
+      'hi'
+    end
+  end
+  controller MyController
+  get{ hi }
+end
+```
+
+### Enhancements for Jellyfish core
+
+* Introduced Jellyfish.controller_include which makes it easy to pick
+  modules to be included in built-in controller.
+* Introduced Controller#halt as a short hand for `throw :halt`
+* Now default route is `//`. Using `get{ 'Hello, World!' }` is effectively
+  the same as `get(//){ 'Hello, World!' }`
+* Now inheritance works.
+* Now it raises TypeError if passing a route doesn't respond to :match.
+* Now Jellyfish would find the most suitable error handler to handle
+  errors, i.e. It would find the error handler which would handle the
+  nearest exception class in the ancestors chain. Previously it would
+  only find the first one which matches, ignoring the rest. It would
+  also cache the result upon a lookup.
+
+### Enhancements for Jellyfish extension
+
+* Added `Jellyfish::ChunkedBody` which is similar to `Sinatra::Stream`.
+
+* Added `Jellyfish::MultiAction` which gives you some kind of ability to do
+  before or after filters. See README.md for usage.
+
+* Added `Jellyfish::NormalizedParams` which gives you some kind of Sinatra
+  flavoured params.
+
+* Added `Jellyfish::NormalizedPath` which would unescape incoming PATH_INFO
+  so you could match '/f%C3%B6%C3%B6' with '/föö'.
+
+### Enhancements for Jellyfish::Sinatra
+
+* Now `Jellyfish::Sinatra` includes `Jellyfish::MultiAction`,
+  `Jellyfish::NormalizedParams`, and `Jellyfish::NormalizedPath`.
+
 ## Jellyfish 0.6.0 -- 2012-11-02
 
 ### Enhancements for Jellyfish core

data/README.md

@@ -13,7 +13,7 @@ by Lin Jen-Shin ([godfat](http://godfat.org))
 ## DESCRIPTION:
 
 Pico web framework for building API-centric web applications.
-For Rack applications or Rack middlewares. Under 200 lines of code.
+For Rack applications or Rack middlewares. Around 200 lines of code.
 
 ## DESIGN:
 
@@ -23,18 +23,21 @@ For Rack applications or Rack middlewares. Under 200 lines of code.
 * Embrace simplicity over convenience
 * Don't make things complicated only for _some_ convenience, but
   _great_ convenience, or simply stay simple for simplicity.
+* More features are added as extensions
 
 ## FEATURES:
 
 * Minimal
 * Simple
-* No templates
+* Modular
+* No templates (You could use [tilt](https://github.com/rtomayko/tilt))
 * No ORM
 * No `dup` in `call`
 * Regular expression routes, e.g. `get %r{^/(?<id>\d+)$}`
 * String routes, e.g. `get '/'`
 * Custom routes, e.g. `get Matcher.new`
-* Build for either Rack applications or Rack middlewares
+* Build for either Rack applications or Rack middleware
+* Include extensions for more features (There's a Sinatra extension)
 
 ## WHY?
 
@@ -65,6 +68,13 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
+<!---
+GET /
+[200,
+ {'Content-Length' => '12', 'Content-Type' => 'text/plain'},
+ ["Jelly Kelly\n"]]
+-->
+
 ### Regular expression routes
 
 ``` ruby
@@ -80,6 +90,13 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
+<!---
+GET /123
+[200,
+ {'Content-Length' => '11', 'Content-Type' => 'text/plain'},
+ ["Jelly #123\n"]]
+-->
+
 ### Custom matcher routes
 
 ``` ruby
@@ -100,6 +117,13 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
+<!---
+GET /hctam
+[200,
+ {'Content-Length' => '5', 'Content-Type' => 'text/plain'},
+ ["true\n"]]
+-->
+
 ### Different HTTP status and custom headers
 
 ``` ruby
@@ -119,6 +143,14 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
+<!---
+POST /
+[201,
+ {'Content-Length' => '18', 'Content-Type' => 'text/plain',
+  'X-Jellyfish-Life' => '100', 'X-Jellyfish-Mana' => '200'},
+ ["Jellyfish 100/200\n"]]
+-->
+
 ### Redirect helper
 
 ``` ruby
@@ -134,6 +166,17 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
+<!---
+GET /lookup
+body = File.read("#{File.dirname(
+  File.expand_path(__FILE__))}/../lib/jellyfish/public/302.html").
+  gsub('VAR_URL', ':///')
+[302,
+ {'Content-Length' => body.bytesize.to_s, 'Content-Type' => 'text/html',
+  'Location' => ':///'},
+ [body]]
+-->
+
 ### Crash-proof
 
 ``` ruby
@@ -149,6 +192,15 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
+<!---
+GET /crash
+body = File.read("#{File.dirname(
+  File.expand_path(__FILE__))}/../lib/jellyfish/public/500.html")
+[500,
+ {'Content-Length' => body.bytesize.to_s, 'Content-Type' => 'text/html'},
+ [body]]
+-->
+
 ### Custom error handler
 
 ``` ruby
@@ -168,7 +220,74 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
-### Custom controller
+<!---
+GET /yell
+body = case RUBY_ENGINE
+       when 'jruby'
+         "No one hears you: (eval):9:in `Tank'\n"
+       when 'rbx'
+         "No one hears you: kernel/delta/kernel.rb:81:in `yell (method_missing)'\n"
+       else
+         "No one hears you: (eval):9:in `block in <class:Tank>'\n"
+       end
+[403,
+ {'Content-Length' => body.bytesize.to_s, 'Content-Type' => 'text/plain'},
+ [body]]
+-->
+
+### Access Rack::Request and params
+
+``` ruby
+require 'jellyfish'
+class Tank
+  include Jellyfish
+  get '/report' do
+    "Your name is #{request.params['name']}\n"
+  end
+end
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /report?name=godfat
+[200,
+ {'Content-Length' => '20', 'Content-Type' => 'text/plain'},
+ ["Your name is godfat\n"]]
+-->
+
+### Re-dispatch the request with modified env
+
+``` ruby
+require 'jellyfish'
+class Tank
+  include Jellyfish
+  get '/report' do
+    status, headers, body = jellyfish.call(env.merge('PATH_INFO' => '/info'))
+    self.status  status
+    self.headers headers
+    self.body    body
+  end
+  get('/info'){ "OK\n" }
+end
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /report
+[200,
+ {'Content-Length' => '3', 'Content-Type' => 'text/plain'},
+ ["OK\n"]]
+-->
+
+### Include custom helper in built-in controller
+
+Basically it's the same as defining a custom controller and then
+include the helper. This is merely a short hand. See next section
+for defining a custom controller.
 
 ``` ruby
 require 'jellyfish'
@@ -178,33 +297,92 @@ class Heater
     temperature
   end
 
-  def controller; Controller; end
-  class Controller < Jellyfish::Controller
+  module Helper
     def temperature
       "30\u{2103}\n"
     end
   end
+  controller_include Helper
 end
 use Rack::ContentLength
 use Rack::ContentType, 'text/plain'
 run Heater.new
 ```
 
-### Sinatra flavored controller
+<!---
+GET /status
+[200,
+ {'Content-Length' => '6', 'Content-Type' => 'text/plain'},
+ ["30\u{2103}\n"]]
+-->
+
+### Define custom controller manually
+
+This is effectively the same as defining a helper module as above and
+include it, but more flexible and extensible.
+
+``` ruby
+require 'jellyfish'
+class Heater
+  include Jellyfish
+  get '/status' do
+    temperature
+  end
+
+  class Controller < Jellyfish::Controller
+    def temperature
+      "30\u{2103}\n"
+    end
+  end
+  controller Controller
+end
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Heater.new
+```
 
-Currently support:
+<!---
+GET /status
+[200,
+ {'Content-Length' => '6', 'Content-Type' => 'text/plain'},
+ ["30\u{2103}\n"]]
+-->
 
-* Indifferent params
-* Force params encoding to Encoding.default_external
+### Extension: MultiActions (Filters)
 
 ``` ruby
 require 'jellyfish'
 class Tank
   include Jellyfish
-  class MyController < Jellyfish::Controller
-    include Jellyfish::Sinatra
+  controller_include Jellyfish::MultiActions
+
+  get do # wildcard before filter
+    @state = 'jumps'
   end
-  def controller; MyController; end
+  get do
+    "Jelly #{@state}.\n"
+  end
+end
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /123
+[200,
+ {'Content-Length' => '13', 'Content-Type' => 'text/plain'},
+ ["Jelly jumps.\n"]]
+-->
+
+### Extension: NormalizedParams (with force_encoding)
+
+``` ruby
+require 'jellyfish'
+class Tank
+  include Jellyfish
+  controller_include Jellyfish::NormalizedParams
+
   get %r{^/(?<id>\d+)$} do
     "Jelly ##{params[:id]}\n"
   end
@@ -214,16 +392,78 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
-### Using NewRelic?
+<!---
+GET /123
+[200,
+ {'Content-Length' => '11', 'Content-Type' => 'text/plain'},
+ ["Jelly #123\n"]]
+-->
+
+### Extension: NormalizedPath (with unescaping)
 
 ``` ruby
 require 'jellyfish'
 class Tank
   include Jellyfish
-  class MyController < Jellyfish::Controller
-    include Jellyfish::NewRelic
+  controller_include Jellyfish::NormalizedPath
+
+  get "/\u{56e7}" do
+    "#{env['PATH_INFO']}=#{path_info}\n"
+  end
+end
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /%E5%9B%A7
+[200,
+ {'Content-Length' => '16', 'Content-Type' => 'text/plain'},
+ ["/%E5%9B%A7=/\u{56e7}\n"]]
+-->
+
+### Extension: Sinatra flavoured controller
+
+It's an extension collection contains:
+
+* MultiActions
+* NormalizedParams
+* NormalizedPath
+
+``` ruby
+require 'jellyfish'
+class Tank
+  include Jellyfish
+  controller_include Jellyfish::Sinatra
+
+  get do # wildcard before filter
+    @state = 'jumps'
+  end
+  get %r{^/(?<id>\d+)$} do
+    "Jelly ##{params[:id]} #{@state}.\n"
   end
-  def controller; MyController; end
+end
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /123
+[200,
+ {'Content-Length' => '18', 'Content-Type' => 'text/plain'},
+ ["Jelly #123 jumps.\n"]]
+-->
+
+### Extension: NewRelic
+
+``` ruby
+require 'jellyfish'
+class Tank
+  include Jellyfish
+  controller_include Jellyfish::NewRelic
+
   get '/' do
     "OK\n"
   end
@@ -237,6 +477,48 @@ run Tank.new
 NewRelic::Agent.manual_start(:developer_mode => true)
 ```
 
+<!---
+GET /
+[200,
+ {'Content-Length' => '3', 'Content-Type' => 'text/plain'},
+ ["OK\n"]]
+-->
+
+### Extension: Using multiple extensions with custom controller
+
+This is effectively the same as using Jellyfish::Sinatra extension.
+Note that the controller should be assigned lastly in order to include
+modules remembered in controller_include.
+
+``` ruby
+require 'jellyfish'
+class Tank
+  include Jellyfish
+  class MyController < Jellyfish::Controller
+    include Jellyfish::MultiActions
+  end
+  controller_include NormalizedParams, NormalizedPath
+  controller MyController
+
+  get do # wildcard before filter
+    @state = 'jumps'
+  end
+  get %r{^/(?<id>\d+)$} do
+    "Jelly ##{params[:id]} #{@state}.\n"
+  end
+end
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /123
+[200,
+ {'Content-Length' => '18', 'Content-Type' => 'text/plain'},
+ ["Jelly #123 jumps.\n"]]
+-->
+
 ### Jellyfish as a middleware
 
 ``` ruby
@@ -261,6 +543,146 @@ use Heater
 run Tank.new
 ```
 
+<!---
+GET /
+[200,
+ {'Content-Length' => '12', 'Content-Type' => 'text/plain'},
+ ["Jelly Kelly\n"]]
+-->
+
+### Modify response as a middleware
+
+``` ruby
+require 'jellyfish'
+class Heater
+  include Jellyfish
+  get '/status' do
+    status, headers, body = jellyfish.app.call(env)
+    self.status  status
+    self.headers headers
+    self.body    body
+    headers_merge('X-Temperature' => "30\u{2103}")
+  end
+end
+
+class Tank
+  include Jellyfish
+  get '/status' do
+    "See header X-Temperature\n"
+  end
+end
+
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+use Heater
+run Tank.new
+```
+
+<!---
+GET /status
+[200,
+ {'Content-Length' => '25', 'Content-Type' => 'text/plain',
+  'X-Temperature'  => "30\u{2103}"},
+ ["See header X-Temperature\n"]]
+-->
+
+### Default headers as a middleware
+
+``` ruby
+require 'jellyfish'
+class Heater
+  include Jellyfish
+  get '/status' do
+    status, headers, body = jellyfish.app.call(env)
+    self.status  status
+    self.headers({'X-Temperature' => "30\u{2103}"}.merge(headers))
+    self.body    body
+  end
+end
+
+class Tank
+  include Jellyfish
+  get '/status' do
+    headers_merge('X-Temperature' => "35\u{2103}")
+    "\n"
+  end
+end
+
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+use Heater
+run Tank.new
+```
+
+<!---
+GET /status
+[200,
+ {'Content-Length' => '1', 'Content-Type' => 'text/plain',
+  'X-Temperature'  => "35\u{2103}"},
+ ["\n"]]
+-->
+
+### Simple before action as a middleware
+
+``` ruby
+require 'jellyfish'
+class Heater
+  include Jellyfish
+  get '/status' do
+    env['temperature'] = 30
+    forward
+  end
+end
+
+class Tank
+  include Jellyfish
+  get '/status' do
+    "#{env['temperature']}\u{2103}\n"
+  end
+end
+
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+use Heater
+run Tank.new
+```
+
+<!---
+GET /status
+[200,
+ {'Content-Length' => '6', 'Content-Type' => 'text/plain'},
+ ["30\u{2103}\n"]]
+-->
+
+### Halt in before action
+
+``` ruby
+require 'jellyfish'
+class Tank
+  include Jellyfish
+  controller_include Jellyfish::MultiActions
+
+  get do # wildcard before filter
+    body "Done!\n"
+    halt
+  end
+  get '/' do
+    "Never reach.\n"
+  end
+end
+
+use Rack::ContentLength
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /status
+[200,
+ {'Content-Length' => '6', 'Content-Type' => 'text/plain'},
+ ["Done!\n"]]
+-->
+
 ### One huge tank
 
 ``` ruby
@@ -289,6 +711,13 @@ end
 run HugeTank
 ```
 
+<!---
+GET /status
+[200,
+ {'Content-Length' => '6', 'Content-Type' => 'text/plain'},
+ ["30\u{2103}\n"]]
+-->
+
 ### Raise exceptions
 
 ``` ruby
@@ -315,17 +744,48 @@ use Protector
 run Tank.new
 ```
 
-### Chunked transfer encoding (streaming)
+<!---
+GET /
+[200,
+ {'Content-Length' => '29', 'Content-Type' => 'text/plain'},
+ ["Protected: Oops, tank broken\n"]]
+-->
+
+### Chunked transfer encoding (streaming) with Jellyfish::ChunkedBody
 
 You would need a proper server setup.
 Here's an example with Rainbows and fibers:
 
+``` ruby
+class Tank
+  include Jellyfish
+  get '/chunked' do
+    ChunkedBody.new{ |out|
+      (0..4).each{ |i| out.call("#{i}\n") }
+    }
+  end
+end
+use Rack::Chunked
+use Rack::ContentType, 'text/plain'
+run Tank.new
+```
+
+<!---
+GET /chunked
+[200,
+ {'Content-Type' => 'text/plain', 'Transfer-Encoding' => 'chunked'},
+ ["2\r\n0\n\r\n", "2\r\n1\n\r\n", "2\r\n2\n\r\n",
+  "2\r\n3\n\r\n", "2\r\n4\n\r\n", "0\r\n\r\n"]]
+-->
+
+### Chunked transfer encoding (streaming) with custom body
+
 ``` ruby
 class Tank
   include Jellyfish
   class Body
     def each
-      (0..4).each{ |i| yield "#{i}\n"; Rainbows.sleep(0.1) }
+      (0..4).each{ |i| yield "#{i}\n" }
     end
   end
   get '/chunked' do
@@ -337,6 +797,14 @@ use Rack::ContentType, 'text/plain'
 run Tank.new
 ```
 
+<!---
+GET /chunked
+[200,
+ {'Content-Type' => 'text/plain', 'Transfer-Encoding' => 'chunked'},
+ ["2\r\n0\n\r\n", "2\r\n1\n\r\n", "2\r\n2\n\r\n",
+  "2\r\n3\n\r\n", "2\r\n4\n\r\n", "0\r\n\r\n"]]
+-->
+
 ## CONTRIBUTORS:
 
 * Lin Jen-Shin (@godfat)
@@ -345,7 +813,7 @@ run Tank.new
 
 Apache License 2.0
 
-Copyright (c) 2012, Lin Jen-Shin (godfat)
+Copyright (c) 2012-2013, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.