webmachine 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76f443d8e22ccb13b371b7aedfd2d02204653d89
-  data.tar.gz: d2b04ca2adc316e74903f02696bd55ae6bc1a900
+  metadata.gz: 9309a2f44549ae1c912684fcdc7f60d31404bbf3
+  data.tar.gz: 9531f40a275a2bf5e2bda7ed4816ff2463e4c234
 SHA512:
-  metadata.gz: ea9cdbfdf582062d7c5eea818816482f99bb75e915625b62263b62936c79b5126c5f046cab13bc72524caf97c1e0cf031551e445b0f10d9d0b0714377e556e7f
-  data.tar.gz: 26575bcdc2c324d42c2af0cb1029654a4c4c92003a17738c12036f55908c97d94f8a461e79f24df3700040c480937568a03f55f9c2c21c1dd40ca1fae2cc980a
+  metadata.gz: 5f5e9419fadcf121f8e0e80ec41417bd5dd9f096933aaf06793dd18d9d6ac6f5e2d028f56e0bc105ff5a87f9b2aa7ebc72e1d61424cc8c88d76e7cb92b9655a0
+  data.tar.gz: d79442bba70911a7b704a26135a2fcadc4dbc1f0a0e12197d1ddbfb055498c54e164e972b03479d7428839ceef15bf32faa070b7ace58fc4b76704bdc5ec7bf8

data/.gitignore

@@ -29,4 +29,3 @@ Gemfile.lock
 .SyncID
 .SyncIgnore
 vendor
-

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ### HEAD
 
+### 1.5.0 September 8, 2017
+* Removed Fixnum/Integer deprecation warnings in Ruby 2.4
+* Fixed multiple cookie setting code
+* Added support for named captures
+* Improved logic for determining which errors are 'rescuable' by Webmachine,
+  and which are 'unhandlable'.
+
 ### 1.4.0 March 20, 2015
 
 * Added RackMapped adapter which allows Webmachine apps to be mounted

data/Gemfile

@@ -3,15 +3,15 @@ source 'https://rubygems.org'
 gemspec
 
 group :development do
-  gem "yard"
-  gem "rake"
+  gem "yard", "~> 0.9"
+  gem "rake", "~> 12.0"
 end
 
 group :test do
-  gem "rspec", '~> 3.0.0'
-  gem "rspec-its"
-  gem "rack"
-  gem "rack-test"
+  gem "rspec", "~> 3.0", ">= 3.6.0"
+  gem "rspec-its", "~> 1.2"
+  gem "rack", "~> 2.0"
+  gem "rack-test", "~> 0.7"
 end
 
 group :webservers do
@@ -21,12 +21,12 @@ group :webservers do
 end
 
 group :guard do
-  gem 'guard-rspec'
+  gem 'guard-rspec', '~> 4.7'
   case RbConfig::CONFIG['host_os']
   when /darwin/
-    gem 'rb-fsevent'
+    gem 'rb-fsevent', '~> 0.10'
     # gem 'growl_notify'
-    gem 'growl'
+    gem 'growl', '~> 1.0'
   when /linux/
     gem 'rb-inotify'
     gem 'libnotify'
@@ -35,7 +35,7 @@ end
 
 group :docs do
   platform :mri_19, :mri_20 do
-    gem 'redcarpet'
+    gem 'redcarpet', '~> 3.4'
   end
 end
 

data/README.md

