jellyfish 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed0f1e851242bf9537578f804560b70c4941fd99
-  data.tar.gz: 0d90b769bdb5fba1328d8734b5f6ac307578136c
+  metadata.gz: f177b766380820557e01f05b9da4efacc4895984
+  data.tar.gz: 800a25a7fa325e5c0c40c7604b94cbddb32c43a6
 SHA512:
-  metadata.gz: a2168d6a1fd9beeb8486065288be32d59347d2e52d5e503efa5898e5ed6666603e8061d16fe269e25aaa831a59054e40bbcfe11adcb64dd7f24fc9201bc0b14d
-  data.tar.gz: d74afc9d0425f7f88b193259785f81da48e990f4dbf2359fafd334cc99926e79384aa41b008e37546520bb48cf95d0b6315d034c87bbb25848583605fbca8ceb
+  metadata.gz: 288710b695398769a27f730e3a2d2d6fe921b140455a968f57515503628af9f7759506c89c9291b860e862b1eb6ca56d076b9ca01c2429d53626bc021d189904
+  data.tar.gz: 78edee35fbbac6dd332fc9eb9290b1dc26c27b74abd72c57166bb0d429ac6f3d441c3c88f56f014befdeb32825a47bf6d395dae04e21c624b6c52caa986aa589

data/.travis.yml

@@ -3,6 +3,7 @@ language: ruby
 rvm:
   - 2.0
   - 2.1
+  - 2.2
   - rbx-2
   - jruby
 

data/CHANGES.md

@@ -1,5 +1,19 @@
 # CHANGES
 
