roda 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c94569f43d36e67b81fa0f67d739a24f9b5a594
-  data.tar.gz: 8420ceb5dafb0f76e840fdeff028e46f4b0842f9
+  metadata.gz: 4196dbdea5add49bdf94cb6c59d5f10f3d2d6464
+  data.tar.gz: 23b683d38973ae9c47d99033e35f71be7ae89e68
 SHA512:
-  metadata.gz: ab68ffe4810164018008821e8a8ae7a66469a58884ff5a25599e0cac03330e393d9b62cf5d8712ceea8e9a870afd431f52a072294c710285a7e69d1a243326b0
-  data.tar.gz: ab79ec088d85b8daa3f705fb92bcd9e64be19ae9a5bf131f9414fca72c53a89f00a9c82465ed8db68440bf120a783c1ad4e521e295f15868a4a372463ecf8a06
+  metadata.gz: 79a29e4ad2df5b81307e3db2bd768c10937f9a704f93d5702b97779ee1f6821b223e60b5011ce3c482220bf56d993d3aa67473e1bd6a8b68869135123ee29897
+  data.tar.gz: 7ffc00c161bf098279cf9b5e61bd02aa5e99531e9c4bd1072ab7b97a191ff77e1c417a037e8f1c7b2d8d2dc757fc15d667d57d622aa001a3e568c467700ce8be

data/CHANGELOG

