nyny 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae38227835876ef5e85282b236b5349049e15116
-  data.tar.gz: 70836d65922b92ac174fee44b9c0c1dc8a2525b9
+  metadata.gz: 123f620e3c40a87a0f54fd78cd8f8112941d0220
+  data.tar.gz: 89ff15d4d6635afe7fdb7626f5981ecd756359b6
 SHA512:
-  metadata.gz: 99cfbc9eabad3173837d1acba68236b4eb7ba01dee114691d12a8266bb6c4970acea3a586c7be8b1699f08938abaea8f5ef1e25931b47dc78b6d2c10a6d5907b
-  data.tar.gz: 5443fdcb5d69b8771f35153ca8c7bbec47eb71f6db4221fd831f2f733da4b62576f99ac723491f9778d7e2fa0659a472ff21d378bbb9fd46054948067127fe8b
+  metadata.gz: 6ef900b1533aca5c0b1422ab7a621ebac15a0eb5a9f2e1b49c0a04da5464d4b656b9b1e328cf2da566983b1a9e4c242ad51069f5669e6a66c088fe611e31d9a6
+  data.tar.gz: 82fdbc3b1dc437bb94b3e51142d5082077b4ed25c0a7ccd6d87489d832c1cda8debf9224ad1539b5be14acb0e7d6e23df5c002346a216e5115f858d62c87e687

data/CHANGELOG

@@ -1,3 +1,7 @@
+3.2.0
+  - Use Rails' Journey router as router to conquer the world and shorten
+    the codebase
+
 3.1.0
   - use latest Tilt (2.0.0)
   - get rid of silly Rack::Response hacks, write to body properly

data/README.md

@@ -1,5 +1,5 @@
 # New York, New York.
