grape 1.8.0 → 4.0.1

data/lib/grape/router/pattern.rb

@@ -1,62 +1,104 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'mustermann/grape'
-require 'grape/util/cache'
-
 module Grape
   class Router
     class Pattern
-      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true }.freeze
-      DEFAULT_SUPPORTED_CAPTURE = %i[format version].freeze
+      extend Forwardable
 
-      attr_reader :origin, :path, :pattern, :to_regexp
+      DEFAULT_CAPTURES = %w[format version].freeze
 
-      extend Forwardable
-      def_delegators :pattern, :named_captures, :params
+      attr_reader :origin, :path, :pattern, :to_regexp, :anchor, :version, :requirements
+
+      def_delegators :pattern, :params
       def_delegators :to_regexp, :===
       alias match? ===
 
-      def initialize(pattern, **options)
-        @origin  = pattern
-        @path    = build_path(pattern, **options)
-        @pattern = Mustermann::Grape.new(@path, **pattern_options(options))
+      # Build a Pattern from a raw path, namespace and the API's inheritable
+      # settings. {Path} owns the settings-aware assembly of +origin+/+suffix+;
+      # the Pattern itself stays value-based (see {#initialize}).
+      def self.build(path:, namespace:, settings:, anchor:, params:, version:, requirements:)
+        built_path = Path.new(path, namespace, settings)
+        new(origin: built_path.origin, suffix: built_path.suffix, anchor:, params:, version:, requirements:)
+      end
+
+      def initialize(origin:, suffix:, anchor:, params:, version:, requirements:)
+        @origin = origin
+        @anchor = anchor
+        @version = version
+        @requirements = requirements
+        @path = PatternCache[[build_path_from_pattern(@origin, anchor), suffix]]
+        @pattern = MustermannPattern.new(@path, uri_decode: true, params:, capture: extract_capture(version, requirements))
         @to_regexp = @pattern.to_regexp
+        @captures = @to_regexp.names.any?
       end
 
-      private
+      # True when the compiled pattern has named captures to extract from a
+      # matched path. A fully static path has none — not even +format+, which
+      # the suffix spells as a literal — so asking Mustermann for its params
+      # would run the regexp a second time (the router's union already matched
+      # it) only to hand back an empty Hash.
+      #
+      # Resolved once here rather than per request: +Regexp#names+ builds an
+      # Array and a String per capture, and Ruby offers no predicate that skips
+      # that (+named_captures+ builds a Hash, and scanning the source for
+      # <tt>(?<</tt> would count lookbehinds, which name nothing).
+      def captures?
+        @captures
+      end
 
-      def pattern_options(options)
-        capture = extract_capture(**options)
-        options = DEFAULT_PATTERN_OPTIONS.dup
-        options[:capture] = capture if capture.present?
-        options
+      def captures_default
+        to_regexp.names
+                 .delete_if { |n| DEFAULT_CAPTURES.include?(n) }
+                 .to_h { |k| [k, ''] }
       end
 
-      def build_path(pattern, anchor: false, suffix: nil, **_options)
-        unless anchor || pattern.end_with?('*path')
-          pattern = +pattern
-          pattern << '/' unless pattern.end_with?('/')
-          pattern << '*path'
-        end
+      private
 