@@ -1,3 +1,15 @@
+= 2.4.0 (2015-06-15)
+
+* Add websockets plugin, for integration with faye-websocket (jeremyevans)
+
+* Add status_handler plugin, similar to not_found but for any status code (celsworth) (#29)
+
+* Support Closure Compiler, Uglifier, and MinJS for compressing javascript in the assets plugin (jeremyevans)
+
+* Make Roda.plugin always return nil (jeremyevans)
+
+* Add :gzip option to assets plugin (jeremyevans)
+
 = 2.3.0 (2015-05-13)
 
 * Make assets plugin work better with json plugin when r.assets is the last method called in a route block (jeremyevans) (#27)

data/Rakefile

@@ -6,7 +6,7 @@ VERS = lambda do
   require File.expand_path("../lib/roda/version.rb", __FILE__)
   Roda::RodaVersion
 end
-CLEAN.include ["#{NAME}-*.gem", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc"]
+CLEAN.include ["#{NAME}-*.gem", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc", "spec/assets/app.*.css", "spec/assets/app.*.js", "spec/assets/app.*.css.gz", "spec/assets/app.*.js.gz"]
 
 # Gem Packaging and Release
 

data/doc/release_notes/2.4.0.txt

@@ -0,0 +1,55 @@
+= New Plugins
+
+* A websocket plugin has been added, for websocket support using
+  faye-websocket.  Here's an example of a simple echo service using
+  websockets:
+
+    plugin :websocket
+
+    route do |r|
+      r.get "echo" do
+        r.websocket do |ws|
+          # Routing block taken for a websocket request to /echo
+
+          # ws is a Faye::WebSocket instance, so you can use the
+          # Faye::WebSocket API
+          ws.on(:message) do |event|
+            ws.send(event.data)
+          end
+        end
+
+        # View rendered if a regular GET request to /echo
+        view "echo"
+      end
+    end
+ 
+* A status_handler plugin has been added, which allows Roda to
+  specially handle arbitrary status codes.  Usage is similar to the
+  not_found plugin (which now uses status_handler internally):
+
+    plugin :status_handler
+
+    status_handler 403 do
+      "You are forbidden from seeing that!"
+    end
+    status_handler 404 do
+      "Where did it go?"
+    end
+
+= Other New Features
+
+* The assets plugin now supports a :gzip option, which will save
+  gzipped versions when compiling assets.  When serving compiled
+  assets, if the request accepts gzip encoding, it will serve
+  the gzipped version.  This also plays nicely with nginx's
+  gzip_static support.
+
+* The assets plugin now supports Google Closure Compiler, Uglifier,
+  and MinJS for minifying javascript.  You can now specify which
+  css and js compressors to use via the :css_compressor and
+  :js_compressor options.
+
+= Backwards Compatibility
+
+* Roda.plugin now always returns nil.  Previously the return value
+  could be non-nil if the plugin used a configure method.

data/lib/roda.rb

@@ -161,7 +161,7 @@ class Roda
 
         # Load a new plugin into the current class.  A plugin can be a module
         # which is used directly, or a symbol represented a registered plugin
-        # which will be required and then used.
+        # which will be required and then used. Returns nil.
         #
         #   Roda.plugin PluginModule
         #   Roda.plugin :csrf
@@ -176,6 +176,7 @@ class Roda
           self::RodaResponse.send(:include, plugin::ResponseMethods) if defined?(plugin::ResponseMethods)
           self::RodaResponse.extend(plugin::ResponseClassMethods) if defined?(plugin::ResponseClassMethods)
           plugin.configure(self, *args, &block) if plugin.respond_to?(:configure)
+          nil
         end
 
         # Setup routing tree for the current Roda application, and build the

data/lib/roda/plugins/assets.rb

@@ -199,6 +199,8 @@ class Roda
     # :compiled_path:: Path inside public folder in which compiled files are stored (default: :prefix)
     # :concat_only :: Whether to just concatenate instead of concatentating
     #                 and compressing files (default: false)
+    # :css_compressor :: Compressor to use for compressing CSS, either :yui, :none, or nil (the default, which will try
+    #                    :yui if available, but not fail if it is not available)
     # :css_dir :: Directory name containing your css source, inside :path (default: 'css')
     # :css_headers :: A hash of additional headers for your rendered css files
     # :css_opts :: Template options to pass to the render plugin (via :template_opts) when rendering css assets
@@ -208,7 +210,11 @@ class Roda
     #                  detect changes in your asset files.
     # :group_subdirs :: Whether a hash used in :css and :js options requires the assets for the
     #                   related group are contained in a subdirectory with the same name (default: true)
+    # :gzip :: Store gzipped compiled assets files, and serve those to clients who accept gzip encoding.
     # :headers :: A hash of additional headers for both js and css rendered files
+    # :js_compressor :: Compressor to use for compressing javascript, either :yui, :closure, :uglifier, :minjs,
+    #                   :none, or nil (the default, which will try :yui, :closure, :uglifier, then :minjs, but
+    #                   not fail if any of them is not available)
     # :js_dir :: Directory name containing your javascript source, inside :path (default: 'js')
     # :js_headers :: A hash of additional headers for your rendered javascript files
     # :js_opts :: Template options to pass to the render plugin (via :template_opts) when rendering javascript assets
@@ -243,6 +249,13 @@ class Roda
       EMPTY_STRING = ''.freeze
       JS_SUFFIX = '.js'.freeze
       CSS_SUFFIX = '.css'.freeze
+      HTTP_ACCEPT_ENCODING = 'HTTP_ACCEPT_ENCODING'.freeze
+      CONTENT_ENCODING = 'Content-Encoding'.freeze
+      GZIP = 'gzip'.freeze
+      DOTGZ = '.gz'.freeze
+
+      # Internal exception raised when a compressor cannot be found
+      CompressorNotFound = Class.new(RodaError)
 
       # Load the render and caching plugins plugins, since the assets plugin
       # depends on them.
@@ -420,6 +433,14 @@ class Roda
           path = "#{o[:"compiled_#{type}_path"]}#{suffix}.#{unique_id}.#{type}"
           ::FileUtils.mkdir_p(File.dirname(path))
           ::File.open(path, 'wb'){|f| f.write(content)}
+
+          if o[:gzip]
+            require 'zlib'
+            Zlib::GzipWriter.open("#{path}.gz") do |gz|
+              gz.write(content)
+            end
+          end
+
           nil
         end
 
@@ -428,22 +449,81 @@ class Roda
         # a java runtime.  This method can be overridden by the application
         # to use a different compressor.
         def compress_asset(content, type)
-          require 'yuicompressor'
-          # :nocov:
-          content = YUICompressor.send("compress_#{type}", content, :munge => true)
-          # :nocov:
-        rescue LoadError, Errno::ENOENT
-          # yuicompressor or java not available, just use concatenated, uncompressed output
+          case compressor = assets_opts[:"#{type}_compressor"]
+          when :none
+            return content
+          when nil
+            # default, try different compressors
+          else
+            return send("compress_#{type}_#{compressor}", content)
+          end
+
+          compressors = if type == :js
+            [:yui, :closure, :uglifier, :minjs]
+          else
+            [:yui]
+          end
+
+          compressors.each do |comp|
+            begin
+              if c = send("compress_#{type}_#{comp}", content)
+                return c
+              end
+            rescue LoadError, CompressorNotFound
+            end
+          end
+
           content
         end
 
+        # Compress the CSS using YUI Compressor, requires java runtime
+        def compress_css_yui(content)
+          compress_yui(content, :compress_css)
+        end
+
+        # Compress the JS using Google Closure Compiler, requires java runtime
+        def compress_js_closure(content)
+          require 'closure-compiler'
+
+          begin
+            ::Closure::Compiler.new.compile(content)
+          rescue ::Closure::Error => e
+            raise CompressorNotFound, "#{e.class}: #{e.message}", e.backtrace
+          end
+        end
+
+        # Compress the JS using MinJS, a pure ruby compressor
+        def compress_js_minjs(content)
+          require 'minjs'
+          ::Minjs::Compressor.new(:debug => false).compress(content)
+        end
+
+        # Compress the JS using Uglifier, requires javascript runtime
+        def compress_js_uglifier(content)
+          require 'uglifier'
+          Uglifier.compile(content)
+        end
+
+        # Compress the CSS using YUI Compressor, requires java runtime
+        def compress_js_yui(content)
+          compress_yui(content, :compress_js)
+        end
+
+        # Compress the CSS/JS using YUI Compressor, requires java runtime
+        def compress_yui(content, meth)
+          require 'yuicompressor'
+          ::YUICompressor.send(meth, content, :munge => true)
+        rescue ::Errno::ENOENT => e
+          raise CompressorNotFound, "#{e.class}: #{e.message}", e.backtrace
+        end
+
         # Return a unique id for the given content.  By default, uses the
         # SHA1 hash of the content.  This method can be overridden to use
         # a different digest type or to return a static string if you don't
         # want to use a unique value.
         def asset_digest(content)
           require 'digest/sha1'
-          Digest::SHA1.hexdigest(content)
+          ::Digest::SHA1.hexdigest(content)
         end
       end
 
@@ -512,6 +592,12 @@ class Roda
           o = self.class.assets_opts
           if o[:compiled]
             file = "#{o[:"compiled_#{type}_path"]}#{file}"
+
+            if o[:gzip] && env[HTTP_ACCEPT_ENCODING] =~ /\bgzip\b/
+              @_response[CONTENT_ENCODING] = GZIP
+              file << DOTGZ
+            end
+
             check_asset_request(file, type, ::File.stat(file).mtime)
             ::File.read(file)
           else

data/lib/roda/plugins/hooks.rb

@@ -21,13 +21,13 @@ class Roda
     #     # ...
     #   end
     #
+    # However, this code makes it easier to write after hooks, as well as
+    # handle cases where before hooks are added after the route block.
+    #
     # Note that the after hook is called with the rack response array
     # of status, headers, and body.  If it wants to change the response,
     # it must mutate this argument, calling <tt>response.status=</tt> inside
     # an after block will not affect the returned status.
-    #
-    # However, this code makes it easier to write after hooks, as well as
-    # handle cases where before hooks are added after the route block.
     module Hooks
       def self.configure(app)
         app.opts[:before_hook] ||= nil

data/lib/roda/plugins/not_found.rb

@@ -23,7 +23,15 @@ class Roda
     # will be cleared.  So if you want to be sure the headers are set
     # even in a not_found block, you need to reset them in the
     # not_found block.
+    #
+    # This plugin is now a wrapper around the +status_handler+ plugin and
+    # still exists mainly for backward compatibility.
     module NotFound
+      # Require the status_handler plugin
+      def self.load_dependencies(app)
+        app.plugin :status_handler
+      end
+
       # If a block is given, install the block as the not_found handler.
       def self.configure(app, &block)
         if block
@@ -34,31 +42,7 @@ class Roda
       module ClassMethods
         # Install the given block as the not_found handler.
         def not_found(&block)
-          define_method(:not_found, &block)
-          private :not_found
-        end
-      end
-
-      module InstanceMethods
-        # If routing returns a 404 response with an empty body, call
-        # the not_found handler.
-        def call
-          result = super
-
-          if result[0] == 404 && (v = result[2]).is_a?(Array) && v.empty?
-            @_response.headers.clear
-            super{not_found}
-          else
-            result
-          end
-        end
-
-        private
-
-        # Use an empty not_found_handler by default, so that loading
-        # the plugin without defining a not_found handler doesn't
-        # break things.
-        def not_found
+          status_handler(404, &block)
         end
       end
     end

data/lib/roda/plugins/status_handler.rb

@@ -0,0 +1,57 @@
+class Roda
+  module RodaPlugins
+    # The status_handler plugin adds a +status_handler+ method which sets a
+    # block that is called whenever a response with the relevant response code
+    # with an empty body would be returned.
+    #
+    # This plugin does not support providing the blocks with the plugin call;
+    # you must provide them to status_handler calls afterwards:
+    #
+    #   plugin :status_handler
+    #
+    #   status_handler(403) do
+    #     "You are forbidden from seeing that!"
+    #   end
+    #   status_handler(404) do
+    #     "Where did it go?"
+    #   end
+    #
+    # Before a block is called, any existing headers on the response will be
+    # cleared.  So if you want to be sure the headers are set even in your block,
+    # you need to reset them in the block.
+    module StatusHandler
+      def self.configure(app)
+        app.opts[:status_handler] ||= {}
+      end
+
+      module ClassMethods
+        # Install the given block as a status handler for the given HTTP response code.
+        def status_handler(code, &block)
+          opts[:status_handler][code] = block
+        end
+
+        # Freeze the hash of status handlers so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:status_handler].freeze
+          super
+        end
+      end
+
+      module InstanceMethods
+        # If routing returns a response we have a handler for, call that handler.
+        def call
+          result = super
+
+          if (block = opts[:status_handler][result[0]]) && (v = result[2]).is_a?(Array) && v.empty?
+            @_response.headers.clear
+            super(&block)
+          else
+            result
+          end
+        end
+      end
+    end
+
+    register_plugin(:status_handler, StatusHandler)
+  end
+end

data/lib/roda/plugins/websockets.rb

@@ -0,0 +1,103 @@
+require 'faye/websocket'
+
+class Roda
+  module RodaPlugins
+    # The websocket plugin adds integration support for websockets.
+    # Currently, only 'faye-websocket' is supported, so eventmachine
+    # is required for websockets.  See the
+    # {faye-websocket documentation}[https://github.com/faye/faye-websocket-ruby] 
+    # for details on the faye-websocket API. Note that faye-websocket
+    # is only supported on ruby 1.9.3+, so the websockets plugin only works
+    # on ruby 1.9.3+.
+    #
+    # Here's a simplified example for a basic multi-user,
+    # multi-room chat server, where a message from any user in a room
+    # is sent to all other users in the same room, using a websocket
+    # per room:
+    #
+    #   plugin :websockets, :adapter=>:thin, :opts=>{:ping=>45}
+    #
+    #   MUTEX = Mutex.new
+    #   ROOMS = {}
+    #
+    #   def sync
+    #     MUTEX.synchronize{yield}
+    #   end
+    #
+    #   route do |r|
+    #     r.get "room/:d" do |room_id|
+    #       room = sync{ROOMS[room_id] ||= []}
+    #
+    #       r.websocket do |ws|
+    #         # Routing block taken if request is a websocket request,
+    #         # yields a Faye::WebSocket instance
+    #
+    #         ws.on(:message) do |event|
+    #           sync{room.dup}.each{|user| user.send(event.data)}
+    #         end
+    #
+    #         ws.on(:close) do |event|
+    #           sync{room.delete(ws)}
+    #           sync{room.dup}.each{|user| user.send("Someone left")}
+    #         end
+    #
+    #         sync{room.dup}.each{|user| user.send("Someone joined")}
+    #         sync{room.push(ws)}
+    #       end
+    #
+    #       # If the request is not a websocket request, execution
+    #       # continues, similar to how routing in general works.
+    #       view 'room'
+    #     end
+    #   end
+    module Websockets
+      WebSocket = ::Faye::WebSocket
+      OPTS = {}.freeze
+
+      # Add default opions used for websockets.  These options are
+      # passed to Faye:WebSocket.new, except that the following
+      # options are handled separately.
+      #
+      # :adapter :: Calls Faye::WebSocket.load adapter with the given
+      #             value, used to set the adapter to load, if Faye
+      #             requires an adapter to work with the webserver.
+      #             Possible options: :thin, :rainbows, :goliath
+      #
+      # See RequestMethods#websocket for additional supported options.
+      def self.configure(app, opts=OPTS)
+        opts = app.opts[:websockets_opts] = (app.opts[:websockets_opts] || {}).merge(opts || {})
+        if adapter = opts.delete(:adapter)
+          WebSocket.load_adapter(adapter.to_s)
+        end
+        opts.freeze
+      end
+
+      module RequestMethods
+        # True if this request is a websocket request, false otherwise.
+        def websocket?
+          WebSocket.websocket?(env)
+        end
+
+        # If the request is a websocket request, yield a websocket to the
+        # block, and return the appropriate rack response after the block
+        # returns.  +opts+ is an options hash used when creating the
+        # websocket, except the following options are handled specially:
+        #
+        # :protocols :: Set the protocols to accept, should be an array
+        #               of strings.
+        def websocket(opts=OPTS)
+          if websocket?
+            always do
+              opts = Hash[roda_class.opts[:websockets_opts]].merge!(opts)
+              ws = WebSocket.new(env, opts.delete(:protocols), opts)
+              yield ws
+              halt ws.rack_response
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:websockets, Websockets)
+  end
+end

data/lib/roda/version.rb

@@ -4,7 +4,7 @@ class Roda
   RodaMajorVersion = 2
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 3
+  RodaMinorVersion = 4
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/spec/freeze_spec.rb

@@ -6,20 +6,20 @@ describe "Roda.freeze" do
   end
 
   it "should make opts not be modifiable after calling finalize!" do
-    proc{app.opts[:foo] = 'bar'}.must_raise FrozenError
+    proc{app.opts[:foo] = 'bar'}.must_raise
   end
 
   it "should make use and route raise errors" do
-    proc{app.use Class.new}.must_raise FrozenError
-    proc{app.route{}}.must_raise FrozenError
+    proc{app.use Class.new}.must_raise
+    proc{app.route{}}.must_raise
   end
 
   it "should make plugin raise errors" do
-    proc{app.plugin Module.new}.must_raise Roda::RodaError
+    proc{app.plugin Module.new}.must_raise
   end
 
   it "should make subclassing raise errors" do
-    proc{Class.new(app)}.must_raise Roda::RodaError
+    proc{Class.new(app)}.must_raise
   end
 
   it "should freeze app" do

data/spec/integration_spec.rb

@@ -176,8 +176,7 @@ describe "integration" do
   it "should have app return the rack application to call" do
     app(:bare){}.app.must_equal nil
     app.route{|r|}
-    # Work around minitest bug
-    assert_kind_of Proc, app.app
+    app.app.must_be_kind_of(Proc)
     c = Class.new{def initialize(app) @app = app end; def call(env) @app.call(env) end} 
     app.use c
     app.app.must_be_kind_of(c)

data/spec/plugin/assets_spec.rb

@@ -30,7 +30,9 @@ if run_tests
           :js => { :head => ['app.js'] },
           :path => 'spec/assets',
           :public => 'spec',
-          :css_opts => {:cache=>false}
+          :css_opts => {:cache=>false},
+          :css_compressor => :none,
+          :js_compressor => :none
 
         route do |r|
           r.assets
@@ -51,6 +53,10 @@ if run_tests
       FileUtils.rm_r('spec/public') if File.directory?('spec/public')
     end
 
+    def gunzip(body)
+      Zlib::GzipReader.wrap(StringIO.new(body), &:read)
+    end
+
     it 'assets_opts should use correct paths given options' do
       fpaths = [:js_path, :css_path, :compiled_js_path, :compiled_css_path]
       rpaths = [:js_prefix, :css_prefix, :compiled_js_prefix, :compiled_css_prefix]
@@ -224,6 +230,25 @@ if run_tests
       js.must_include('console.log')
     end
 
+    it 'should handle compressing using different libraries' do
+      try_compressor = proc do |css, js|
+        app.plugin :assets, :css_compressor=>css, :js_compressor=>js
+        begin
+          app.compile_assets
+        rescue LoadError, Roda::RodaPlugins::Assets::CompressorNotFound
+          next
+        end
+        File.read("spec/assets/app.#{app.assets_opts[:compiled]['css']}.css").must_match(/color: ?blue/)
+        File.read("spec/assets/app.head.#{app.assets_opts[:compiled]['js.head']}.js").must_include('console.log')
+      end
+
+      try_compressor.call(nil, nil)
+      try_compressor.call(:yui, :yui)
+      try_compressor.call(:none, :closure)
+      try_compressor.call(:none, :uglifier)
+      try_compressor.call(:none, :minjs)
+    end
+
     it 'should handle compiling assets, linking to them, and accepting requests for them' do
       app.compile_assets
       html = body('/test')
@@ -238,6 +263,30 @@ if run_tests
       js.must_include('console.log')
     end
 
+    it 'should handle compiling assets, linking to them, and accepting requests for them when :gzip is set' do
+      app.plugin :assets, :gzip=>true
+      app.compile_assets
+      html = body('/test')
+      html.scan(/<link/).length.must_equal 1
+      html =~ %r{href="(/assets/app\.[a-f0-9]{40}\.css)"}
+      css_path = $1
+      html.scan(/<script/).length.must_equal 1
+      html =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
+      js_path = $1
+
+      css = body(css_path)
+      js = body(js_path)
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
+
+      css = gunzip(body(css_path, 'HTTP_ACCEPT_ENCODING'=>'deflate, gzip'))
+      js = gunzip(body(js_path, 'HTTP_ACCEPT_ENCODING'=>'deflate, gzip'))
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
+    end
+
     it 'should handle compiling assets, linking to them, and accepting requests for them when :add_script_name app option is used' do
       app.opts[:add_script_name] = true
       app.plugin :assets

data/spec/plugin/class_level_routing_spec.rb

@@ -159,6 +159,6 @@ describe "class_level_routing plugin" do
     status.must_equal 200
     status("/asdfa/asdf").must_equal 404
 
-    proc{app.on{}}.must_raise FrozenError
+    proc{app.on{}}.must_raise
   end
 end

data/spec/plugin/multi_route_spec.rb

@@ -87,7 +87,7 @@ describe "multi_route plugin" do
     status('/c').must_equal 404
     status('/c', 'REQUEST_METHOD'=>'POST').must_equal 404
 
-    proc{app.route("foo"){}}.must_raise FrozenError
+    proc{app.route("foo"){}}.must_raise
   end
 
   it "uses multi_route to dispatch to any named route" do

data/spec/plugin/multi_run_spec.rb

@@ -45,7 +45,7 @@ describe "multi_run plugin" do
     body("/b/a").must_equal 'b2'
     body.must_equal 'c'
 
-    proc{app.run "a", Class.new(Roda).class_eval{route{"a1"}; app}}.must_raise FrozenError
+    proc{app.run "a", Class.new(Roda).class_eval{route{"a1"}; app}}.must_raise
   end
 
   it "works when subclassing" do

data/spec/plugin/named_templates_spec.rb

@@ -52,7 +52,7 @@ describe "named_templates plugin" do
     app.freeze
     body.must_equal 'bar13-foo12-baz'
 
-    proc{app.template(:b){"a"}}.must_raise FrozenError
+    proc{app.template(:b){"a"}}.must_raise
   end
 
   it "works with the view_subdirs plugin" do

data/spec/plugin/path_rewriter_spec.rb

@@ -32,6 +32,6 @@ describe "path_rewriter plugin" do
     
     app.freeze
     body('/a').must_equal '/a:/b'
-    proc{app.rewrite_path '/a', '/b'}.must_raise FrozenError
+    proc{app.rewrite_path '/a', '/b'}.must_raise
   end
 end

data/spec/plugin/path_spec.rb

@@ -193,7 +193,7 @@ describe "path plugin" do
     b = proc{|x| x.to_s}
     @app.path(c, &b)
     # Work around minitest bug
-    assert_equal @app.path_block(c), b
+    app.path_block(c).must_equal b
   end
 
   it "Roda.path doesn't work with classes without blocks" do
@@ -207,7 +207,7 @@ describe "path plugin" do
 
   it "Roda.path doesn't work after freezing the app" do
     app.freeze
-    proc{app.path(Class.new){|obj| ''}}.must_raise FrozenError
+    proc{app.path(Class.new){|obj| ''}}.must_raise
   end
 end
 

data/spec/plugin/status_handler_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "status_handler plugin" do
+  it "executes on no arguments" do
+    app(:bare) do
+      plugin :status_handler
+
+      status_handler(404) do
+        "not found"
+      end
+
+      route do |r|
+        r.on "a" do
+          "found"
+        end
+      end
+    end
+
+    body.must_equal 'not found'
+    status.must_equal 404
+    body("/a").must_equal 'found'
+    status("/a").must_equal 200
+  end
+
+  it "allows overriding status inside status_handler" do
+    app(:bare) do
+      plugin :status_handler
+
+      status_handler(404) do
+        response.status = 403
+        "not found"
+      end
+
+      route do |r|
+      end
+    end
+
+    status.must_equal 403
+  end
+
+  it "calculates correct Content-Length" do
+    app(:bare) do
+      plugin :status_handler
+
+      status_handler(404) do
+        "a"
+      end
+
+      route{}
+    end
+
+    header('Content-Length').must_equal "1"
+  end
+
+  it "clears existing headers" do
+    app(:bare) do
+      plugin :status_handler
+
+      status_handler(404) do
+        "a"
+      end
+
+      route do |r|
+        response['Content-Type'] = 'text/pdf'
+        response['Foo'] = 'bar'
+        nil
+      end
+    end
+
+    header('Content-Type').must_equal 'text/html'
+    header('Foo').must_equal nil
+  end
+
+  it "does not modify behavior if status_handler is not called" do
+    app(:status_handler) do |r|
+      r.on "a" do
+        "found"
+      end
+    end
+
+    body.must_equal ''
+    body("/a").must_equal 'found'
+  end
+
+  it "does not modify behavior if body is not an array" do
+    app(:bare) do
+      plugin :status_handler
+
+      status_handler(404) do
+        "not found"
+      end
+
+      o = Object.new
+      def o.each; end
+      route do |r|
+        r.halt [404, {}, o]
+      end
+    end
+
+    body.must_equal ''
+  end
+
+  it "does not modify behavior if body is not an empty array" do
+    app(:bare) do
+      plugin :status_handler
+
+      status_handler(404) do
+        "not found"
+      end
+
+      route do |r|
+        response.status = 404
+        response.write 'a'
+      end
+    end
+
+    body.must_equal 'a'
+  end
+
+  it "does not allow further status handlers to be added after freezing" do
+    app(:bare) do
+      plugin :status_handler
+
+      status_handler(404) do
+        "not found"
+      end
+
+      route{}
+    end
+
+    app.freeze
+
+    body.must_equal 'not found'
+    status.must_equal 404
+
+    proc{app.status_handler(404) { "blah" }}.must_raise
+
+    body.must_equal 'not found'
+  end
+
+end

data/spec/plugin/websockets_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+if RUBY_VERSION >= '1.9.3'
+begin
+  lib = nil
+  for lib in %w'faye/websocket thin' do
+    require lib
+  end
+rescue LoadError
+  warn "#{lib} not installed, skipping websockets plugin test"  
+else
+describe "websockets plugin" do 
+  it "supports regular requests" do
+    app(:websockets) do |r|
+      r.websocket{}
+      "a"
+    end
+    body.must_equal 'a'
+  end
+end
+
+describe "websockets plugin" do 
+  before do
+    events = @events = []
+    app(:bare) do
+      plugin :websockets, :adapter=>:thin
+      route do |r|
+        r.websocket do |ws|
+          ws.on(:open) do |event|
+            events << 'open'
+          end
+          ws.on(:message) do |event|
+            events << event.data
+            ws.send(event.data.reverse)
+          end
+          ws.on(:close) do |event|
+            events << 'close'
+          end
+        end
+      end
+    end
+
+    @port = 9791
+    q = Queue.new
+    Thread.new do
+      Thin::Logging.silent = true
+      Rack::Handler.get('thin').run(app, :Port => @port) do |s|
+        @server = s
+        q.push nil
+      end
+    end
+    q.pop
+  end
+  after do
+    @server.stop
+  end
+
+  it "supports websocket requests" do
+    ws = Faye::WebSocket::Client.new("ws://localhost:#{@port}")
+    msg = nil
+    ws.on(:open){|event| msg = true}
+    t = Time.now
+    sleep 0.01 until msg || Time.now - t > 5
+    msg.must_equal true
+
+    msg = nil
+    ws.on(:message){|event| msg = event.data}
+    ws.send("hello")
+    t = Time.now
+    sleep 0.01 until msg || Time.now - t > 5
+    msg.must_equal 'olleh'
+
+    ws.close
+    t = Time.now
+    sleep 0.01 until @events == %w'open hello close' || Time.now - t > 5
+    @events.must_equal %w'open hello close'
+  end
+end
+end
+end

data/spec/plugin_spec.rb

@@ -48,7 +48,7 @@ describe "plugins" do
     end
 
     app(:bare) do
-      plugin c, "Foo "
+      plugin(c, "Foo ").must_equal nil
 
       route do |r|
         r.hello do

data/spec/spec_helper.rb

@@ -24,9 +24,6 @@ require "stringio"
 gem 'minitest'
 require "minitest/autorun"
 
-# Work around minitest issue requiring specific exception class
-FrozenError = RUBY_VERSION >= '1.9' ? RuntimeError : TypeError
-
 #def (Roda::RodaPlugins).warn(s); end
 
 class Minitest::Spec

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-13 00:00:00.000000000 Z
+date: 2015-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.6.1
+        version: 5.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.6.1
+        version: 5.7.0
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -140,6 +140,7 @@ extra_rdoc_files:
 - doc/release_notes/2.1.0.txt
 - doc/release_notes/2.2.0.txt
 - doc/release_notes/2.3.0.txt
+- doc/release_notes/2.4.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -154,6 +155,7 @@ files:
 - doc/release_notes/2.1.0.txt
 - doc/release_notes/2.2.0.txt
 - doc/release_notes/2.3.0.txt
+- doc/release_notes/2.4.0.txt
 - lib/roda.rb
 - lib/roda/plugins/_erubis_escaping.rb
 - lib/roda/plugins/all_verbs.rb
@@ -210,11 +212,13 @@ files:
 - lib/roda/plugins/slash_path_empty.rb
 - lib/roda/plugins/static.rb
 - lib/roda/plugins/static_path_info.rb
+- lib/roda/plugins/status_handler.rb
 - lib/roda/plugins/streaming.rb
 - lib/roda/plugins/symbol_matchers.rb
 - lib/roda/plugins/symbol_views.rb
 - lib/roda/plugins/view_options.rb
 - lib/roda/plugins/view_subdirs.rb
+- lib/roda/plugins/websockets.rb
 - lib/roda/version.rb
 - spec/assets/css/app.scss
 - spec/assets/css/no_access.css
@@ -280,10 +284,12 @@ files:
 - spec/plugin/sinatra_helpers_spec.rb
 - spec/plugin/slash_path_empty_spec.rb
 - spec/plugin/static_spec.rb
+- spec/plugin/status_handler_spec.rb
 - spec/plugin/streaming_spec.rb
 - spec/plugin/symbol_matchers_spec.rb
 - spec/plugin/symbol_views_spec.rb
 - spec/plugin/view_options_spec.rb
+- spec/plugin/websockets_spec.rb
 - spec/plugin_spec.rb
 - spec/redirect_spec.rb
 - spec/request_spec.rb