-(very) small Sinatra clone.
+(ridiculously) small and powerful micro web framework.
 
 [![Build Status](https://api.travis-ci.org/alisnic/nyny.png)](https://travis-ci.org/alisnic/nyny)
 [![Coverage Status](https://coveralls.io/repos/alisnic/nyny/badge.png)](https://coveralls.io/r/alisnic/nyny)
@@ -42,9 +42,9 @@ Open the browser at [http://localhost:9292](http://localhost:9292)
     - [Environment](#environment)
     - [Running](#running)
     - [Defining routes](#defining-routes)
+    - [Request scope](#request-scope)
     - [Namespaces](#namespaces)
     - [Templates](#templates)
-    - [Request scope](#request-scope)
     - [Filters](#filters)
     - [Middleware](#middleware)
     - [Helpers](#helpers)
@@ -52,31 +52,17 @@ Open the browser at [http://localhost:9292](http://localhost:9292)
 - [FAQ](#f-a-q)
 - [Contributing](#contributing)
 
-# Motivation
-My efforts to write __NYNY__ started when I wanted to understand how __Sinatra__
-works, and stumbled upon the [base.rb][0]. The majority of the classes that
-are used by Sinatra are in one single file, which makes it nearly impossible
-for a new person to grasp.
-
-I wanted to understand how sinatra works, but the code was pretty challenging.
-So I decided I should re-implement the basic things Sinatra has.
-Thus, __NYNY__ was born.
-
 # Philosophy
-NYNY should have only the bare minimum to write basic web servers comfortably,
-everything else should be in a extension. It is also
-trivial to use NYNY to build large and complex apps, by writing multiple sub
-apps and using Rack to mount them, or by using those sub apps in the "main" app
-as middleware.
-
-# Why use NYNY instead of Sinatra
-- It's very small (~300 LOC), which is just a little overhead on top of Rack.
-- Sinatra is a drop-in replacement for NYNY. Anytime you feel that you need more,
-  you can just change your app to inherit from `Sinatra::Base`, your code will
-  still work, and you will be able to use any of the Sinatra features.
-- It's __~2 times faster__ than Sinatra (see [Performance][performance] for details)
+NYNY is unassuming, it has all the core stuff to get running, but nothing else.
+Your app is the framework. However, it's trivial to extend NYNY via its
+[extension interface](#extensions).
+
+# Why use NYNY instead of any other small web framework
+- It's __very__ small (<300 LOC), which is just a little overhead on top of Rack.
 - You want to dig into the source code and change to your needs (NYNY's source code is more welcoming)
 - Each NYNY app is a Rack middleware, so it can be used inside of Sinatra, Rails, or any other Rack-based app.
+- __It uses Journey for routing (Rails' router)__, which makes its routing logic
+  a lot more powerful and reliable that in most micro web frameworks.
 
 # Usage
 
@@ -97,6 +83,7 @@ To get the directory in which your app is running use `NYNY.root`
 #/some/folder/server.rb
 require 'nyny'
 puts NYNY.root #=> /some/folder/
+puts NYNY.root.join("foo") #=> /some/folder/foo
 ```
 
 To get NYNY's environment, use `NYNY.env`
@@ -142,13 +129,14 @@ 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
-development easier: Rack::CommonLogger and Rack::ShowExceptions.
+development easier: Rack::CommonLogger and BetterErrors::Middleware (only in dev).
 This will show all requests in the log, and will provide useful details
 in the case a error occurs during a request.
 
 ## Defining routes
 
-NYNY supports the following verbs for defining a route: delete, get, head,
+NYNY uses [Journey][journey] for routing, that means that NYNY has all the
+awesomeness the Rails' router has. NYNY supports the following verbs for defining a route: delete, get, head,
 options, patch, post, put and trace.
 
 ```ruby
@@ -158,24 +146,25 @@ class App < NYNY::App
   end
 end
 ```
+You can use any construct or convention [supported in Rails][bound-params]
+for the path string.
 
-NYNY also suports basic URL patterns:
+Each route definition call optionally accepts constraints:
 
 ```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]}!"
+  get '/', :constraints => {:format => :html} do
+    'html'
   end
 end
 ```
+You can use [the same constraints][constraints] you use in Rails.
 
-you can also tell NYNY to match a regex for a path:
-
+Besides the constraints, you can specify defaults:
 ```ruby
 class App < NYNY::App
-  get /html/ do
-    'Your URL contains html!'
+  get '/', :defaults => {:format => 'html'} do
+    'html'
   end
 end
 ```
@@ -183,6 +172,30 @@ 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.
 
+## Request scope
+As was said above, when you pass a block to a route definition,
+that block is evaluated in the context of a [RequestScope][2].
+This means that several methods/objects available inside that block:
+
+- `request` - A `Rack::Request` object which encapsulates the request
+  to that route. (see [Rack::Request documentation][3] for more info)
+- `response` - A `Rack::Response` object which encapsulates the response.
+  Additionally, NYNY's response exposes 2 more methods in addition to Rack's ones.
+  (see [primitives.rb][primitivesrb])
+- `params` - a hash which contains both POST body params and GET querystring params.
+- `headers` - a hash with the response headers
+  (ex: `headers['Content-Type'] = 'text/html'`)
+- `status` - allows you to set the status of the response (ex: `status 403`)
+- `redirect_to` - sets the response to redirect
+  (ex: `redirect_to 'http://google.com'`)
+- `cookies` - a hash which allows you to access/modify/remove cookies
+  (ex: `cookies[:foo] = 'bar'` or `cookies.delete[:foo]`)
+- `session` - a hash which allows you to access/modify/remove session variables
+  (ex: `session[:foo] = 'bar'`)
+- `halt` - allows you to instantly return a response, interrupting current
+  handler execution (see [halt][halt-definition])
+
+
 ## Namespaces
 You can define namespaces for routes in NYNY. Each namespace is an isolated
 app, which means that you can use the same api that you use in your top app there:
@@ -254,29 +267,6 @@ end
 ```
 NYNY uses [Tilt][tilt] for templating, so the list of supported engines is pretty complete.
 
-## Request scope
-As was said above, when you pass a block to a route definition,
-that block is evaluated in the context of a [RequestScope][2].
-This means that several methods/objects available inside that block:
-
-- `request` - A `Rack::Request` object which encapsulates the request
-  to that route. (see [Rack::Request documentation][3] for more info)
-- `response` - A `Rack::Response` object which encapsulates the response.
-  Additionally, NYNY's response exposes 2 more methods in addition to Rack's ones.
-  (see [primitives.rb][primitivesrb])
-- `params` - a hash which contains both POST body params and GET querystring params.
-- `headers` - a hash with the response headers
-  (ex: `headers['Content-Type'] = 'text/html'`)
-- `status` - allows you to set the status of the response (ex: `status 403`)
-- `redirect_to` - sets the response to redirect
-  (ex: `redirect_to 'http://google.com'`)
-- `cookies` - a hash which allows you to access/modify/remove cookies
-  (ex: `cookies[:foo] = 'bar'` or `cookies.delete[:foo]`)
-- `session` - a hash which allows you to access/modify/remove session variables
-  (ex: `session[:foo] = 'bar'`)
-- `halt` - allows you to instantly return a response, interrupting current
-  handler execution (see [halt][halt-definition])
-
 ## Filters
 
 Unlike Sinatra, NYNY supports only "generic" before and after filters.
@@ -422,3 +412,6 @@ TBD.
 [halt-definition]: https://github.com/alisnic/nyny/blob/master/lib/nyny/request_scope.rb#L36
 [primitivesrb]: https://github.com/alisnic/nyny/blob/master/lib/nyny/primitives.rb
 [tilt]: https://github.com/rtomayko/tilt
+[journey]: https://github.com/rails/journey
+[constraints]: http://guides.rubyonrails.org/routing.html#request-based-constraints
+[bound-params]: http://guides.rubyonrails.org/routing.html#bound-parameters

data/lib/nyny.rb

@@ -1,12 +1,7 @@
-require 'uri'
 require 'rack'
 
 require 'nyny/version'
-require 'nyny/primitives'
-require 'nyny/request_scope'
-require 'nyny/route'
 require 'nyny/app'
-require 'nyny/router'
 require 'nyny/core-ext/runner'
 require 'nyny/core-ext/templates'
 
@@ -19,8 +14,14 @@ module NYNY
     end
   end
 
+  class PathString < String
+    def join other
+      File.join(self, other)
+    end
+  end
+
   def self.root
-    Dir.pwd
+    @root ||= PathString.new(Dir.pwd)
   end
 
   def self.env

data/lib/nyny/app.rb

@@ -1,3 +1,7 @@
+require 'nyny/primitives'
+require 'nyny/request_scope'
+require 'nyny/router'
+
 module NYNY
   class App
     HTTP_VERBS = [:delete, :get, :head, :options, :patch, :post, :put, :trace]
@@ -19,19 +23,20 @@ module NYNY
     end
 
     inheritable :builder,       Rack::Builder.new
-    inheritable :routes,        []
+    inheritable :route_defs,    []
     inheritable :before_hooks,  []
     inheritable :after_hooks,   []
     inheritable :scope_class,   Class.new(RequestScope)
 
     def initialize app=nil
       self.class.builder.run Router.new({
-        :routes       => self.class.routes,
-        :fallback     => (app || lambda {|env| Response.new [], 404 }),
-        :before_hooks => self.class.before_hooks,
-        :after_hooks  => self.class.after_hooks,
-        :scope_class  => self.class.scope_class
+        :scope_class    => self.class.scope_class,
+        :route_defs     => self.class.route_defs,
+        :before_hooks   => self.class.before_hooks,
+        :after_hooks    => self.class.after_hooks,
+        :fallback       => app
       })
+
       @app = self.class.builder.to_app
     end
 
@@ -42,11 +47,17 @@ module NYNY
     #class methods
     class << self
       HTTP_VERBS.each do |method|
-        define_method method do |str, &blk|
-          routes << Route.new(method, str, &blk)
+        define_method method do |path, options={}, &block|
+          options[:constraints] ||= {}
+          options[:constraints].merge!(:request_method => method.to_s.upcase)
+          define_route path, options, &block
         end
       end
 
+      def define_route path, options, &block
+        self.route_defs << [path, options, Proc.new(&block)]
+      end
+
       def register *extensions
         extensions.each do |ext|
           extend ext

data/lib/nyny/request_scope.rb

@@ -11,7 +11,7 @@ module NYNY
 
     def initialize request
       @request  = request
-      @response = Response.new
+      @response = Response.new [], 200, {'Content-Type' => 'text/html'}
     end
 
     def cookies

data/lib/nyny/router.rb

@@ -1,46 +1,64 @@
+require 'journey'
+
 module NYNY
   class Router
-    attr_reader :fallback, :routes, :before_hooks, :after_hooks, :scope_class
+    attr_reader :scope_class, :journey, :before_hooks, :after_hooks, :fallback
     def initialize options
-      @fallback     = options[:fallback]
-      @routes       = options[:routes]
-      @before_hooks = options[:before_hooks]
-      @after_hooks  = options[:after_hooks]
-      @scope_class  = options[:scope_class]
+      @scope_class    = options[:scope_class]
+      @before_hooks   = options[:before_hooks]
+      @after_hooks    = options[:after_hooks]
+      @fallback       = options[:fallback]
+
+      prepare_for_journey(options[:route_defs])
     end
 
     def call env
-      env['PATH_INFO'] = '/' if env['PATH_INFO'].empty?
-      route = routes.find {|route| route.match? env }
+      response = journey.call(env)
 
-      if route
-        process route, env
+      if response[0] == 404 and fallback
+        fallback.call(env)
       else
-        fallback.call env
+        response
       end
     end
 
-    def process route, env
-      request = Request.new(env)
-      request.params.merge! route.url_params(env)
-      request.params.default_proc = lambda do |h, k|
-        h.fetch(k.to_s, nil) || h.fetch(k.to_sym, nil)
-      end
+    private
 
-      eval_response scope_class.new(request), route.handler
-    end
+    def prepare_for_journey route_defs
+      @journey = Journey::Router.new(Journey::Routes.new, {
+        :parameters_key => 'nyny.params'
+      })
 
-    def eval_response scope, handler
-      response = catch (:halt) do
-        before_hooks.each {|h| scope.instance_eval &h }
-        scope.apply_to &handler
-      end
+      route_defs.each do |path, options, handler|
+        pat         = Journey::Path::Pattern.new(path)
+        constraints = options.fetch(:constraints, {})
+        defaults    = options.fetch(:defaults, {})
 
-      catch (:halt) do
-        after_hooks.each {|h| scope.instance_eval &h }
+        @journey.routes.add_route compile(handler), pat, constraints, defaults
       end
+    end
 
-      response
+    def compile handler
+      Proc.new do |env|
+        request = Request.new(env)
+        request.params.merge! env["nyny.params"]
+        request.params.default_proc = lambda do |h, k|
+          h.fetch(k.to_s, nil) || h.fetch(k.to_sym, nil)
+        end
+
+        scope = scope_class.new(request)
+
+        response = catch (:halt) do
+          before_hooks.each {|h| scope.instance_eval &h }
+          scope.apply_to &handler
+        end
+
+        catch (:halt) do
+          after_hooks.each {|h| scope.instance_eval &h }
+        end
+
+        response
+      end
     end
   end
-end
+end

data/lib/nyny/version.rb

@@ -1,3 +1,3 @@
 module NYNY
-  VERSION = "3.1.0"
+  VERSION = "3.2.0"
 end

data/nyny.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency             "rack-contrib",   "~> 1.1.0"
   spec.add_dependency             "tilt",           "~> 2.0.0"
   spec.add_dependency             "better_errors",  "~> 1.1.0"
+  spec.add_dependency             "journey",        "~> 1.0.4"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/spec/nyny_spec.rb

@@ -1,11 +1,15 @@
 require 'spec_helper'
 
 describe NYNY do
-  it '.root points to pwd' do
+  its 'root points to pwd' do
     NYNY.root.should == Dir.pwd
   end
 
   it 'has the correct env' do
     NYNY.env.should be_test
   end
+
+  its 'root can join a path' do
+    NYNY.root.join("foo").should == File.join(Dir.pwd, "foo")
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nyny
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Andrei Lisnic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: journey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -122,7 +136,6 @@ files:
 - CHANGELOG
 - Gemfile
 - LICENSE.txt
-- Performance.md
 - README.md
 - Rakefile
 - lib/nyny.rb
@@ -131,7 +144,6 @@ files:
 - lib/nyny/core-ext/templates.rb
 - lib/nyny/primitives.rb
 - lib/nyny/request_scope.rb
-- lib/nyny/route.rb
 - lib/nyny/router.rb
 - lib/nyny/version.rb
 - nyny.gemspec
@@ -140,7 +152,6 @@ files:
 - spec/nyny_spec.rb
 - spec/primitives_spec.rb
 - spec/request_scope_spec.rb
-- spec/router_spec.rb
 - spec/runner_spec.rb
 - spec/spec_helper.rb
 - spec/templates_spec.rb
@@ -178,7 +189,6 @@ test_files:
 - spec/nyny_spec.rb
 - spec/primitives_spec.rb
 - spec/request_scope_spec.rb
-- spec/router_spec.rb
 - spec/runner_spec.rb
 - spec/spec_helper.rb
 - spec/templates_spec.rb

data/Performance.md

@@ -1,45 +0,0 @@
-
-Note: this bench may be a bit obsolete, I removed the profiling
-script due to the fact that NYNY's and Sintara's deps are
-incompatible. For a more complete list of of microframework
-benchmarks, see [https://github.com/luislavena/bench-micro]()
-```
-Comparing NYNY 3.0.0 with Sinatra 1.4.4
-
-Test: hello world
-              user     system      total        real
-nyny:     0.110000   0.000000   0.110000 (  0.108916)
-sinatra:  0.260000   0.010000   0.270000 (  0.273225)
-NYNY is 2.51x faster than Sinatra in this test
-
-Test: filters
-              user     system      total        real
-nyny:     0.120000   0.000000   0.120000 (  0.118976)
-sinatra:  0.250000   0.010000   0.260000 (  0.264279)
-NYNY is 2.22x faster than Sinatra in this test
-
-Test: helpers
-              user     system      total        real
-nyny:     0.100000   0.000000   0.100000 (  0.105290)
-sinatra:  0.240000   0.000000   0.240000 (  0.249585)
-NYNY is 2.37x faster than Sinatra in this test
-
-Test: Url patterns
-              user     system      total        real
-nyny:     0.120000   0.000000   0.120000 (  0.113535)
-sinatra:  0.260000   0.020000   0.280000 (  0.277098)
-NYNY is 2.44x faster than Sinatra in this test
-
-Test: A lot o Plain routes
-              user     system      total        real
-nyny:     0.120000   0.000000   0.120000 (  0.113001)
-sinatra:  0.250000   0.000000   0.250000 (  0.262890)
-NYNY is 2.33x faster than Sinatra in this test
-
-Test: A lot of Pattern routes
-              user     system      total        real
-nyny:     0.130000   0.000000   0.130000 (  0.133590)
-sinatra:  0.270000   0.010000   0.280000 (  0.284605)
-NYNY is 2.13x faster than Sinatra in this test
-
-```

data/lib/nyny/route.rb

@@ -1,40 +0,0 @@
-module NYNY
-  class Route
-    NAME_PATTERN = /:(\S+)/
-
-    attr_reader :pattern, :handler, :method
-    def initialize method, signature, &block
-      @pattern = pattern_for signature
-      @handler = Proc.new(&block)
-      @method = method.to_s.upcase
-    end
-
-    def pattern_for signature
-      return signature if signature.is_a? Regexp
-      build_regex(signature.start_with?('/') ? signature : "/#{signature}")
-    end
-
-    def build_regex signature
-      return %r(^#{signature}$) unless signature.include?(':')
-
-      groups = signature.split('/').map do |part|
-        next part if part.empty?
-        next part unless part.start_with? ':'
-        name = NAME_PATTERN.match(part)[1]
-        %Q{(?<#{name}>\\S+)}
-      end.select {|s| !s.empty? }.join('\/')
-
-      %r(^\/#{groups}$)
-    end
-
-    def match? env
-      return false unless method == env['REQUEST_METHOD']
-      not pattern.match(env['PATH_INFO']).nil?
-    end
-
-    def url_params env
-      data = pattern.match(env['PATH_INFO'])
-      Hash[data.names.map {|n| [n.to_sym, URI.unescape(data[n])]}]
-    end
-  end
-end

data/spec/router_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Router do
-  let (:app) do
-    mock_app do
-      get '/' do
-        halt 200, {}, "Bar"
-        "Foo"
-      end
-
-      post '/' do
-        params[:not_exist].to_s
-      end
-
-      after do
-        response.rewrite "Zaz"
-      end
-    end
-  end
-
-  it "should eval after blocks even if the request was halted" do
-    response = app.get('/')
-    response.body.should == "Zaz"
-  end
-
-  it "should not raise SystemStackError if any absent param is accessed" do
-    expect { response = app.post('/') }.not_to raise_error
-  end
-end