-        pattern = -pattern.split('/').tap do |parts|
-          parts[parts.length - 1] = "?#{parts.last}"
-        end.join('/') if pattern.end_with?('*path')
+      # The declared versions constrain the +:version+ capture. They are handed
+      # to Mustermann as one alternation Regexp rather than as the Array of
+      # Strings they arrive in, because an Array capture makes Mustermann build
+      # a *converter* for the capture -- and for an Array of plain Strings that
+      # converter is the identity function (Mustermann only derives one from a
+      # Class or a Symbol, so every entry contributes nothing and the lambda
+      # falls through to `|| string`).
+      #
+      # A non-empty converter table costs every request on the route: it makes
+      # Mustermann's +identity_params?+ fast path unreachable, so +params+
+      # rebuilds the capture Hash through +map_param+ and calls the do-nothing
+      # lambda on each value. Passing a Regexp registers no converter at all.
+      #
+      # The generated matcher differs in one respect: Mustermann expands an
+      # Array entry the way it expands a path literal, so each character also
+      # matches its own percent-encoding (+v1+ as <tt>(?:v|%76)(?:1|%31)</tt>).
+      # A Regexp is inserted verbatim, so a percent-encoded version segment no
+      # longer matches the route. It never reached the endpoint anyway --
+      # {Versioner::Base#potential_version_match?} compares the raw segment
+      # against the declared versions, so +/api/%76%31/x+ was matched here and
+      # then rejected as an unknown version, ending in the same cascading 404
+      # the router now returns directly.
+      #
+      # +Regexp.union+ takes Strings and Regexps only, and +version+ accepts
+      # Symbols and Integers too, so the entries are coerced first. A lone one
+      # would survive without it -- the single-argument path goes through
+      # +Regexp.escape+, which does accept a Symbol -- but a second raises
+      # TypeError.
+      def extract_capture(version, requirements)
+        return requirements if version.blank?
 
-        PatternCache[[pattern, suffix]]
+        requirements.merge(version: Regexp.union(Array.wrap(version).map(&:to_s)))
       end
 
-      def extract_capture(requirements: {}, **options)
-        requirements = {}.merge(requirements)
-        DEFAULT_SUPPORTED_CAPTURE.each_with_object(requirements) do |field, capture|
-          option = Array(options[field])
-          capture[field] = option.map(&:to_s) if option.present?
-        end
+      def build_path_from_pattern(pattern, anchor)
+        return pattern.dup.insert(pattern.rindex('/') + 1, '?') if pattern.end_with?('*path')
+        return pattern if anchor
+        return "#{pattern}?*path" if pattern.end_with?('/')
+
+        "#{pattern}/?*path"
       end
 
       class PatternCache < Grape::Util::Cache
         def initialize
+          super
           @cache = Hash.new do |h, (pattern, suffix)|
             h[[pattern, suffix]] = -"#{pattern}#{suffix}"
           end

data/lib/grape/router/route.rb

@@ -1,90 +1,109 @@
 # frozen_string_literal: true
 
-require 'grape/router/pattern'
-require 'grape/router/attribute_translator'
-require 'forwardable'
-require 'pathname'
-
 module Grape
   class Router
-    class Route
-      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/.freeze
-      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
-      FIXED_NAMED_CAPTURES = %w[format version].freeze
+    class Route < BaseRoute
+      extend Forwardable
 
-      attr_accessor :pattern, :translator, :app, :index, :options
+      FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
+      NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
 
-      alias attributes translator
+      attr_reader :app, :request_method, :index
 
-      extend Forwardable
-      def_delegators :pattern, :path, :origin
-      delegate Grape::Router::AttributeTranslator::ROUTE_ATTRIBUTES => :attributes
-
-      def method_missing(method_id, *arguments)
-        match = ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
-        if match
-          method_name = match.captures.last.to_sym
-          warn_route_methods(method_name, caller(1).shift)
-          @options[method_name]
-        else
-          super
-        end
-      end
+      def_delegators :@app, :call
 
-      def respond_to_missing?(method_id, _)
-        ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
+      def initialize(endpoint, method, pattern, options, forward_match:, params: {}, **route_attributes)
+        super(pattern, options, **route_attributes)
+        @app = endpoint
+        @request_method = upcase_method(method)
+        @match_function = forward_match ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD
+        @declared_params = params
       end
 
-      def route_method
-        warn_route_methods(:method, caller(1).shift, :request_method)
-        request_method
+      def to_head
+        head = dup
+        head.convert_to_head_request!
+        head
       end
 
-      def route_path
-        warn_route_methods(:path, caller(1).shift)
-        pattern.path
+      def apply(app)
+        @app = app
+        self
       end
 
-      def initialize(method, pattern, **options)
-        method_s = method.to_s
-        method_upcase = Grape::Http::Headers.find_supported_method(method_s) || method_s.upcase
+      def match?(input)
+        return false if input.blank?
 