@@ -1,4 +1,4 @@
-# webmachine for Ruby [![Build Status](https://travis-ci.org/seancribbs/webmachine-ruby.svg)](https://travis-ci.org/seancribbs/webmachine-ruby)
+# webmachine for Ruby [![Build Status](https://travis-ci.org/webmachine/webmachine-ruby.svg)](https://travis-ci.org/webmachine/webmachine-ruby)
 
 webmachine-ruby is a port of
 [Webmachine](https://github.com/basho/webmachine), which is written in
@@ -163,7 +163,7 @@ the "visual debugger". Learn how to configure it [here][visual-debugger].
 
 ## Related libraries
 
-* [irwebmachine](https://github.com/robgleeson/irwebmachine) - IRB/Pry debugging of Webmachine applications
+* [irwebmachine](https://github.com/generalassembly/irwebmachine) - IRB/Pry debugging of Webmachine applications
 * [webmachine-test](https://github.com/bernd/webmachine-test) - Helpers for testing Webmachine applications
 * [webmachine-linking](https://github.com/petejohanson/webmachine-linking) - Helpers for linking between Resources, and Web Linking
 * [webmachine-sprockets](https://github.com/lgierth/webmachine-sprockets) - Integration with Sprockets assets packaging system

data/RELEASING.md

@@ -0,0 +1,21 @@
+1. Open `CHANGELOG.md` and summarize the changes made since the last release (hopefully better than the individual commit messages). The history can be grabbed with a simple git command (assuming the last version was 1.3.0:
+
+        $ git log --pretty=format:'  * %s' v1.3.0..HEAD
+
+2. Edit the version in `lib/webmachine/version.rb` according to semantic versioning rules.
+3. Commit both files.
+
+        $ git add CHANGELOG.md lib/webmachine/version.rb
+        $ git commit -m "chore(release): version $(ruby -r ./lib/webmachine/version.rb -e "puts Webmachine::VERSION")" && git push
+
+4. Release the gem.
+
+        $ bundle exec rake release
+
+5. If this is a new major or minor release, push a new stable branch, otherwise merge the commit into the stable branch (or master, depending on where you made the commit).
+
+        $ git push origin HEAD:1.3-stable
+        # or
+        $ git checkout 1.3-stable; git merge master; git push origin; git checkout master
+
+6. YOU'RE DONE!

data/Rakefile

@@ -1,5 +1,4 @@
-require 'rubygems'
-require 'rubygems/package_task'
+require "bundler/gem_tasks"
 
 begin
   require 'yard'
@@ -11,26 +10,12 @@ begin
 rescue LoadError
 end
 
-def gemspec
-  $webmachine_gemspec ||= Gem::Specification.load("webmachine.gemspec")
+desc "Validate the gemspec file."
+task :validate_gemspec do
+  Gem::Specification.load("webmachine.gemspec").validate
 end
 
-Gem::PackageTask.new(gemspec) do |pkg|
-  pkg.need_zip = false
-  pkg.need_tar = false
-end
-
-task :gem => :gemspec
-
-desc %{Validate the gemspec file.}
-task :gemspec do
-  gemspec.validate
-end
-
-desc %{Release the gem to RubyGems.org}
-task :release => :gem do
-  system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
-end
+task :build => :validate_gemspec
 
 desc "Cleans up white space in source files"
 task :clean_whitespace do

data/bethtemp

@@ -0,0 +1,3 @@
+  * use Integer instead of Fixnum (removes deprecation warnings in Ruby 2.4)
+  * Fixing multiple cookie setting code
+  * Added support for named captures

data/documentation/examples.md

@@ -137,6 +137,8 @@ class OrderResource < Webmachine::Resource
     [["application/json", :from_json]]
   end
 
+  # Note that returning falsey will NOT result in a 404 for PUT requests.
+  # See note below.
   def resource_exists?
     order
   end
@@ -166,8 +168,10 @@ class OrderResource < Webmachine::Resource
 end
 ```
 
+If you wish to disallow PUT to a non-existent resource, read more [here](https://github.com/webmachine/webmachine-ruby/issues/207#issuecomment-132604379).
+
 # PATCH
-* Webmachine does not currently support PATCH requests. See https://github.com/seancribbs/webmachine-ruby/issues/109 for more information and https://github.com/bethesque/pact_broker/blob/2918814e70bbda14df68598a6a41502a5eac4308/lib/pact_broker/api/resources/pacticipant.rb for a dirty hack to make it work if you need to.
+* Webmachine does not currently support PATCH requests. See https://github.com/webmachine/webmachine-ruby/issues/109 for more information and https://github.com/bethesque/pact_broker/blob/2918814e70bbda14df68598a6a41502a5eac4308/lib/pact_broker/api/resources/pacticipant.rb for a dirty hack to make it work if you need to.
 
 # DELETE
 * Override `resource_exists?` and `delete_resource`
@@ -208,8 +212,7 @@ Thanks to [oestrich][oestrich] for putting together the original example. You ca
 [oestrich]: https://github.com/oestrich
 [source]: https://gist.github.com/oestrich/3638605
 
-<a name="callback-order">
+<a name="callback-order"></a>
 ## What order are the callbacks invoked in?
-</a>
 
 This question is actually irrelevant if you write your code in a "stateless" way using lazy initialization as the examples do above. As much as possible, think about exposing "facts" about your resource, not writing procedural code that needs to be called in a certain order. See [How it works](/documentation/how-it-works.md) for more information on how the Webmachine state machine works.

data/documentation/how-it-works.md

@@ -71,6 +71,6 @@ end
 * A collection resource (eg. /orders) should be implemented as a separate class to a single object resource (eg. /orders/1), as the routes represent different underlying objects with different "facts". For example, the orders _collection_ resource probably always exists (but may be empty), however the order with ID 1 may or may not exist.
 
 [callbacks]: https://github.com/seancribbs/webmachine-ruby/blob/master/lib/webmachine/resource/callbacks.rb
-[diagram]: http://webmachine.basho.com/images/http-headers-status-v3.png
+[diagram]: https://webmachine.github.io/images/http-headers-status-v3.png
 [flow]: https://github.com/seancribbs/webmachine-ruby/blob/master/lib/webmachine/decision/flow.rb
 [examples]: /documentation/examples.md

data/documentation/routes.md

@@ -20,6 +20,21 @@ App = Webmachine::Application.new do |app|
     # but will not provide any path_info
     add ["orders", :*], OrderResource
 
+    # Will map to any path that matches the given components and regular expression
+    # Any capture groups specified in the regex will be made available in
+    # request.path_info[:captures. In this case, you would get one or two
+    # values in :captures depending on whether your request looked like:
+    # /orders/1/cancel
+    # or
+    # /orders/1/cancel.json
+    add ["orders", :id, /([^.]*)\.?(.*)?/], OrderResource
+
+    # You can even use named captures with regular expressions. This will 
+    # automatically put the captures into path_info. In the below example,
+    # you would get :id from the symbol, along with :action and :format
+    # from the regex. :format in this case would be optional.
+    add ["orders", :id, /(?<action>)[^.]*)\.?(?<format>.*)?/], OrderResource
+
     # will map to any path
     add [:*], DefaultResource
   end
@@ -94,4 +109,4 @@ end
 request.path_info[:foo]
 => "bar"
 
-```
+```

data/lib/webmachine/adapters/reel.rb

@@ -1,6 +1,7 @@
 require 'webmachine/adapter'
 require 'webmachine/constants'
 require 'set'
+require 'celluloid/current'
 require 'reel'
 require 'webmachine/headers'
 require 'webmachine/request'

data/lib/webmachine/configuration.rb

@@ -5,7 +5,7 @@ module Webmachine
   # defaults will be filled in when {Webmachine::run} is called.
   # @attr [String] ip the interface to bind to, defaults to "0.0.0.0"
   #    (all interfaces)
-  # @attr [Fixnum] port the port to bind to, defaults to 8080
+  # @attr [Integer] port the port to bind to, defaults to 8080
   # @attr [Symbol] adapter the adapter to use, defaults to :WEBrick
   # @attr [Hash] adapter_options adapter-specific options, defaults to {}
   Configuration = Struct.new(:ip, :port, :adapter, :adapter_options)

data/lib/webmachine/decision/flow.rb

@@ -35,7 +35,7 @@ module Webmachine
       # Handles standard decisions where halting is allowed
       def decision_test(test, iftrue, iffalse)
         case test
-        when Fixnum # Allows callbacks to "halt" with a given response code
+        when Integer # Allows callbacks to "halt" with a given response code
           test
         when Falsey
           iffalse
@@ -77,7 +77,7 @@ module Webmachine
       # Content-MD5 valid?
       def b9a
         case valid = resource.validate_content_checksum
-        when Fixnum
+        when Integer
           valid
         when true
           :b9b
@@ -105,7 +105,7 @@ module Webmachine
         case result
         when true
           :b7
-        when Fixnum
+        when Integer
           result
         when String
           response.headers['WWW-Authenticate'] = result
@@ -280,7 +280,7 @@ module Webmachine
         when String, URI
           response.headers[LOCATION] = uri.to_s
           301
-        when Fixnum
+        when Integer
           uri
         else
           :p3
@@ -313,7 +313,7 @@ module Webmachine
         when String, URI
           response.headers[LOCATION] = uri.to_s
           301
-        when Fixnum
+        when Integer
           uri
         else
           :l5
@@ -342,7 +342,7 @@ module Webmachine
         when String, URI
           response.headers[LOCATION] = uri.to_s
           307
-        when Fixnum
+        when Integer
           uri
         else
           :m5
@@ -422,13 +422,13 @@ module Webmachine
             request.disp_path = new_uri.path
             response.headers[LOCATION] = new_uri.to_s
             result = accept_helper
-            return result if Fixnum === result
+            return result if Integer === result
           end
         else
           case result = resource.process_post
           when true
             encode_body_if_set
-          when Fixnum
+          when Integer
             return result
           else
             raise InvalidResource, t('process_post_invalid', :result => result.inspect)
@@ -456,7 +456,7 @@ module Webmachine
           409
         else
           res = accept_helper
-          (Fixnum === res) ? res : :p11
+          (Integer === res) ? res : :p11
         end
       end
 
@@ -473,7 +473,7 @@ module Webmachine
           content_type = metadata[CONTENT_TYPE]
           handler = resource.content_types_provided.find {|ct, _| content_type.type_matches?(MediaType.parse(ct)) }.last
           result = resource.send(handler)
-          if Fixnum === result
+          if Integer === result
             result
           else
             response.body = result
@@ -501,7 +501,7 @@ module Webmachine
           409
         else
           res = accept_helper
-          (Fixnum === res) ? res : :p11
+          (Integer === res) ? res : :p11
         end
       end
 

data/lib/webmachine/decision/fsm.rb

@@ -2,6 +2,7 @@
 require 'webmachine/trace'
 require 'webmachine/translation'
 require 'webmachine/constants'
+require 'webmachine/rescueable_exception'
 
 module Webmachine
   module Decision
@@ -29,7 +30,7 @@ module Webmachine
           trace_decision(state)
           result = handle_exceptions { send(state) }
           case result
-          when Fixnum # Response code
+          when Integer # Response code
             respond(result)
             break
           when Symbol # Next state
@@ -48,12 +49,12 @@ module Webmachine
 
       def handle_exceptions
         yield
+      rescue Webmachine::RescuableException => e
+        resource.handle_exception(e)
+        500
       rescue MalformedRequest => e
         Webmachine.render_error(400, request, response, :message => e.message)
         400
-      rescue => e
-        resource.handle_exception(e)
-        500
       end
 
       def respond(code, headers={})

data/lib/webmachine/decision/helpers.rb

@@ -95,7 +95,7 @@ module Webmachine
       # is a String or IO with known size.
       def body_is_fixed_length?
         response.body.respond_to?(:bytesize) &&
-          Fixnum === response.body.bytesize
+          Integer === response.body.bytesize
       end
     end # module Helpers
   end # module Decision

data/lib/webmachine/dispatcher/route.rb

@@ -103,7 +103,7 @@ module Webmachine
       # accumulating variable bindings.
       # @param [Array<String>] tokens the list of path segments
       # @param [Hash] bindings where path bindings will be stored
-      # @return [Fixnum, Array<Fixnum, Array>, false] either the depth
+      # @return [Integer, Array<Integer, Array>, false] either the depth
       #   that the path matched at, the depth and tokens matched by
       #   {MATCH_ALL}, or false if it didn't match.
       def bind(tokens, bindings)
@@ -119,6 +119,20 @@ module Webmachine
             return [depth, tokens]
           when tokens.empty?
             return false
+          when Regexp === spec.first
+            matches = spec.first.match URI.decode(tokens.first)
+            if matches
+              if spec.first.named_captures.empty?
+                bindings[:captures] = (bindings[:captures] || []) + matches.captures
+              else
+                spec.first.named_captures.reduce(bindings) do |bindings, (name, idxs)|
+                  bindings[name.to_sym] = matches.captures[idxs.first-1]
+                  bindings
+                end
+              end
+            else
+              return false
+            end
           when Symbol === spec.first
             bindings[spec.first] = URI.decode(tokens.first)
           when spec.first == tokens.first

data/lib/webmachine/errors.rb

@@ -9,7 +9,7 @@ module Webmachine
 
   # Renders a standard error message body for the response. The
   # standard messages are defined in localization files.
-  # @param [Fixnum] code the response status code
+  # @param [Integer] code the response status code
   # @param [Request] req the request object
   # @param [Response] req the response object
   # @param [Hash] options keys to override the defaults when rendering
@@ -39,6 +39,6 @@ module Webmachine
 
   # Raised when the client has submitted an invalid request, e.g. in
   # the case where a request header is improperly formed. Raising this
-  # exception will result in a 400 response.
+  # error will result in a 400 response.
   class MalformedRequest < Error; end
 end # module Webmachine

data/lib/webmachine/events.rb

@@ -55,9 +55,9 @@ module Webmachine
       # and publish it. Notice that events get sent even if an error occurs
       # in the passed-in block.
       #
-      # If an exception happens during an instrumentation the payload will
+      # If an error happens during an instrumentation the payload will
       # have a key `:exception` with an array of two elements as value:
-      # a string with the name of the exception class, and the exception
+      # a string with the name of the error class, and the error
       # message. (when using the default
       # [AS::Notifications](http://rubydoc.info/gems/as-notifications/AS/Notifications)
       # backend)

data/lib/webmachine/headers.rb

@@ -48,7 +48,7 @@ module Webmachine
 
     # Returns the value for the given key. If the key can't be found,
     # there are several options:
-    # With no other arguments, it will raise a KeyError exception;
+    # With no other arguments, it will raise a KeyError error;
     # if default is given, then that will be returned;
     # if the optional code block is specified, then that will be run and its
     # result returned.

data/lib/webmachine/rescueable_exception.rb

@@ -0,0 +1,62 @@
+module Webmachine::RescuableException
+  require_relative 'errors'
+  require 'set'
+
+  UNRESCUABLE_DEFAULTS =  [
+    Webmachine::MalformedRequest,
+    NoMemoryError, SystemExit, SignalException
+  ].freeze
+
+  UNRESCUABLE = Set.new UNRESCUABLE_DEFAULTS.dup
+  private_constant :UNRESCUABLE
+
+  def self.===(e)
+    case e
+    when *UNRESCUABLE then false
+    else true
+    end
+  end
+
+  #
+  # Remove modifications to Webmachine::RescuableException.
+  # Restores default list of unrescue-able exceptions.
+  #
+  # @return [nil]
+  #
+  def self.default!
+    UNRESCUABLE.replace Set.new(UNRESCUABLE_DEFAULTS.dup)
+    nil
+  end
+
+  #
+  # @return [Array<Exception>]
+  #   Returns an Array of exceptions that will not be
+  #   rescued by {Webmachine::Resource#handle_exception}.
+  #
+  def self.UNRESCUABLEs
+    UNRESCUABLE.to_a
+  end
+
+  #
+  # Add a variable number of exceptions that should be rescued by
+  # {Webmachine::Resource#handle_exception}. See {UNRESCUABLE_DEFAULTS}
+  # for a list of exceptions that are not caught by default.
+  #
+  # @param (see #remove)
+  #
+  def self.add(*exceptions)
+    exceptions.each{|e| UNRESCUABLE.delete(e)}
+  end
+
+  #
+  # Remove a variable number of exceptions from being rescued by
+  # {Webmachine::Resource#handle_exception}. See {UNRESCUABLE_DEFAULTS}
+  # for a list of exceptions that are not caught by default.
+  #
+  # @param [Exception] *exceptions
+  #   A subclass of Exception.
+  #
+  def self.remove(*exceptions)
+    exceptions.each{|e| UNRESCUABLE.add(e)}
+  end
+end

data/lib/webmachine/resource/callbacks.rb

@@ -103,7 +103,7 @@ module Webmachine
       # If the entity length on PUT or POST is invalid, this should
       # return false, which will result in a '413 Request Entity Too
       # Large' response. Defaults to true.
-      # @param [Fixnum] length the size of the request body (entity)
+      # @param [Integer] length the size of the request body (entity)
       # @return [true,false] Whether the body is a valid length (not too
       #    large)
       # @api callback
@@ -192,7 +192,7 @@ module Webmachine
 
       # If post_is_create? returns false, then this will be called to
       # process any POST request. If it succeeds, it should return true.
-      # @return [true,false,Fixnum] Whether the POST was successfully
+      # @return [true,false,Integer] Whether the POST was successfully
       #    processed, or an alternate response code
       # @api callback
       def process_post
@@ -363,11 +363,11 @@ module Webmachine
       def finish_request; end
 
       #
-      # This method is called when an exception is raised within a subclass of
+      # This method is called when an error is raised within a subclass of
       # {Webmachine::Resource}.
       #
-      # @param [Exception] e
-      #   The exception.
+      # @param [StandardError] e
+      #   The error.
       #
       # @return [void]
       #

data/lib/webmachine/response.rb

@@ -4,7 +4,7 @@ module Webmachine
     # @return [HeaderHash] Response headers that will be sent to the client
     attr_reader :headers
 
-    # @return [Fixnum] The HTTP status code of the response
+    # @return [Integer] The HTTP status code of the response
     attr_accessor :code
 
     # @return [String, #each] The response body
@@ -48,11 +48,9 @@ module Webmachine
       cookie = Webmachine::Cookie.new(name, value, attributes).to_s
       case headers['Set-Cookie']
       when nil
-        headers['Set-Cookie'] = cookie
-      when String
-        headers['Set-Cookie'] = [headers['Set-Cookie'], cookie]
+        headers['Set-Cookie'] = [cookie]
       when Array
-        headers['Set-Cookie'] = headers['Set-Cookie'] + cookie
+        headers['Set-Cookie'] << cookie
       end
     end
 

data/lib/webmachine/spec/adapter_lint.rb

@@ -1,28 +1,42 @@
 require "webmachine/spec/test_resource"
 require "net/http"
 
+ADDRESS = "127.0.0.1"
+
 shared_examples_for :adapter_lint do
-  attr_accessor :client
+  attr_reader :client
+
+  class TestApplicationNotResponsive < Timeout::Error; end
 
-  let(:address) { "127.0.0.1" }
-  let(:port) { s = TCPServer.new(address, 0); p = s.addr[1]; s.close; p }
+  def find_free_port
+    temp_server = TCPServer.new(ADDRESS, 0)
+    port = temp_server.addr[1]
+    temp_server.close # only frees Ruby resource, socket is in TIME_WAIT at OS level
+                      # so we can't have our adapter use it too quickly
 
-  let(:application) do
-    application = Webmachine::Application.new
-    application.dispatcher.add_route ["test"], Test::Resource
+    sleep(0.1)        # 'Wait' for temp_server to *really* close, not just TIME_WAIT
+    port
+  end
 
-    application.configure do |c|
-      c.ip = address
-      c.port = port
+  def create_test_application(port)
+    Webmachine::Application.new.tap do |application|
+      application.dispatcher.add_route ["test"], Test::Resource
+
+      application.configure do |c|
+        c.ip   = ADDRESS
+        c.port = port
+      end
     end
+  end
 
-    application
+  def run_application(adapter_class, application)
+    adapter = adapter_class.new(application)
+    Thread.abort_on_exception = true
+    Thread.new { adapter.run }
   end
 
-  let(:client) do
-    client = Net::HTTP.new(application.configuration.ip, port)
-    # Wait until the server is responsive
-    timeout(5) do
+  def wait_until_server_responds_to(client)
+    Timeout.timeout(5, TestApplicationNotResponsive) do
       begin
         client.start
       rescue Errno::ECONNREFUSED
@@ -30,19 +44,21 @@ shared_examples_for :adapter_lint do
         retry
       end
     end
-    client
   end
 
-  before do
-    @adapter = described_class.new(application)
+  before(:all) do
+    @port = find_free_port
+    application = create_test_application(@port)
 
-    Thread.abort_on_exception = true
-    @server_thread = Thread.new { @adapter.run }
-    sleep(0.01)
+    adapter_class = described_class
+    @server_thread = run_application(adapter_class, application)
+
+    @client = Net::HTTP.new(application.configuration.ip, @port)
+    wait_until_server_responds_to(client)
   end
 
-  after do
-    client.finish
+  after(:all) do
+    @client.finish
     @server_thread.kill
   end
 
@@ -50,7 +66,7 @@ shared_examples_for :adapter_lint do
     request = Net::HTTP::Get.new("/test")
     request["Accept"] = "test/response.request_uri"
     response = client.request(request)
-    expect(response.body).to eq("http://#{address}:#{port}/test")
+    expect(response.body).to eq("http://#{ADDRESS}:#{@port}/test")
   end
 
   # context do

data/lib/webmachine/streaming/io_encoder.rb

@@ -39,7 +39,7 @@ module Webmachine
       # Returns the length of the IO stream, if known. Returns nil if
       # the stream uses an encoder or charsetter that might modify the
       # length of the stream, or the stream size is unknown.
-      # @return [Fixnum] the size, in bytes, of the underlying IO, or
+      # @return [Integer] the size, in bytes, of the underlying IO, or
       #   nil if unsupported
       def size
         if is_unencoded?

data/lib/webmachine/version.rb

@@ -1,6 +1,6 @@
 module Webmachine
   # Library version
-  VERSION = "1.4.0".freeze
+  VERSION = "1.5.0".freeze
 
   # String for use in "Server" HTTP response header, which includes
   # the {VERSION}.

data/spec/spec_helper.rb

@@ -18,6 +18,14 @@ RSpec.configure do |config|
     config.order = :random
   end
 
+  config.before :each do
+    Webmachine::RescuableException.remove(RSpec::Mocks::MockExpectationError)
+  end
+
+  config.after :each do
+    Webmachine::RescuableException.default!
+  end
+
   config.before(:suite) do
     options = {
       :Logger => NullLogger.new(STDERR),

data/spec/webmachine/adapters/reel_spec.rb

@@ -56,7 +56,7 @@ describe Webmachine::Adapters::Reel do
   def reel_server(adptr = adapter)
     thread = Thread.new { adptr.run }
     begin
-      timeout(5) do
+      Timeout.timeout(5) do
         begin
           sock = TCPSocket.new(adptr.application.configuration.ip, adptr.application.configuration.port)
           begin

data/spec/webmachine/decision/conneg_spec.rb

@@ -41,7 +41,7 @@ describe Webmachine::Decision::Conneg do
 
     end
 
-    it "should raise an exception when a media-type is improperly formatted" do
+    it "should raise an error when a media-type is improperly formatted" do
       expect {
         subject.choose_media_type(["text/html", "application/xml"],
                                   "bah;")

data/spec/webmachine/decision/flow_spec.rb

@@ -1100,7 +1100,7 @@ describe Webmachine::Decision::Flow do
     end
   end
 
-  describe "On exception" do
+  describe "On error" do
     context "handle_exception is inherited." do
       let :resource do
         resource_with do

data/spec/webmachine/decision/fsm_spec.rb

@@ -5,15 +5,58 @@ describe Webmachine::Decision::FSM do
 
   subject { described_class.new(resource, request, response) }
 
+  let(:run_with_exception) do
+    begin
+      subject.run
+    rescue Exception
+    end
+  end
+
   describe 'handling of exceptions from decision methods' do
-    let(:exception) { RuntimeError.new }
+    let(:UNRESCUABLE_exceptions) do
+      Webmachine::RescuableException::UNRESCUABLE
+    end
+
+    describe "rescueable exceptions" do
+      it 'does rescue Exception' do
+        allow(subject).to receive(Webmachine::Decision::Flow::START) { raise(Exception) }
+        expect(resource).to receive(:handle_exception).with instance_of(Exception)
+        expect { subject.run }.to_not raise_error
+      end
+
+      it 'does rescue a failed require' do
+        allow(subject).to receive(Webmachine::Decision::Flow::START) { require 'laterequire' }
+        expect(resource).to receive(:handle_exception).with instance_of(LoadError)
+        expect { subject.run }.to_not raise_error
+      end
+    end
+
+    describe "UNRESCUABLE exceptions"  do
+      shared_examples "UNRESCUABLE" do |e|
+        specify "#{e} is not rescued" do
+          allow(subject).to receive(Webmachine::Decision::Flow::START) {raise(e)}
+          expect(resource).to_not receive(:handle_exception).with instance_of(e)
+          expect { subject.run }.to raise_error(e)
+        end
+      end
+      eary = Webmachine::RescuableException::UNRESCUABLE_DEFAULTS - [
+        Webmachine::MalformedRequest, # Webmachine rescues by default, so it won't re-raise.
+        SignalException # Requires raise in form 'raise SignalException, "SIGSOMESIGNAL"'.
+                        # Haven't found a good no-op signal to use here.
+      ]
+      eary.each{|e| include_examples "UNRESCUABLE", e}
+    end
+  end
+
+  describe 'handling of errors from decision methods' do
+    let(:error) { RuntimeError.new }
 
     before do
-      allow(subject).to receive(Webmachine::Decision::Flow::START) { raise exception }
+      allow(subject).to receive(Webmachine::Decision::Flow::START) { raise error }
     end
 
     it 'calls resource.handle_exception' do
-      expect(resource).to receive(:handle_exception).with(exception)
+      expect(resource).to receive(:handle_exception).with(error)
       subject.run
     end
 
@@ -23,12 +66,12 @@ describe Webmachine::Decision::FSM do
     end
   end
 
-  describe 'handling of exceptions from resource.handle_exception' do
-    let(:exception) { RuntimeError.new('an error message') }
+  describe 'handling of errors from resource.handle_exception' do
+    let(:error) { RuntimeError.new('an error message') }
 
     before do
       allow(subject).to receive(Webmachine::Decision::Flow::START) { raise }
-      allow(resource).to receive(:handle_exception) { raise exception }
+      allow(resource).to receive(:handle_exception) { raise error }
     end
 
     it 'does not call resource.handle_exception again' do
@@ -44,20 +87,39 @@ describe Webmachine::Decision::FSM do
     it 'renders an error' do
       expect(Webmachine).
         to receive(:render_error).
-        with(500, request, response, { :message => exception.message })
+        with(500, request, response, { :message => error.message })
       subject.run
     end
   end
 
   describe 'handling of exceptions from resource.finish_request' do
-    let(:exception) { RuntimeError.new }
+    let(:exception) { Class.new(Exception).new }
 
     before do
+      Webmachine::RescuableException.remove(exception)
       allow(resource).to receive(:finish_request) { raise exception }
     end
 
+    it 'does not call resource.handle_exception' do
+      expect(resource).to_not receive(:handle_exception)
+      run_with_exception
+    end
+
+    it 'does not call resource.finish_request again' do
+      expect(resource).to_not receive(:finish_request).once { raise }
+      run_with_exception
+    end
+  end
+
+  describe 'handling of errors from resource.finish_request' do
+    let(:error) { RuntimeError.new }
+
+    before do
+      allow(resource).to receive(:finish_request) { raise error }
+    end
+
     it 'calls resource.handle_exception' do
-      expect(resource).to receive(:handle_exception).with(exception)
+      expect(resource).to receive(:handle_exception).with(error)
       subject.run
     end
 

data/spec/webmachine/dispatcher/route_spec.rb

@@ -180,7 +180,6 @@ describe Webmachine::Dispatcher::Route do
         end
       end
     end
-
     context "on a deep path" do
       subject { described_class.new(%w{foo bar baz}, resource) }
       let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz") }
@@ -205,6 +204,29 @@ describe Webmachine::Dispatcher::Route do
           expect(request.path_info).to eq({:id => "bar"})
         end
       end
+      context "with regex" do
+        subject { described_class.new([/foo/, /(.*)/, 'baz'], resource) }
+
+        it "should assign the captures path variables" do
+          expect(request.path_info).to eq({:captures => ["bar"]})
+        end
+      end
+      context "with multi-capture regex" do
+        subject { described_class.new([/foo/, /(.*)/, /baz\.(.*)/], resource) }
+        let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz.json") }
+
+        it "should assign the captures path variables" do
+          expect(request.path_info).to eq({:captures => ["bar", "json"]})
+        end
+      end
+      context "with named capture regex" do
+        subject { described_class.new(['foo', :bar, /(?<baz>[^.]+)\.(?<format>.*)/], resource) }
+        let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz.json") }
+
+        it "should assign the captures path variables" do
+          expect(request.path_info).to eq({bar: 'bar', baz: 'baz', format: "json"})
+        end
+      end
 
       context "with a splat" do
         subject { described_class.new(['foo', :*], resource) }

data/spec/webmachine/dispatcher_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe Webmachine::Dispatcher do
   let(:dispatcher) { Webmachine.application.dispatcher }
   let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
+  let(:request2) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/hello/bob.html"), Webmachine::Headers["accept" => "*/*"], "") }
   let(:response) { Webmachine::Response.new }
   let(:resource) do
     Class.new(Webmachine::Resource) do
@@ -14,6 +15,14 @@ describe Webmachine::Dispatcher do
       def to_html; "goodbye, cruel world"; end
     end
   end
+  let(:resource3) do
+    Class.new(Webmachine::Resource) do
+      def to_html
+        name, format = request.path_info[:captures]
+        "Hello #{name} with #{format}"
+      end
+    end
+  end
   let(:fsm){ double }
 
   before { dispatcher.reset }
@@ -44,6 +53,12 @@ describe Webmachine::Dispatcher do
     expect(fsm).to receive(:run)
     dispatcher.dispatch(request, response)
   end
+  it "should handle regex path segments in route definition" do
+    dispatcher.add_route ["hello", /(.*)\.(.*)/], resource3
+    expect(Webmachine::Decision::FSM).to receive(:new).with(instance_of(resource3), request2, response).and_return(fsm)
+    expect(fsm).to receive(:run)
+    dispatcher.dispatch(request2, response)
+  end
 
   it "should apply route to request before creating the resource" do
     route   = dispatcher.add_route [:*], resource

data/spec/webmachine/rescueable_exception_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+RSpec.describe Webmachine::RescuableException do
+  before { described_class.default! }
+
+  describe ".UNRESCUABLEs" do
+    specify "returns an array of UNRESCUABLE exceptions" do
+      expect(described_class.UNRESCUABLEs).to eq(described_class::UNRESCUABLE_DEFAULTS)
+    end
+
+    specify "returns an array of UNRESCUABLE exceptions, with custom exceptions added" do
+      described_class.remove(Exception)
+      expect(described_class.UNRESCUABLEs).to eq(described_class::UNRESCUABLE_DEFAULTS.dup.concat([Exception]))
+    end
+  end
+end

data/spec/webmachine/response_spec.rb

@@ -33,12 +33,18 @@ describe Webmachine::Response do
     describe "setting multiple cookies" do
       let(:cookie2) { "rodeo" }
       let(:cookie2_value) { "clown" }
-      before(:each) { subject.set_cookie(cookie2, cookie2_value) }
+      let(:cookie3) {"color"}
+      let(:cookie3_value) {"blue"}
+      before(:each) do 
+        subject.set_cookie(cookie2, cookie2_value)
+        subject.set_cookie(cookie3, cookie3_value)
+      end
 
       it "should have a proper Set-Cookie header" do
         expect(subject.headers["Set-Cookie"]).to be_a Array
         expect(subject.headers["Set-Cookie"]).to include "rodeo=clown"
         expect(subject.headers["Set-Cookie"]).to include "monster=mash"
+        expect(subject.headers["Set-Cookie"]).to include "color=blue"
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: webmachine
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Sean Cribbs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-20 00:00:00.000000000 Z
+date: 2017-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -68,7 +68,9 @@ files:
 - Guardfile
 - LICENSE
 - README.md
+- RELEASING.md
 - Rakefile
+- bethtemp
 - documentation/adapters.md
 - documentation/authentication-and-authorization.md
 - documentation/configurator.md
@@ -115,6 +117,7 @@ files:
 - lib/webmachine/media_type.rb
 - lib/webmachine/quoted_string.rb
 - lib/webmachine/request.rb
+- lib/webmachine/rescueable_exception.rb
 - lib/webmachine/resource.rb
 - lib/webmachine/resource/authentication.rb
 - lib/webmachine/resource/callbacks.rb
@@ -145,6 +148,7 @@ files:
 - lib/webmachine/translation.rb
 - lib/webmachine/version.rb
 - memory_test.rb
+- pkg/webmachine-1.5.0.gem
 - spec/spec_helper.rb
 - spec/webmachine/adapter_spec.rb
 - spec/webmachine/adapters/httpkit_spec.rb
@@ -169,6 +173,7 @@ files:
 - spec/webmachine/headers_spec.rb
 - spec/webmachine/media_type_spec.rb
 - spec/webmachine/request_spec.rb
+- spec/webmachine/rescueable_exception_spec.rb
 - spec/webmachine/resource/authentication_spec.rb
 - spec/webmachine/response_spec.rb
 - spec/webmachine/trace/fsm_spec.rb
@@ -196,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: webmachine is a toolkit for building HTTP applications,
@@ -225,6 +230,7 @@ test_files:
 - spec/webmachine/headers_spec.rb
 - spec/webmachine/media_type_spec.rb
 - spec/webmachine/request_spec.rb
+- spec/webmachine/rescueable_exception_spec.rb
 - spec/webmachine/resource/authentication_spec.rb
 - spec/webmachine/response_spec.rb
 - spec/webmachine/trace/fsm_spec.rb