nyny 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa8bdccd5f35a66eaa05e512117950e230350185
-  data.tar.gz: 9932d345a2b696477bb9eef615671ce9db598de1
+  metadata.gz: bd3b0074fdefc837e7c08f4c760b894165bf2755
+  data.tar.gz: 4e7162b95bfbc2350f6f4cdccf36597ecf19ac8b
 SHA512:
-  metadata.gz: 941652c537350c79204235b9d62af1dd7a55f0e2074a4c75043fad5f793c5ec87c1f85f6d02ec28d7df3286ac56270b1f2d7aaef07f272d5480ae6f13db3ea27
-  data.tar.gz: a4a63feaf107bc95a0981f7b087c2a1e03d918bcf63fc1fbe23d3bf3e059a39b3124f3f8c5582fc03563deb4ca3866e3542f1803d6ca58186e03a36954aafb6f
+  metadata.gz: c3dc84c5a09a7dbb15ea47c52e55ff9679a473ad1241872fa81c44582ba0b3efe339f1cc1700a3dd29416191f221f58f2c926a0254cff08367dfcd50d5b59a8b
+  data.tar.gz: 963aac17eefd5aa6d1b67fdacddba1fb4bd0e91c14a104739921701307792968f8a4d5011f568ba12a900598e30e8386286babb6c468232c01cf1a3a84be6426

data/CHANGELOG

@@ -1,9 +1,24 @@
+2.1.0
+  - Add ability to define helpers with a block
+  - Remove benchmark folder, and create a single benchmark file which can be
+    executed easily
+  - Simplified and optimized routing logic
+  - Fixed root path processing when a NYNY app is mounted
+  - Added Rails interop example
+  - Added session example
+  - Added NYNY.root
+  - Added NYNY.env
+  - NYNY will not show exceptions in production env
+
 2.0.0
   - Simplified and improved RouteSignature implementation
   - Simplified and improved RequestScope implementation
   - Made response object available in RequestScope
-  - removed .use_protection! (the rack-protection) middleware can be easily
-    used manually
-  - add .register, which registers an extension (works the same way as in sinatra)
+  - removed .use_protection! (the rack-protection middleware can be easily
+    used manually)
+  - added support for extensions (using .register, which works the same way as in sinatra)
+
+1.0.2
+  - Add rack to runtime deps (@etehtsea)
 
 1.0.0 Initial release

data/Performance.md

@@ -1,73 +1,44 @@
-# NYNY vs Sinatra performance test
+This output was generated by running benchmark.rb in repo root
 
-Note: all the tests below were made using Thin as a webserver. Httperf was
-choosen as the tool to do that. Bench settings: `--num-conns 10000`
+Comparing NYNY 2.1.0 with Sinatra 1.4.3
 