-        @options    = options.merge(method: method_upcase)
-        @pattern    = Pattern.new(pattern, **options)
-        @translator = AttributeTranslator.new(**options, request_method: method_upcase)
+        @match_function.call(input, pattern)
       end
 
-      def exec(env)
-        @app.call(env)
+      # The route's declared params keyed by name — path captures plus any
+      # declared body/query params, as their definitions. Used for documentation
+      # (e.g. grape-swagger), not for extracting request values.
+      def params
+        @params ||= pattern.captures_default.merge(@declared_params)
       end
 
-      def apply(app)
-        @app = app
-        self
+      # Extract param values from a matched request path. Used by the router.
+      #
+      # A pattern with no named captures has nothing to extract, so it skips the
+      # match entirely and answers nil — the same way {GreedyRoute#params_for}
+      # does, and what the router already coerces into the Hash it builds
+      # routing args in.
+      def params_for(input)
+        return unless pattern.captures?
+
+        parsed = pattern.params(input)
+        return unless parsed
+
+        params = {}
+        parsed.each { |name, value| params[name.to_sym] = tag_utf8!(value) unless value.nil? }
+        params
       end
 
-      def match?(input)
-        translator.respond_to?(:forward_match) && translator.forward_match ? input.start_with?(pattern.origin) : pattern.match?(input)
+      protected
+
+      def convert_to_head_request!
+        @request_method = Rack::HEAD
       end
 
-      def params(input = nil)
-        if input.nil?
-          pattern.named_captures.keys.each_with_object(translator.params) do |(key), defaults|
-            defaults[key] ||= '' unless FIXED_NAMED_CAPTURES.include?(key) || defaults.key?(key)
-          end
+      private
+
+      # Mustermann decodes path captures out of +PATH_INFO+, which Rack hands us
+      # tagged ASCII-8BIT, so path params came back binary while Rack tags query
+      # and body params UTF-8. That split makes an API's own declarations
+      # disagree with themselves: `values: ['café']` matched `?id=café` but not
+      # `/café`, since a binary string never equals the UTF-8 literal it was
+      # written as.
+      #
+      # Re-tag as UTF-8. Nothing obliges a client to send UTF-8: the request
+      # target is octets to HTTP, and Rack's SPEC has CGI keys carry non-ASCII
+      # as ASCII-8BIT. But UTF-8 is what browsers percent-encode with, what an
+      # IRI maps to, and what Rails settles on — ActionDispatch::Journey::Router
+      # force_encodes every path capture to UTF-8 after unescaping it.
+      #
+      # Only the encoding changes; the bytes are untouched. Octets that are not
+      # UTF-8 therefore stay invalid and are caught downstream rather than being
+      # silently scrubbed into something the client never sent.
+      #
+      # The re-tag is in place, hence the bang. Mustermann's +Pattern#params+
+      # builds a fresh Hash of fresh, unfrozen strings on every call and skips
+      # its own Match cache, so the mutation cannot escape this request — which
+      # is also what lets the Array branch re-tag its elements with +each+.
+      def tag_utf8!(value)
+        case value
+        when String
+          value.force_encoding(Encoding::UTF_8)
+        when Array
+          value.each { |v| tag_utf8!(v) }
         else
-          parsed = pattern.params(input)
-          parsed ? parsed.delete_if { |_, value| value.nil? }.symbolize_keys : {}
+          value
         end
       end
 
-      private
-
-      def warn_route_methods(name, location, expected = nil)
-        path, line = *location.scan(SOURCE_LOCATION_REGEXP).first
-        path = File.realpath(path) if Pathname.new(path).relative?
-        expected ||= name
-        ActiveSupport::Deprecation.warn("#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.")
+      def upcase_method(method)
+        method_s = method.to_s
+        Grape::HTTP_SUPPORTED_METHODS.detect { |m| m.casecmp(method_s).zero? } || method_s.upcase
       end
     end
   end

data/lib/grape/router.rb

