rack-bodyparser 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 743caf986aba0bf3b1de5f82ebf7939f4163cc2f
-  data.tar.gz: 687565e7eaec8e87c5d5d17a728f3dfa800ba4c2
+  metadata.gz: 184b75e43e419e7d825abc63f2aa2612eeb536fd
+  data.tar.gz: b46e9fee21d46573d2dbecd3e09d9f3cc16d34ce
 SHA512:
-  metadata.gz: 214c1fc24ac38fab23bfd4c2fb54435403058eb93c62fa2bd5613bc2990e3447fb2149af7afd5bc0156baae0079163ade0d51ff622e56ea3b485abbabec15df1
-  data.tar.gz: 44c165eb469358d64021a4ee0b393925da606c5896463cb769e49158b5a6da1a844bf004b16637a74a527a79b43de6227c8333b3bd49c1cc3ae04d12dc53ab20
+  metadata.gz: 8a1c51c9e46fde3ee67a75aa822e91e43cda7823c752225471de4477e87eac4f8d12943636a7b107343dff3aeb945455bc0d1ecbed38b9f1d9275228fd7debec
+  data.tar.gz: d79f05a5e8e5e3d42df828721ed3d4a65d9ff6fec69ad4172a5a062625cd0577c895442ca1fe69e5dc0486ea3e4abc6177e7b34ba4a25e9c4e8d621f4b7f0ded

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Style/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+    - 'benchmark/**/*.rb'
+
+Metrics/LineLength:
+  Exclude:
+    - 'benchmark/**/*.rb'

data/README.md

@@ -1,38 +1,40 @@
 # Rack::BodyParser #
 
-Rack middleware that provides a way to parse the request body without touching 
-`params` or `request.params`. 
+Rack middleware for parsing incoming request body per content type.
 
+### Inspiration ###
 