-Hardware: Intel(R) Core(TM) i7-2620M CPU @ 2.70GHz, 6 GB DDR3
-
-If you have a clue how to make proper benchmarks (because, frankly, I don't), I am open to suggestions.
-
-## Results
-
-| Benchmark | NYNY (req/s) | Sinatra (req/s) |
-|-----------|:---------------:|:---------------:|
-| Simple    |__5012__         |2534             |
-| UrlPattern|__4564__         |2338             |
-| Filters   |__4510__         |2465             |
-| Helpers   |__4737__         |2663             |
-
-See below the code for each benchmark
-
-## Code
-### Simple
-```ruby
-class App < NYNY::App #(or Sinatra::Base)
-  get '/' do
-    'Hello World!'
-  end
-end
+Test: empty
 ```
-
-### UrlPattern
-```ruby
-class App < NYNY::App #(or Sinatra::Base)
-  get '/hello/:name' do
-    "Hello #{params[:name]}!"
-  end
-end
+              user     system      total        real
+nyny:     0.060000   0.010000   0.070000 (  0.063841)
+sinatra:  0.380000   0.000000   0.380000 (  0.392611)
 ```
+NYNY is **6.15x** faster than Sinatra in this test
 
-### Filters
-```ruby
-class App < NYNY::App #(or Sinatra::Base)
-  before do
-    request
-  end
-
-  after do
-    response
-  end
-
-  get '/' do
-    'Hello World!'
-  end
-end
+Test: hello world
 ```
+              user     system      total        real
+nyny:     0.100000   0.000000   0.100000 (  0.099356)
+sinatra:  0.250000   0.010000   0.260000 (  0.253724)
+```
+NYNY is **2.55x** faster than Sinatra in this test
 
-### Helpers
-```ruby
-module Dude
-  def da_request_man
-    request
-  end
-end
+Test: filters
+```
+              user     system      total        real
+nyny:     0.090000   0.000000   0.090000 (  0.097938)
+sinatra:  0.260000   0.000000   0.260000 (  0.259718)
+```
+NYNY is **2.65x** faster than Sinatra in this test
 
-class App < NYNY::App #(or Sinatra::Base)
-  helpers Dude
+Test: helpers
+```
+              user     system      total        real
+nyny:     0.090000   0.000000   0.090000 (  0.090412)
+sinatra:  0.240000   0.010000   0.250000 (  0.239332)
+```
+NYNY is **2.65x** faster than Sinatra in this test
 
-  get '/' do
-    da_request_man
-    'Hello World!'
-  end
-end
+Test: Url patterns
+```
+              user     system      total        real
+nyny:     0.100000   0.000000   0.100000 (  0.104926)
+sinatra:  0.260000   0.000000   0.260000 (  0.268531)
 ```
+NYNY is **2.56x** faster than Sinatra in this test
+

data/README.md

@@ -33,6 +33,7 @@ Open the browser at [http://localhost:9292](http://localhost:9292)
 - [Philosophy](#philosophy)
 - [Why use NYNY instead of Sinatra](#why-use-nyny-instead-of-sinatra)
 - [Usage](#usage)
+    - [Environment](#environment)
     - [Running](#running)
     - [Defining routes](#defining-routes)
     - [Request scope](#request-scope)
@@ -79,24 +80,55 @@ A NYNY app must _always_ be in a class which inherits from `NYNY::App`:
       end
     end
 
+## Environment
+To get the directory in which your app is running use `NYNY.root`
+
+```ruby
+#/some/folder/server.rb
+require 'nyny'
+puts NYNY.root #=> /some/folder/
+```
+
+To get NYNY's environment, use `NYNY.env`
+
+```ruby
+#env.rb
+require 'nyny'
+puts NYNY.env
+puts NYNY.env.production?
+```
+
+```bash
+$ ruby env.rb
+development
+false
+
+$ ruby env.rb RACK_ENV=production
+production
+true
+```
+
 ## Running
 There are two ways to run a NYNY app __directly__ [[?]](#middleware):
 
 - by requiring it in a `config.ru` file, and then passing it as argument to the
 Rack's `run` function:
 
-        # config.ru
-        
-        require 'app'
-        run App.new
+```ruby
+# config.ru
 
+require 'app'
+run App.new
+```
 - by using the `run!` method directly on the app class:
 
-        # app.rb
-        
-        # ...app class definition...
+```ruby
+# app.rb
+
+# ...app class definition...
 
-        App.run!
+App.run!
+```
 
 `run!` takes the port number as optional argument (the default port is 9292).
 Also the `run!` method will include 2 default middlewares to make the
@@ -110,28 +142,34 @@ in the case a error occurs during a request.
 NYNY supports the following verbs for defining a route: delete, get, head,
 options, patch, post, put and trace.
 
-    class App < NYNY::App
-      post '/' do
-        'You Posted, dude!'
-      end
-    end
+```ruby
+class App < NYNY::App
+  post '/' do
+    'You Posted, dude!'
+  end
+end
+```
 
 NYNY also suports basic URL patterns:
 
-    class App < NYNY::App
-      get '/greet/:first_name/:last_name' do
-        # the last expression in the block is _always_ considered the response body.
-        "Hello #{params[:first_name]} #{params[:last_name]}!"
-      end
-    end
+```ruby
+class App < NYNY::App
+  get '/greet/:first_name/:last_name' do
+    # the last expression in the block is _always_ considered the response body.
+    "Hello #{params[:first_name]} #{params[:last_name]}!"
+  end
+end
+```
 
 you can also tell NYNY to match a regex for a path:
 
-    class App < NYNY::App
-      get /html/ do
-        'Your URL contains html!'
-      end
-    end
+```ruby
+class App < NYNY::App
+  get /html/ do
+    'Your URL contains html!'
+  end
+end
+```
 
 Each block that is passed to a route definition is evaluated in the context of
 a request scope. See below what methods are available there.
@@ -164,38 +202,44 @@ This means that you can't declare a filter to execute depending on a URL pattern
 However, you can obtain the same effect by calling next in a before block
 if the request.path matches a pattern.
 
-    class App < NYNY::App
-      before do
-        next unless /html/ =~ request.path
-        headers 'Content-Type' => 'text/html'
-      end
+```ruby
+class App < NYNY::App
+  before do
+    next unless /html/ =~ request.path
+    headers 'Content-Type' => 'text/html'
+  end
 
-      after do
-        puts response.inspect
-      end
+  after do
+    puts response.inspect
+  end
 
-      get '/' do
-        'hello'
-      end
-    end
+  get '/' do
+    'hello'
+  end
+end
+```
 
 ## Middleware
 
 A NYNY app is a Rack middleware, which means that it can be used inside 
 Sinatra, Rails, or any other Rack-based app:
 
-    class MyApp < Sinatra::Base
-      use MyNYNYApp
-    end
+```ruby
+class MyApp < Sinatra::Base
+  use MyNYNYApp
+end
+```
 
 NYNY also supports middleware itself, and that means you can use Rack middleware
 (or a Sinatra app) inside a NYNY app:
 
-    class App < NYNY::App
-      # this will serve all the files in the "public" folder
-      use Rack::Static :url => ['public']
-      use SinatraApp
-    end
+```ruby
+class App < NYNY::App
+  # this will serve all the files in the "public" folder
+  use Rack::Static :url => ['public']
+  use SinatraApp
+end
+```
 
 I recommend looking at [the list of Rack middlewares][rack-middleware]
 
@@ -203,9 +247,17 @@ I recommend looking at [the list of Rack middlewares][rack-middleware]
 
 NYNY supports helpers as Sinatra does:
 
-    class App < NYNY::App
-      helpers MyHelperModule
+```ruby
+class App < NYNY::App
+  helpers MyHelperModule
+  helpers do
+    def using_a_block_to_define_helper
+      true
     end
+  end
+end
+```
+
 
 Using a helper implies that the helper module is included in the [RequestScope][2],
 and that all the methods in that module will be available inside a route
@@ -217,44 +269,46 @@ Since version 2.0.0, NYNY added support for extensions.
 This makes possible to include helpers, middlewares and custom app class
 methods inside a single module:
 
-    module MyKewlExtension
-      class Middleware
-        def initialize app
-          @app = app
-        end
+```ruby
+module MyKewlExtension
+  class Middleware
+    def initialize app
+      @app = app
+    end
 
-        def call env
-          env['KEWL'] = true
-          @app.call(env) if @app
-        end
-      end
+    def call env
+      env['KEWL'] = true
+      @app.call(env) if @app
+    end
+  end
 
-      module Helpers
-        def the_ultimate_answer
-          42
-        end
-      end
+  module Helpers
+    def the_ultimate_answer
+      42
+    end
+  end
 
-      def get_or_post route, &block
-        get route, &block
-        post route, &block
-      end
+  def get_or_post route, &block
+    get route, &block
+    post route, &block
+  end
 
-      def self.registered app
-        app.use Middleware
-        app.helpers Helpers
+  def self.registered app
+    app.use Middleware
+    app.helpers Helpers
 
-        app.get_or_post '/' do
-          "After many years of hard computation, the answer is #{the_ultimate_answer}"
-        end
-      end
+    app.get_or_post '/' do
+      "After many years of hard computation, the answer is #{the_ultimate_answer}"
     end
+  end
+end
 
-    class App < NYNY::App
-      register MyKewlExtension
-    end
+class App < NYNY::App
+  register MyKewlExtension
+end
 
-    App.run!
+App.run!
+```
 
 By default, the App class will `extend` the provided extension module.
 Optionally, an extension can add a `registered` method, which will be invoked

data/benchmark.rb

@@ -0,0 +1,95 @@
+#!ruby -I ./lib -I lib
+require 'nyny'
+require 'ruby-prof'
+require 'benchmark'
+require 'sinatra'
+include Benchmark
+
+set :run, false #do not run sinatra's builtin web server
+
+def build_apps &block
+  sinatra = Class.new(Sinatra::Base, &block).new
+  nyny    = Class.new(NYNY::App, &block).new
+  return [nyny, sinatra].map {|app| Rack::MockRequest.new(app) }
+end
+
+def run_test name, apps, &block
+  nyny, sinatra = apps
+  prc = Proc.new(&block)
+
+  puts "\nTest: #{name}"
+  Benchmark.benchmark(CAPTION, 7, FORMAT, "> NYNY/Sinatra:") do |x|
+    nyny_time     = x.report("nyny:   ")  { 1000.times { prc.call(nyny) } }
+    sinatra_time  = x.report("sinatra:")  { 1000.times { prc.call(sinatra) } }
+    puts "NYNY is #{"%.2f" % [sinatra_time.real/nyny_time.real]}x faster than Sinatra in this test"
+  end
+end
+
+puts "Comparing NYNY #{NYNY::VERSION} with Sinatra #{Sinatra::VERSION}"
+
+#
+# Empty app
+apps = build_apps do
+  #empty app
+end
+run_test 'empty', apps do |app|
+  app.get '/'
+end
+
+#
+# Hello World
+apps = build_apps do
+  get '/' do
+    'Hello World'
+  end
+end
+run_test 'hello world', apps do |app|
+  app.get '/'
+end
+
+#
+# Filters
+apps = build_apps do
+  before do
+    request
+  end
+
+  after do
+    response
+  end
+
+  get '/' do
+    'Hello World!'
+  end
+end
+run_test 'filters', apps do |app|
+  app.get '/'
+end
+
+#
+# Helpers
+apps = build_apps do
+  helpers do
+    def da_request
+      request
+    end
+  end
+
+  get '/' do
+    da_request
+  end
+end
+run_test 'helpers', apps do |app|
+  app.get '/'
+end
+
+#
+# Url patterns
+apps = build_apps do
+  get '/:name' do
+    params[:name]
+  end
+end
+run_test 'Url patterns', apps do |app|
+  app.get '/foo'
+end