@@ -1,60 +1,54 @@
 # frozen_string_literal: true
 
-require 'grape/router/route'
-require 'grape/util/cache'
-
 module Grape
   class Router
-    attr_reader :map, :compiled
-
-    def self.normalize_path(path)
-      path = +"/#{path}"
-      path.squeeze!('/')
-      path.sub!(%r{/+\Z}, '')
-      path = '/' if path == ''
-      path
-    end
-
-    def self.supported_methods
-      @supported_methods ||= Grape::Http::Headers::SUPPORTED_METHODS + ['*']
-    end
-
     def initialize
       @neutral_map = []
       @neutral_regexes = []
-      @map = Hash.new { |hash, key| hash[key] = [] }
-      @optimized_map = Hash.new { |hash, key| hash[key] = // }
+      # Plain hashes with no auto-vivifying default: a lookup for an HTTP method
+      # that has no routes must not insert a key. `compile!` freezes both maps,
+      # so request-time reads never mutate shared state (see #match? / #rotation).
+      @map = {}
+      @optimized_map = {}
     end
 
     def compile!
-      return if compiled
+      return if @compiled
 
-      @union = Regexp.union(@neutral_regexes)
+      @union = resolve_capture_groups(Regexp.union(@neutral_regexes), @neutral_map)
       @neutral_regexes = nil
-      self.class.supported_methods.each do |method|
-        routes = map[method]
-        @optimized_map[method] = routes.map.with_index do |route, index|
-          route.index = index
-          Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
-        end
-        @optimized_map[method] = Regexp.union(@optimized_map[method])
+      # Compiled from the routes actually registered rather than from
+      # Grape::HTTP_SUPPORTED_METHODS. A route declared with any other verb
+      # (`route :purge, '/cache'`) is accepted at definition time and is
+      # already collected into the resource's Allow header, so skipping it here
+      # left it in @map but out of @optimized_map — the only map #match? reads.
+      # The resource then advertised a method that could never be matched and
+      # answered every request for it with 405.
+      @map.each do |method, routes|
+        optimized_map = routes.map.with_index { |route, index| route.to_regexp(index) }
+        @optimized_map[method] = resolve_capture_groups(Regexp.union(optimized_map), routes)
       end
+      @map.freeze
+      @optimized_map.freeze
       @compiled = true
     end
 
     def append(route)
-      map[route.request_method] << route
+      (@map[route.request_method] ||= []) << route
     end
 
-    def associate_routes(pattern, **options)
-      @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Grape::Router::AttributeTranslator.new(**options, pattern: pattern, index: @neutral_map.length)
+    def associate_routes(greedy_route)
+      @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
+      @neutral_map << greedy_route
     end
 
     def call(env)
       with_optimization do
-        response, route = identity(env)
-        response || rotation(env, route)
+        # Published on the env so the middleware the matched route runs -- the
+        # path versioner above all -- reads the path this routed on instead of
+        # normalizing PATH_INFO a second time.
+        input = env[Grape::Env::GRAPE_NORMALIZED_PATH] = Grape::Util::PathNormalizer.call(env[Rack::PATH_INFO])
+        transaction(input, env[Rack::REQUEST_METHOD], env)
       end
     end
 
@@ -65,113 +59,143 @@ module Grape
       any.endpoint
     end
 
+    DEFAULT_RESPONSE_HEADERS = Grape::Util::Header.new.merge('X-Cascade' => 'pass').freeze
+    DEFAULT_RESPONSE_BODY = ['404 Not Found'].freeze
+
     private
 
-    def identity(env)
-      route = nil
-      response = transaction(env) do |input, method|
-        route = match?(input, method)
-        process_route(route, env) if route
+    # Resolve +input+ against the compiled routes, in priority order:
+    #
+    # 1. the routes registered for +method+ — the compiled-union match first,
+    #    then, when that route cascades, its siblings (see #rotation);
+    # 2. the ANY (+'*'+) routes;
+    # 3. the greedy neighbour, which answers auto-OPTIONS and 405.
+    #
+    # Returns nil when nothing answered, leaving the caller to 404. A response
+    # that cascades is never final: it is returned only once every later
+    # candidate has declined too, so the caller (or a mounting app upstream)
+    # can keep looking.
+    def transaction(input, method, env)
+      exact_route = match?(input, method)
+      response = process_route(exact_route, input, env) if exact_route
+      return response if halt?(response)
+
+      # A cascading route has only declined this request. Its siblings — the
+      # routes sharing this path but differing in, say, version — must be
+      # tried before falling back to the ANY routes and the greedy neighbour.
+      # Skipped when nothing matched: the compiled union is the disjunction of
+      # the same patterns #rotation walks, so a miss there is a miss here.
+      cascaded = !response.nil?
+      if cascaded
+        response = rotation(input, method, env, exact_route)
+        return response if response && !cascade?(response)
       end
-      [response, route]
-    end
 
-    def rotation(env, exact_route = nil)
-      response = nil
-      input, method = *extract_input_and_method(env)
-      map[method].each do |route|
-        next if exact_route == route
-        next unless route.match?(input)
+      last_neighbor_route = greedy_match?(input)
 
-        response = process_route(route, env)
-        break unless cascade?(response)
-      end
-      response
-    end
+      # If last_neighbor_route exists and request method is OPTIONS,
+      # return response by using #include_allow_header.
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !cascaded && method == Rack::OPTIONS && last_neighbor_route
 
-    def transaction(env)
-      input, method = *extract_input_and_method(env)
-      response = yield(input, method)
+      star_route = match?(input, '*')
 
-      return response if response && !(cascade = cascade?(response))
+      if star_route
+        close_body(response) if response # superseded by the ANY route
+        response = process_route(star_route, input, env)
+        return response if halt?(response)
 
-      last_neighbor_route = greedy_match?(input)
+        cascaded ||= !response.nil?
+      end
 
-      # If last_neighbor_route exists and request method is OPTIONS,
-      # return response by using #call_with_allow_headers.
-      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Grape::Http::Headers::OPTIONS && !cascade
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !cascaded && last_neighbor_route
 
-      route = match?(input, '*')
+      response
+    end
 
-      return last_neighbor_route.endpoint.call(env) if last_neighbor_route && cascade && route
+    # The routes registered for +method+ other than +exact_route+, tried in
+    # registration order until one answers without cascading. Returns the last
+    # response processed — a cascading one when every sibling declined, so the
+    # caller can hand it back — or nil when no sibling matched.
+    def rotation(input, method, env, exact_route)
+      response = nil
+      @map[method]&.each do |route|
+        next if exact_route == route
+        next unless route.match?(input)
 
-      if route
-        response = process_route(route, env)
-        return response if response && !(cascade = cascade?(response))
+        close_body(response) if response # the previous sibling cascaded
+        response = process_route(route, input, env)
+        break unless cascade?(response)
       end
+      response
+    end
 
-      return call_with_allow_headers(env, last_neighbor_route) if !cascade && last_neighbor_route
+    # Returns true if `response` should be returned as-is from the enclosing
+    # transaction. Closes the body as a side effect when the response is
+    # cascading so callers can safely try the next match.
+    def halt?(response)
+      return false unless response
 
-      nil
+      cascade = cascade?(response)
+      close_body(response) if cascade
+      !cascade
     end
 
-    def process_route(route, env)
-      prepare_env_from_route(env, route)
-      route.exec(env)
+    # Releases a response the router has decided not to return. Rack requires
+    # every body it hands out to be closed, and a cascading candidate is
+    # discarded as soon as a later one answers.
+    def close_body(response)
+      body = response[2]
+      body.close if body.respond_to?(:close)
     end
 
-    def make_routing_args(default_args, route, input)
-      args = default_args || { route_info: route }
-      args.merge(route.params(input) || {})
+    # Routing args are rebuilt for every attempt: when a route cascades
+    # (X-Cascade pass), the next candidate must not observe the previous
+    # attempt's +route_info+ or path captures.
+    def process_route(route, input, env, include_allow_header: false)
+      # The path captures are the hash: +route_info+ is written into them
+      # rather than merged in from a second one.
+      routing_args = route.params_for(input) || {}
+      routing_args[:route_info] = route
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = routing_args
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header if include_allow_header
+      route.call(env)
     end
 
-    def extract_input_and_method(env)
-      input = string_for(env[Grape::Http::Headers::PATH_INFO])
-      method = env[Grape::Http::Headers::REQUEST_METHOD]
-      [input, method]
+    # Tells each route the number of the group it ended up as in +union+. The
+    # numbering is a property of the union rather than of the route's own
+    # pattern -- every route ahead of it contributes however many groups its
+    # pattern declares -- so it can only be resolved once the union is built.
+    # Returns the union, so a caller can assign it in one expression.
+    def resolve_capture_groups(union, routes)
+      named_captures = union.named_captures
+      routes.each { |route| route.resolve_capture_group!(named_captures) }
+      union
     end
 
     def with_optimization
-      compile! unless compiled
+      compile!
       yield || default_response
     end
 
     def default_response
-      [404, { Grape::Http::Headers::X_CASCADE => 'pass' }, ['404 Not Found']]
+      [404, DEFAULT_RESPONSE_HEADERS.dup, DEFAULT_RESPONSE_BODY.dup]
     end
 
+    # Which alternative of the union matched is answered by scanning one group
+    # per registered route, so on an API with many of them that scan is what a
+    # request costs. The groups are indexed by number rather than by name: a
+    # name sends MatchData through the pattern's name table on every lookup,
+    # a number indexes the match region directly.
     def match?(input, method)
-      current_regexp = @optimized_map[method]
-      return unless current_regexp.match(input)
-
-      last_match = Regexp.last_match
-      @map[method].detect { |route| last_match["_#{route.index}"] }
+      @optimized_map[method]&.match(input) { |m| @map[method].detect { |route| m[route.regexp_capture_group] } }
     end
 
     def greedy_match?(input)
-      return unless @union.match(input)
-
-      last_match = Regexp.last_match
-      @neutral_map.detect { |route| last_match["_#{route.index}"] }
-    end
-
-    def call_with_allow_headers(env, route)
-      prepare_env_from_route(env, route)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header.join(', ').freeze
-      route.endpoint.call(env)
-    end
-
-    def prepare_env_from_route(env, route)
-      input, = *extract_input_and_method(env)
-      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(env[Grape::Env::GRAPE_ROUTING_ARGS], route, input)
+      @union.match(input) { |m| @neutral_map.detect { |route| m[route.regexp_capture_group] } }
     end
 
     def cascade?(response)
-      response && response[1][Grape::Http::Headers::X_CASCADE] == 'pass'
-    end
-
-    def string_for(input)
-      self.class.normalize_path(input)
+      response && response[1]['X-Cascade'] == 'pass'
     end
   end
 end

data/lib/grape/serve_stream/file_body.rb

@@ -31,6 +31,13 @@ module Grape
       def ==(other)
         path == other.path
       end
+      alias eql? ==
+
+      # Mirrors #==, which keys on the path alone and does not check the
+      # class, so the class must stay out of the hash too.
+      def hash
+        path.hash
+      end
     end
   end
 end

data/lib/grape/serve_stream/sendfile_response.rb

@@ -6,11 +6,9 @@ module Grape
     # for using Rack::SendFile middleware
     class SendfileResponse < Rack::Response
       def respond_to?(method_name, include_all = false)
-        if method_name == :to_path
-          @body.respond_to?(:to_path, include_all)
-        else
-          super
-        end
+        return @body.respond_to?(:to_path, include_all) if method_name == :to_path
+
+        super
       end
 
       def to_path

data/lib/grape/serve_stream/stream_response.rb

@@ -18,6 +18,13 @@ module Grape
       def ==(other)
         stream == other.stream
       end
+      alias eql? ==
+
+      # Mirrors #==, which keys on the stream alone and does not check the
+      # class, so the class must stay out of the hash too.
+      def hash
+        stream.hash
+      end
     end
   end
 end