-Instead the parser output is available through `env['parsed_body']` or 
-optionally through the Rack::Request object as `request.parsed_body` and/or 
-a custom attribute per parser.
+`Rack::BodyParser` is heavily inspired by 
+[Rack::Parser](https://github.com/achiu/rack-parser), 
+but behaves a bit different. See Key Features.
 
-Rack::BodyParser is heavily inspired by 
-[Rack::Parser](https://github.com/achiu/rack-parser).
+## Key Features; Differences to `Rack::Parser` ##
 
-## Key Features (differences to Rack::Parser) ##
+1. `Rack::BodyParser` only parses the request **body**.
 
-1. separation of `params`/`request.params` and the `parsed_body`.
-1. (optional) patching of `Rack::Request`:
+1. `Rack::BodyParser` does not touch or replace the original `params` or `request.params`, and does not mix `params` and body payload. Instead the parsed result is stored in a separate key `parsed_body` in Rack's `env`.
 
-  Access parsed payload through `request.parsed_body` with support 
-  for custom `request.#{your_key_here}` per parser. 
-  Enable with `:patch_request => true`.
+1. (optional) patching of `Rack::Request` with support for custom getter method Parsed result available as `request.parsed_body` with support for custom `request.#{your_key_here}` per parser. Enable with `:patch_request => true`.
 
-Note: Rack::BodyParser **does** **not** contain any parsers by out of the box.
+1. (optional) access to headers/env. If your parser `respond_to? :env=` it will be invoked with Rack's
+`env` just before running `call` on your parser.
+
+#### Batteries not included ####
+
+`Rack::BodyParser` **does** **not** contain any parsers out of the box.
 
 ## Installation ##
 
-Via rubygems:
+Available through [RubyGems](https://rubygems.org/gems/rack-bodyparser):
 
 `gem install rack-bodyparser`
 
 ## Usage ##
 
-Define your parsers per content_type. 
+Define your `:parsers` per [`media-type`](http://www.rubydoc.info/gems/rack/Rack/Request/Helpers#media_type-instance_method), which is the `content-type` without media type parameters;
+e.g., when `content-type` is `text/plain;charset=utf-8`, the media-type is `text/plain`.
 
-Rack::BodyParser accepts `String` or `Regexp` keys as content_type, 
+Parsers configuration accepts a `String` or `Regexp` as media-type key,
 and anything that `respond_to? 'call'` as parser.
 
 Sinatra example:
@@ -43,7 +45,7 @@ Sinatra example:
 use Rack::BodyParser, :parsers => { 
   'application/json' => proc { |data| JSON.parse data },
   'application/xml'  => proc { |data| XML.parse data },
-  %r{msgpack}        => proc { |data| Msgpack.parse data }
+  /msgpack/          => proc { |data| Msgpack.parse data }
 }
 
 post '/' do
@@ -53,29 +55,32 @@ end
 
 ### Error Handling ###
 
-Rack::BodyParser has one default error handler that can be overridden by 
-setting the 'default' handler. These works like `:parsers`. Use a `String` or 
-`Regexp` as content_type key and anything that `respond_to? 'call'` as the
+`Rack::BodyParser` has one default error handler that can be overridden by 
+setting the 'default' handler. As with parsers, you can use a `String` or
+`Regexp` as media-type key and anything that `respond_to? 'call'` as the
 error handler. The error handler must accept the two parameters 
-`Error` and `type` (the content type).
+`Error` and `type` (the media type).
 
 ```ruby
 use Rack::Parser, :handlers => {
   'default' => proc { |e, type| 
     [400, {}, ['[Rack::BodyParser] Failed to parse %s: %s' % [type, e.to_s]]] 
-  }
+  },
+  'application/xml' => proc { [400, {}, 'Error: XML unsupported'] }
 }
 ```
 
-Rack::BodyParsers will try to `warn` of a `logger` is present.
-
-Note: the error handler rescues exceptions that are descents of `StandardError`. 
+__Note__: the error handler rescues exceptions that descend from `StandardError`. 
 See http://www.mikeperham.com/2012/03/03/the-perils-of-rescue-exception/
 
+
+#### Logging ####
+`Rack::BodyParser` will try to `warn` if a `logger` is present.
+
 ## Patch Rack::Request ##
 
-Setting up Rack::BodyParser with `:patch_request => true` will add
-a `parsed_body` method to Rack::Request. Parsers can also provide a
+Setting up `Rack::BodyParser` with `:patch_request => true` will add
+a `parsed_body` getter method to `Rack::Request`. Parsers can also provide a
 `:rack_request_key` to define a custom key per parser:
 
 ```ruby
@@ -120,15 +125,32 @@ post '/' do
   puts request.document
 end
 ```
+## Request headers/environment ##
 
-## Inspirations ##
+Need headers or other data from Rack's `env` in your parser? Set up your parser
+with a setter method, `respond_to? :env=`, and it will be invoked just before running
+the main `call` method.
+
+```ruby
 
-This project is heavily inspired by [Rack::Parser](https://github.com/achiu/rack-parser). I built
-this because I did not want to mix `params` and the body payload.
+module ThisParserNeedsHeaders
+  def self.env=(env)
+    @env = env
+  end
+
+  def self.call(body)
+    # @env available here for your parsing pleasure.
+  end
+end
+
+use Rack::BodyParser, :parsers => { 
+  'plain/text' => ThisParserNeedsHeaders 
+}
+```
 
 ## Copyright
 
-`Copyright © 2016 Aaron Heesakkers.`
+`Copyright © 2016, 2017 Aaron Heesakkers.`
 
 See [MIT-LICENSE](https://github.com/aars/rack-bodyparser/blob/master/MIT-LICENSE) for details.
 

data/benchmark/benchmark_helper.rb

@@ -0,0 +1,8 @@
+require 'rack/test'
+require 'benchmark/ips'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rack/bodyparser'
+
+

data/benchmark/rack_bodyparser_benchmark.rb

@@ -0,0 +1,62 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'benchmark_helper'
+
+# Helper method providing request options.
+def req_opts(content_type = 'plain/text')
+  {
+    input: 'body',
+    'CONTENT_TYPE' => content_type
+  }
+end
+
+# MockParser
+module MockParser
+  def self.env=(env)
+    @env = env
+  end
+
+  def self.call(_body)
+    'parsed body from mock parser'
+  end
+end
+
+Benchmark.ips do |x|
+  noop = proc { [200, {}, ['hello']] }
+  middleware_opts = {
+    parsers: {
+      'plain/text' => proc { 'string matched parser' },
+      /regexp/     => proc { 'regexp matched parser' },
+      'mock'       => MockParser
+    }
+  }
+  middleware_opts_patched = middleware_opts.clone.update(patch_request: true)
+
+  middleware         = Rack::BodyParser.new(noop, middleware_opts)
+  middleware_patched = Rack::BodyParser.new(noop, middleware_opts_patched)
+
+  # Compare BodyParser to a simple noop request.
+  noop_req           = Rack::MockRequest.new(noop)
+  parser_req         = Rack::MockRequest.new(middleware)
+  parser_patched_req = Rack::MockRequest.new(middleware_patched)
+
+  # And off we go!
+  x.config(time: 5, warmup: 1)
+  x.report('Without BodyParser') { noop_req.post('/', req_opts) } # baseline
+  # Try different setups
+  x.report('No parser found') do
+    parser_req.post('/', req_opts('x'))
+  end
+  x.report('String') do
+    parser_req.post('/', req_opts)
+  end
+  x.report('Regexp') do
+    parser_req.post('/', req_opts('regexp'))
+  end
+  x.report('Str, env') do
+    parser_req.post('/', req_opts('mock'))
+  end
+  x.report('Str, patch_request') do
+    parser_patched_req.post('/', req_opts)
+  end
+  x.compare!
+end

data/lib/rack/bodyparser.rb

@@ -1,62 +1,91 @@
 module Rack
+  # BodyParser implementation.
   class BodyParser
     # Where to get input.
     REQUEST_BODY     = 'rack.input'.freeze
     # Where to store in env
     RACK_ENV_KEY     = 'parsed_body'.freeze
-    # Where to store in Rack::Request in case of options[:patch_request]
+    # Where to store in Rack::Request in case of opts[:patch_request]
     RACK_REQUEST_KEY = 'parsed_body'.freeze
 
     # Default error handler
-    ERROR_MESSAGE = "[Rack::BodyParser] Failed to parse %s: %s\n"
-    ERROR_HANDLER = proc { |e, type|
-      [400, {}, [ERROR_MESSAGE % [type, e.to_s]]]
-    }
+    ERROR_MESSAGE = "[Rack::BodyParser] Failed to parse %s: %s\n".freeze
+
+    ERROR_HANDLER = proc do |e, type|
+      [400, {}, format(ERROR_MESSAGE, type, e.to_s)]
+    end
+
+    HANDLERS = { 'default' => ERROR_HANDLER }.freeze
+
     attr_reader :parsers, :handlers, :logger
 
-    def initialize(app, options = {})
+    def initialize(app, opts = {})
       @app      = app
-      @parsers  = options.delete(:parsers)  || {}
-      @handlers = options.delete(:handlers) || {}
-      @handlers = {'default' => ERROR_HANDLER}.merge(@handlers)
-      @options  = options
+      @parsers  = opts.delete(:parsers) || {}
+      @handlers = HANDLERS.merge(opts.delete(:handlers) || {})
+      @logger   = opts.delete(:logger)
+      @opts     = opts
     end
 
     def call(env)
       type   = Rack::Request.new(env).media_type
       parser = type && detect(parsers, type)
-      body   = parser && env[REQUEST_BODY].read; env[REQUEST_BODY].rewind
-      if body && !body.empty?
-        parser = parser.last
+
+      if parser
         begin
-          parsed = parser.call body
-          env.update RACK_ENV_KEY => parsed
-          patch_rack_request parser, parsed if @options[:patch_request]
+          parse_with(parser.last, env) # parser.last is actual parser
         rescue StandardError => e
-          warn! e, type
-          handler = (detect(handlers, type) || detect(handlers, 'default')).last
-          return handler.call e, type
+          return handle_error(e, type) # return error response
         end
       end
+
+      # return control to app
       @app.call env
     end
 
+    def request_body(env)
+      body = env[REQUEST_BODY].read
+      env[REQUEST_BODY].rewind
+
+      body
+    end
+
+    def parse_with(parser, env)
+      body = request_body(env)
+      return unless body && !body.empty?
+
+      # Give env to parser if it has a setter for it.
+      parser.env = env if parser.respond_to? :env=
+
+      # parse!
+      parsed = parser.call(body)
+
+      # store results in env, optionally in Rack::Request.
+      env.update(RACK_ENV_KEY => parsed)
+      patch_rack_request(parser, parsed) if @opts[:patch_request]
+    end
+
+    def handle_error(e, type)
+      warn!(e, type)
+      handler = (detect(handlers, type) || detect(handlers, 'default')).last
+      handler.call(e, type)
+    end
+
     def patch_rack_request(parser, parsed)
-      if parser.respond_to?(:rack_request_key)
-        Rack::Request.send(:define_method, parser.rack_request_key) { parsed }
-      end
-      Rack::Request.send(:define_method, RACK_REQUEST_KEY) { parsed }
+      return unless parser.respond_to?(:rack_request_key)
+      Rack::Request.send(:define_method, parser.rack_request_key) { parsed }
     end
 
+    # returns [type, parser]
     def detect(hash, what)
-      hash.detect { |match, _|
+      hash.detect do |match, _|
         match.is_a?(Regexp) ? what.match(match) : what.eql?(match)
-      }
+      end
     end
 
     def warn!(e, type)
       return unless logger
-      logger.warn ERROR_MESSAGE % [type, e.to_s]
+      logger.warn format(ERROR_MESSAGE, type, e.to_s)
     end
   end
 end

data/lib/rack/bodyparser/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class BodyParser
-    VERSION = "0.0.2"
+    VERSION = '1.0.0'
   end
 end

data/rack-bodyparser.gemspec

@@ -11,16 +11,19 @@ Gem::Specification.new do |s|
   s.homepage    = 'https://www.github.com/aars/rack-bodyparser'
   s.summary     = 'Rack Middleware for parsing request body'
   s.description = %(
-    Rack Middleware for parsing request body without touching request.params.
-    Allowing full separation of query_string params and body payload.
+    Rack Middleware for parsing request body without touching or
+    mixing in request.params.
   )
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map do |f|
+    File.basename(f)
+  end
   s.require_paths = ['lib']
 
   s.add_dependency 'rack'
-  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rspec'
   s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'benchmark-ips'
 end

data/spec/rack_bodyparser_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Rack::BodyParser do
+  let(:app) { ->(env) { [200, {}, env['PATH_INFO']] } }
+  let(:request) do
+    req = Rack::MockRequest.env_for('/', method: :post, input: 'plain text')
+    req['CONTENT_TYPE'] = 'text/plain'
+    req
+  end
+
+  context 'parsing' do
+    let(:parsed_env_key) { Rack::BodyParser::RACK_ENV_KEY }
+
+    it 'does nothing for unconfigured media-type' do
+      Rack::BodyParser.new(app).call(request)
+      expect(request).not_to have_key(parsed_env_key)
+    end
+
+    it 'uses the correct parser for configured media-type (string)' do
+      parsed_response = 'plain text parsed!'
+      opts = {
+        parsers: {
+          'application/xml'  => proc { 'not me' },
+          'text/plain'       => proc { parsed_response },
+          'application/json' => proc { 'not me' }
+        }
+      }
+      Rack::BodyParser.new(app, opts).call(request)
+
+      expect(request[parsed_env_key]).to eq(parsed_response)
+    end
+
+    it 'uses the correct parser for configured media-type (regexp)' do
+      parsed_response = 'plain text parsed!'
+      opts = {
+        parsers: {
+          /plain/ => proc { parsed_response }
+        }
+      }
+      Rack::BodyParser.new(app, opts).call(request)
+
+      expect(request[parsed_env_key]).to eq(parsed_response)
+    end
+
+    it 'patches the request object with a custom getter' do
+      opts = {
+        patch_request: true,
+        parsers: {
+          'text/plain' => MockParser
+        }
+      }
+      Rack::BodyParser.new(app, opts).call(request)
+
+      parsed_response = MockParser.call('')
+      custom_getter   = MockParser.rack_request_key
+
+      # parser was called?
+      expect(request[parsed_env_key]).to eq(parsed_response)
+
+      # Rack::Request was patched with custom getter?
+      rack_request = Rack::Request.new('')
+      expect(rack_request).to respond_to(custom_getter)
+      expect(rack_request.send(custom_getter)).to eq(parsed_response)
+    end
+
+    it 'passes env to parser if it has a setter' do
+      opts = {
+        parsers: {
+          'text/plain' => MockParserWithEnvSetter
+        }
+      }
+      Rack::BodyParser.new(app, opts).call(request)
+
+      # MockParserWithEnvSetter will return env['REQUEST_METHOD'].
+      expect(request[parsed_env_key]).to eq(request['REQUEST_METHOD'])
+    end
+  end
+
+  context 'handlers' do
+    it 'responds with default' do
+      err = 'it broke'
+      opts = {
+        parsers: { 'text/plain' => proc { raise StandardError, err } }
+      }
+      res = Rack::BodyParser.new(app, opts).call(request)
+
+      # test response status code and error message
+      expect(res[0]).to eq(Rack::BodyParser::ERROR_HANDLER.call[0])
+      expect(res[2]).to include(err)
+    end
+
+    it 'responds with custom handler' do
+      status = 422
+      err = 'you broke it'
+      opts = {
+        parsers: { 'text/plain' => proc { raise StandardError, 'it broke' } },
+        handlers: { 'text/plain' => proc { [status, {}, err] } }
+      }
+      res = Rack::BodyParser.new(app, opts).call(request)
+
+      # test response status code and error message
+      expect(res[0]).to eq(status)
+      expect(res[2]).to include(err)
+    end
+
+    it 'can override default' do
+      status = 418
+      err = 'I am a teapot'
+      opts = {
+        parsers: { 'text/plain' => proc { raise StandardError, 'it broke' } },
+        handlers: { 'default' => proc { [status, {}, err] } }
+      }
+      res = Rack::BodyParser.new(app, opts).call(request)
+
+      # test response status code and error message
+      expect(res[0]).to eq(status)
+      expect(res[2]).to include(err)
+    end
+  end
+
+  context 'logger' do
+    it 'warns on error' do
+      err = 'it broke'
+      opts = {
+        parsers: { 'text/plain' => proc { raise StandardError, err } },
+        logger: MockLogger
+      }
+
+      expect(MockLogger).to receive(:warn)
+      Rack::BodyParser.new(app, opts).call(request)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'rspec'
+require 'rack/test'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rack/bodyparser'
+
+# MockParser to test :patch_request option.
+module MockParser
+  # custom getter key
+  def self.rack_request_key
+    :mockparser_document
+  end
+
+  def self.call(_body)
+    'mockparser called!'
+  end
+end
+
+# MockParser to test env setter. Will return env['REQUEST_METHOD'] when called.
+module MockParserWithEnvSetter
+  def self.call(_body)
+    @env['REQUEST_METHOD']
+  end
+
+  def self.env=(env)
+    @env = env
+  end
+end
+
+module MockLogger
+  def self.warn(_msg)
+    'you were warned!'
+  end
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-bodyparser
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Aaron Heesakkers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-13 00:00:00.000000000 Z
+date: 2017-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,8 +52,22 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "\n    Rack Middleware for parsing request body without touching request.params.\n
-  \   Allowing full separation of query_string params and body payload.\n  "
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n    Rack Middleware for parsing request body without touching or\n
+  \   mixing in request.params.\n  "
 email:
 - aaronheesakkers@gmail.com
 executables: []
@@ -61,11 +75,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
 - MIT-LICENSE
 - README.md
+- benchmark/benchmark_helper.rb
+- benchmark/rack_bodyparser_benchmark.rb
 - lib/rack/bodyparser.rb
 - lib/rack/bodyparser/version.rb
 - rack-bodyparser.gemspec
+- spec/rack_bodyparser_spec.rb
+- spec/spec_helper.rb
 homepage: https://www.github.com/aars/rack-bodyparser
 licenses:
 - MIT
@@ -90,4 +110,6 @@ rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Rack Middleware for parsing request body
-test_files: []
+test_files:
+- spec/rack_bodyparser_spec.rb
+- spec/spec_helper.rb