nyny 2.2.1 → 3.0.0

data/Rakefile

@@ -1,6 +1,6 @@
-require "bundler/gem_tasks"
-require 'rspec/core/rake_task'
-
-desc "run all specs"
-RSpec::Core::RakeTask.new(:default)
-
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc "run all specs"
+RSpec::Core::RakeTask.new(:default)
+

data/benchmark.rb

@@ -1,125 +1,125 @@
-#!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
-
-# Plain routes
-apps = build_apps do
-  [:get, :post, :put].each do |method|
-    10.times do |i|
-      send(method, "/foo/#{i}") do
-        i
-      end
-    end
-  end
-end
-run_test 'A lot o Plain routes', apps do |app|
-  app.get '/foo/5'
-end
-
-#
-# Pattern routes
-apps = build_apps do
-  [:get, :post, :put].each do |method|
-    10.times do |i|
-      send(method, "/foo/#{i}/:action") do
-        params[:action]
-      end
-    end
-  end
-end
-run_test 'A lot of Pattern routes', apps do |app|
-  app.get '/foo/5/edit'
-end
-
+#!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
+
+# Plain routes
+apps = build_apps do
+  [:get, :post, :put].each do |method|
+    10.times do |i|
+      send(method, "/foo/#{i}") do
+        i
+      end
+    end
+  end
+end
+run_test 'A lot o Plain routes', apps do |app|
+  app.get '/foo/5'
+end
+
+#
+# Pattern routes
+apps = build_apps do
+  [:get, :post, :put].each do |method|
+    10.times do |i|
+      send(method, "/foo/#{i}/:action") do
+        params[:action]
+      end
+    end
+  end
+end
+run_test 'A lot of Pattern routes', apps do |app|
+  app.get '/foo/5/edit'
+end
+

data/lib/nyny.rb

@@ -1,36 +1,33 @@
-require 'uri'
-require 'rack'
-require 'tilt'
-
-require 'nyny/version'
-require 'nyny/primitives'
-require 'nyny/request_scope'
-require 'nyny/route'
-require 'nyny/middleware_chain'
-require 'nyny/app'
-require 'nyny/router'
-
-# Register core extensions
-require 'nyny/core-ext/runner'
-require 'nyny/core-ext/templates'
-
-module NYNY
-  App.register NYNY::Runner
-  App.register NYNY::Templates
-
-  class EnvString < String
-    [:production, :development, :test].each do |env|
-      define_method "#{env}?" do
-        self == env.to_s
-      end
-    end
-  end
-
-  def self.root
-    Dir.pwd
-  end
-
-  def self.env
-    @env ||= EnvString.new(ENV['RACK_ENV'] || 'development')
-  end
-end
+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'
+
+module NYNY
+  class EnvString < String
+    [:production, :development, :test].each do |env|
+      define_method "#{env}?" do
+        self == env.to_s
+      end
+    end
+  end
+
+  def self.root
+    Dir.pwd
+  end
+
+  def self.env
+    @env ||= EnvString.new(ENV['RACK_ENV'] || 'development')
+  end
+
+  App.register NYNY::Runner
+  App.register NYNY::Templates
+end
+

data/lib/nyny/app.rb

@@ -1,67 +1,79 @@
-module NYNY
-  class App
-    HTTP_VERBS = [:delete, :get, :head, :options, :patch, :post, :put, :trace]
-
-    attr_reader :middleware_chain, :router
-    def initialize app=nil
-      @router = 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
-      })
-      @middleware_chain = MiddlewareChain.new(self.class.middlewares,
-                                              lambda {|env| _call(env)})
-    end
-
-    def _call env
-      router.call env
-    end
-
-    def call env
-      middleware_chain.call env
-    end
-
-    #class methods
-    class << self
-      HTTP_VERBS.each do |method|
-        define_method method do |str, &blk|
-          routes << Route.new(method, str, &blk)
-        end
-      end
-
-      def middlewares;  @middlewares  ||= []  end
-      def routes;       @routes       ||= []  end
-      def before_hooks; @before_hooks ||= []  end
-      def after_hooks;  @after_hooks  ||= []  end
-
-      # move middleware chain and runner to core-ext
-      def register *extensions
-        extensions.each do |ext|
-          extend ext
-          ext.registered(self) if ext.respond_to?(:registered)
-        end
-      end
-
-      def before &blk
-        before_hooks << Proc.new(&blk)
-      end
-
-      def after &blk
-        after_hooks << Proc.new(&blk)
-      end
-
-      def use middleware, *args, &block
-        middlewares << [middleware, args, block]
-      end
-
-      def helpers *args, &block
-        if block_given?
-          args << Module.new(&block)
-        end
-
-        args.each {|m| RequestScope.add_helper_module m }
-      end
-    end #class methods
-  end
-end
+module NYNY
+  class App
+    HTTP_VERBS = [:delete, :get, :head, :options, :patch, :post, :put, :trace]
+
+    def self.inheritable name, value
+      @_inheritables ||= []
+      @_inheritables << name
+      self.class.send :attr_accessor, name
+      self.send "#{name}=", value
+    end
+
+    def self.inherited subclass
+      @_inheritables.each do |attr|
+        subclass.send "#{attr}=", self.send(attr).clone
+        subclass.instance_variable_set "@_inheritables", @_inheritables.clone
+      end
+
+      super
+    end
+
+    inheritable :builder,       Rack::Builder.new
+    inheritable :routes,        []
+    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
+      })
+    end
+
+    def call env
+      self.class.builder.call env
+    end
+
+    #class methods
+    class << self
+      HTTP_VERBS.each do |method|
+        define_method method do |str, &blk|
+          routes << Route.new(method, str, &blk)
+        end
+      end
+
+      def register *extensions
+        extensions.each do |ext|
+          extend ext
+          ext.registered(self) if ext.respond_to?(:registered)
+        end
+      end
+
+      def namespace url, &block
+        app = Class.new(NYNY::App, &block)
+        builder.map (url) { use app }
+      end
+
+      def before &blk
+        before_hooks << Proc.new(&blk)
+      end
+
+      def after &blk
+        after_hooks << Proc.new(&blk)
+      end
+
+      def use middleware, *args, &block
+        builder.use middleware, *args, &block
+      end
+
+      def helpers *args, &block
+        args << Module.new(&block) if block_given?
+        args.each {|m| scope_class.send :include, m }
+      end
+    end #class methods
+  end
+end