+## Jellyfish 1.1.0 -- 2015-09-25
+
+### Incompatible changes
+
+* `Jellyfish::Sinatra`, `Jellyfish::MultiActions`, and `Jellyfish::Swagger`
+  were extracted to
+  [jellyfish-contrib](https://github.com/godfat/jellyfish-contrib)
+
+### Other enhancements
+
+* Added `Jellyfish::Builder` and `Jellyfish::URLMap` which is 36 times faster
+  than `Rack::Builder` and `Rack::URLMap` given an application with
+  1000 routes.
+
 ## Jellyfish 1.0.2 -- 2014-12-09
 
 * `Jellyfish::NewRelic` is fixed. Thanks Jason R. Clark (@jasonrclark)

data/README.md

@@ -1,4 +1,4 @@
-# Jellyfish [![Build Status](https://secure.travis-ci.org/godfat/jellyfish.png?branch=master)](http://travis-ci.org/godfat/jellyfish) [![Coverage Status](https://coveralls.io/repos/godfat/jellyfish/badge.png)](https://coveralls.io/r/godfat/jellyfish)
+# Jellyfish [![Build Status](https://secure.travis-ci.org/godfat/jellyfish.png?branch=master)](http://travis-ci.org/godfat/jellyfish) [![Coverage Status](https://coveralls.io/repos/godfat/jellyfish/badge.png)](https://coveralls.io/r/godfat/jellyfish) [![Join the chat at https://gitter.im/godfat/jellyfish](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/godfat/jellyfish)
 
 by Lin Jen-Shin ([godfat](http://godfat.org))
 
@@ -13,7 +13,11 @@ by Lin Jen-Shin ([godfat](http://godfat.org))
 ## DESCRIPTION:
 
 Pico web framework for building API-centric web applications.
-For Rack applications or Rack middlewares. Around 250 lines of code.
+For Rack applications or Rack middleware. Around 250 lines of code.
+
+Check [jellyfish-contrib][] for extra extensions.
+
+[jellyfish-contrib]: https://github.com/godfat/jellyfish-contrib
 
 ## DESIGN:
 
@@ -43,7 +47,7 @@ For Rack applications or Rack middlewares. Around 250 lines of code.
 * String routes, e.g. `get '/'`
 * Custom routes, e.g. `get Matcher.new`
 * Build for either Rack applications or Rack middleware
-* Include extensions for more features (There's a Sinatra extension)
+* Include extensions for more features (checkout [jellyfish-contrib][])
 
 ## WHY?
 
@@ -59,9 +63,7 @@ Because Sinatra is too complex and inconsistent for me.
 
 ## SYNOPSIS:
 
-You could also take a look at [config.ru](config.ru) as an example, which
-also uses [Swagger](https://helloreverb.com/developers/swagger) to generate
-API documentation.
+You could also take a look at [config.ru](config.ru) as an example.
 
 ### Hello Jellyfish, your lovely config.ru
 
@@ -439,33 +441,148 @@ GET /123
  ["Jelly jumps.\n"]]
 -->
 
-### Extension: MultiActions (Filters)
+### Extension: Jellyfish::Builder, a faster Rack::Builder and Rack::URLMap
+
+Default `Rack::Builder` and `Rack::URLMap` is routing via linear search,
+which could be very slow with a large number of routes. We could use
+`Jellyfish::Builder` in this case because it would compile the routes
+into a regular expression, it would be matching much faster than
+linear search.
+
+Note that `Jellyfish::Builder` is not a complete compatible implementation.
+The followings are intentional:
+
+* There's no `Jellyfish::Builder.call` because it doesn't make sense in my
+  opinion. Always use `Jellyfish::Builder.app` instead.
+
+* There's no `Jellyfish::Builder.parse_file` and
+  `Jellyfish::Builder.new_from_string` because Rack servers are not
+  going to use `Jellyfish::Builder` to parse `config.ru` at this point.
+  We could provide this if there's a need.
+
+* `Jellyfish::URLMap` does not modify `env`, and it would call the app with
+  another instance of Hash. Mutating data is a bad idea.
+
+* `Jellyfish::URLMap` does not try to match on host because I am not sure
+  if there's anyone would need this feature?
+
+* All other tests passed the same test suites for `Rack::Builder`.
 
 ``` ruby
 require 'jellyfish'
-class Tank
-  include Jellyfish
-  controller_include Jellyfish::MultiActions
 
-  get do # wildcard before filter
-    @state = 'jumps'
+run Jellyfish::Builder.app{
+  map '/a'   do; run lambda{ |_| [200, {}, ["a\n"]  ] }; end
+  map '/b'   do; run lambda{ |_| [200, {}, ["b\n"]  ] }; end
+  map '/c'   do; run lambda{ |_| [200, {}, ["c\n"]  ] }; end
+  map '/d'   do; run lambda{ |_| [200, {}, ["d\n"]  ] }; end
+  map '/e' do
+    map '/f' do; run lambda{ |_| [200, {}, ["e/f\n"]] }; end
+    map '/g' do; run lambda{ |_| [200, {}, ["e/g\n"]] }; end
+    map '/h' do; run lambda{ |_| [200, {}, ["e/h\n"]] }; end
+    map '/i' do; run lambda{ |_| [200, {}, ["e/i\n"]] }; end
+    map '/'  do; run lambda{ |_| [200, {}, ["e\n"]]   }; end
   end
-  get do
-    "Jelly #{@state}.\n"
+  map '/j'   do; run lambda{ |_| [200, {}, ["j\n"]  ] }; end
+  map '/k'   do; run lambda{ |_| [200, {}, ["k\n"]  ] }; end
+  map '/l'   do; run lambda{ |_| [200, {}, ["l\n"]  ] }; end
+  map '/m' do
+    map '/g' do; run lambda{ |_| [200, {}, ["m/g\n"]] }; end
+    run lambda{ |_| [200, {}, ["m\n"]  ] }
   end
-end
-use Rack::ContentLength
-use Rack::ContentType, 'text/plain'
-run Tank.new
+
+  use Rack::ContentLength
+  run lambda{ |_| [200, {}, ["/\n"]] }
+}
 ```
 
 <!---
-GET /123
-[200,
- {'Content-Length' => '13', 'Content-Type' => 'text/plain'},
- ["Jelly jumps.\n"]]
+GET /a
+[200, {}, ["a\n"]]
+
+GET /a/x
+[200, {}, ["a\n"]]
+
+GET /b
+[200, {}, ["b\n"]]
+
+GET /c
+[200, {}, ["c\n"]]
+
+GET /d
+[200, {}, ["d\n"]]
+
+GET /e/f
+[200, {}, ["e/f\n"]]
+
+GET /e/g
+[200, {}, ["e/g\n"]]
+
+GET /e/h
+[200, {}, ["e/h\n"]]
+
+GET /e/i
+[200, {}, ["e/i\n"]]
+
+GET /e/
+[200, {}, ["e\n"]]
+
+GET /e
+[200, {}, ["e\n"]]
+
+GET /e/x
+[200, {}, ["e\n"]]
+
+GET /j
+[200, {}, ["j\n"]]
+
+GET /k
+[200, {}, ["k\n"]]
+
+GET /l
+[200, {}, ["l\n"]]
+
+GET /m/g
+[200, {}, ["m/g\n"]]
+
+GET /m
+[200, {}, ["m\n"]]
+
+GET /m/
+[200, {}, ["m\n"]]
+
+GET /m/x
+[200, {}, ["m\n"]]
+
+GET /
+[200, {'Content-Length' => '2'}, ["/\n"]]
+
+GET /x
+[200, {'Content-Length' => '2'}, ["/\n"]]
+
+GET /ab
+[200, {'Content-Length' => '2'}, ["/\n"]]
 -->
 
+You could try a stupid benchmark yourself:
+
+    ruby -Ilib bench/bench_builder.rb
+
+For a 1000 routes app, here's my result:
+
+```
+Calculating -------------------------------------
+   Jellyfish::URLMap     5.726k i/100ms
+        Rack::URLMap   167.000  i/100ms
+-------------------------------------------------
+   Jellyfish::URLMap     62.397k (± 1.2%) i/s -    314.930k
+        Rack::URLMap      1.702k (± 1.5%) i/s -      8.517k
+
+Comparison:
+   Jellyfish::URLMap:    62397.3 i/s
+        Rack::URLMap:     1702.0 i/s - 36.66x slower
+```
+
 ### Extension: NormalizedParams (with force_encoding)
 
 ``` ruby
@@ -514,39 +631,6 @@ GET /%E5%9B%A7
  ["/%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
-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
@@ -577,7 +661,6 @@ GET /
 
 ### 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.
 
@@ -586,16 +669,13 @@ require 'jellyfish'
 class Tank
   include Jellyfish
   class MyController < Jellyfish::Controller
-    include Jellyfish::MultiActions
+    include Jellyfish::WebSocket
   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"
+    "Jelly ##{params[:id]} jumps.\n"
   end
 end
 use Rack::ContentLength
@@ -761,35 +841,6 @@ GET /status
  ["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
@@ -912,6 +963,57 @@ GET /chunked
   "2\r\n3\n\r\n", "2\r\n4\n\r\n", "0\r\n\r\n"]]
 -->
 
+### Server Sent Event (SSE)
+
+``` ruby
+class Tank
+  include Jellyfish
+  class Body
+    def each
+      (0..4).each{ |i| yield "data: #{i}\n\n" }
+    end
+  end
+  get '/sse' do
+    headers_merge('Content-Type' => 'text/event-stream')
+    Body.new
+  end
+end
+run Tank.new
+```
+
+<!---
+GET /sse
+[200,
+ {'Content-Type' => 'text/event-stream'},
+ ["data: 0\n\n", "data: 1\n\n", "data: 2\n\n", "data: 3\n\n", "data: 4\n\n"]]
+-->
+
+### Server Sent Event (SSE) with Rack Hijacking
+
+``` ruby
+class Tank
+  include Jellyfish
+  get '/sse' do
+    headers_merge(
+      'Content-Type' => 'text/event-stream',
+      'rack.hijack'  => lambda do |sock|
+        (0..4).each do |i|
+          sock.write("data: #{i}\n\n")
+        end
+        sock.close
+      end)
+  end
+end
+run Tank.new
+```
+
+<!---
+GET /sse
+[200,
+ {'Content-Type' => 'text/event-stream'},
+ ["data: 0\n\n", "data: 1\n\n", "data: 2\n\n", "data: 3\n\n", "data: 4\n\n"]]
+-->
+
 ### Using WebSocket
 
 Note that this only works for Rack servers which support [hijack][].
@@ -956,36 +1058,9 @@ HTTP
 [200, {}, ['']]
 -->
 
-### Use Swagger to generate API documentation
-
-For a complete example, checkout [config.ru](config.ru).
-
-``` ruby
-require 'jellyfish'
-class Tank
-  include Jellyfish
-  get %r{^/(?<id>\d+)$}, :notes => 'This is an API note' do |match|
-    "Jelly ##{match[:id]}\n"
-  end
-end
-use Rack::ContentLength
-use Rack::ContentType, 'text/plain'
-map '/swagger' do
-  run Jellyfish::Swagger.new('', Tank)
-end
-run Tank.new
-```
-
-<!---
-GET /swagger
-[200,
- {'Content-Type'   => 'application/json; charset=utf-8',
-  'Content-Length' => '81'},
- ['{"swaggerVersion":"1.2","info":{},"apiVersion":"0.1.0","apis":[{"path":"/{id}"}]}']]
--->
-
 ## CONTRIBUTORS:
 
+* Fumin (@fumin)
 * Jason R. Clark (@jasonrclark)
 * Lin Jen-Shin (@godfat)
 
@@ -993,7 +1068,7 @@ GET /swagger
 
 Apache License 2.0
 
-Copyright (c) 2012-2014, Lin Jen-Shin (godfat)
+Copyright (c) 2012-2015, 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.

data/bench/bench_builder.rb

@@ -0,0 +1,44 @@
+
+# Calculating -------------------------------------
+#    Jellyfish::URLMap     5.726k i/100ms
+#         Rack::URLMap   167.000  i/100ms
+# -------------------------------------------------
+#    Jellyfish::URLMap     62.397k (± 1.2%) i/s -    314.930k
+#         Rack::URLMap      1.702k (± 1.5%) i/s -      8.517k
+
+# Comparison:
+#    Jellyfish::URLMap:    62397.3 i/s
+#         Rack::URLMap:     1702.0 i/s - 36.66x slower
+
+require 'jellyfish'
+require 'rack'
+
+require 'benchmark/ips'
+
+num = 1000
+app = lambda do |_|
+  ok = [200, {}, []]
+  rn = lambda{ |_| ok }
+
+  (0...num).each do |i|
+    map "/#{i}" do
+      run rn
+    end
+  end
+end
+
+jelly = Jellyfish::Builder.app(&app)
+rack  = Rack::Builder.app(&app)
+path_info = 'PATH_INFO'
+
+Benchmark.ips do |x|
+  x.report(jelly.class) do
+    jelly.call(path_info => rand(num).to_s)
+  end
+
+  x.report(rack.class) do
+    rack.call(path_info => rand(num).to_s)
+  end
+
+  x.compare!
+end