rack-parser 0.3.0 → 0.4.0

data/README.md

@@ -1,11 +1,8 @@
 # Rack::Parser #
 
-Rack::Parser is a Rack Middleware for parsing post body data for JSON, XML, and custom
-content types using MultiJson, MultiXML, or any thing that you want to
-use.
-
-What this allows your rack application to do is decode/parse incoming post data
-into param hashes for your applications to use.
+Rack::Parser is a rack middleware that allows your application to do decode/parse incoming post data
+into param hashes for your applications to use. You can provide a custom
+Parser for things like JSON, XML, MSGPACK using your library of choice.
 
 ## Installation ##
 
@@ -23,45 +20,29 @@ or put it in your Gemfile:
 gem 'rack-parser', :require => 'rack/parser'
 ```
 
-
 ## Usage ##
 
-
 In a Sinatra or [Padrino](http://padrinorb.com) application, it would probably be something like:
 
 ```ruby
 # app.rb
 
-use Rack::Parser
+use Rack::Parser :parsers => { 'application/json' => proc { |data| JSON.parse data },
+                               'application/xml'  => proc { |data| XML.parse data },
+                               %r{msgpack}        => proc { |data| Msgpack.parse data }
+                             }
 ```
 
-
 ### Content Type Parsing ###
 
-By default, Rack::Parser uses MultiJson and MultiXml to decode/parse
-your JSON/XML Data. these can be overwritten if you choose not to use
-them. However, through using them you can just as easily leverage the
-engine of your choice by setting the engine like so:
-
-
-```ruby
-# app.rb
-
-MultiJson.engine = :yajl  # Yajl-ruby for json decoding
-MultiXml.parser  = :libxml # libxml for XML parsing
-
-use Rack::Parser
-```
-
-To set your own custom engine that perhaps neither MultiJson or MultiXml
-support, just make it a Proc:
-
+By default, Rack::Parser uses `JSON` decode/parse your JSON Data. This can be overwritten if you choose not to use
+them. You can do it like so:
 
 ```ruby
-use Rack::Parser, :content_types => {
-  'application/json' => Proc.new { |body| MyCustomJsonEngine.do_it body },
-  'application/xml'  => Proc.new { |body| MyCustomXmlEngine.decode body },
-  'application/roll' => Proc.new { |body| 'never gonna give you up'     }
+use Rack::Parser, :parsers => {
+  'application/json' => proc { |body| MyCustomJsonEngine.do_it body },
+  'application/xml'  => proc { |body| MyCustomXmlEngine.decode body },
+  'application/roll' => proc { |body| 'never gonna give you up'     }
 }
 ```
 
@@ -75,18 +56,16 @@ You can additionally customize the error handling response as well to
 whatever it is you like:
 
 ```ruby
-use Rack::Parser, :error_responses => {
-  'default'          => Proc.new { |e, content_type| [500, {}, ["boo hoo"] ] },
-  'application/json' => Proc.new { |e, content_type| [400, {'Content-Type'=>content_type}, ["broke"]] }
-  }
+use Rack::Parser, :handlers => {
+  'application/json' => proc { |e, type| [400, { 'Content-Type' => type }, ["broke"]] }
+}
 ```
 
 The error handler expects to pass both the `error` and `content_type` so
 that you can use them within your responses. In addition, you can
 override the default response as well.
 
-If no content_type error handling response is present, it will use the
-`default`.
+If no content_type error handling response is present, it will return `400`
 
 ## Inspirations ##
 

data/Rakefile

@@ -1,9 +1,9 @@
 require 'bundler/gem_tasks'
 
 require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
+Rake::TestTask.new(:spec) do |test|
+  test.libs << 'lib' << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
   test.warning = true
   test.verbose = true
 end

data/lib/rack/parser.rb

@@ -1,60 +1,20 @@
-require 'multi_json'
-require 'multi_xml'
-
 module Rack
-
-  # Rack::Parser allows you to set custom parsers for incoming post body data. As a default,
-  # Rack::Parser uses MultiJson and MultiXml to do the decoding/parsing for you. This allows you to
-  # designate any engine you wish that is compatible with the MultiJson/MultiXml libraries.
-  # You can also conveniently use another library by as well by wrapping it as a Proc or add additional
-  # content types which are not default in this middleware.
-  # In addition, you can set custom error handling for each content_type. If no error response is defined for
-  # a particular content_type, it will use the default error response, which can also be overrided.
-  #
   class Parser
 
-    # Rack Constants
-    POST_BODY           = 'rack.input'.freeze
-    FORM_INPUT          = 'rack.request.form_input'.freeze
-    FORM_HASH           = 'rack.request.form_hash'.freeze
+    POST_BODY  = 'rack.input'.freeze
+    FORM_INPUT = 'rack.request.form_input'.freeze
+    FORM_HASH  = 'rack.request.form_hash'.freeze
 
-    # Default Settings
-    DEFAULT_CONTENT_TYPE = {
-      'application/xml'  => Proc.new { |body| MultiXml.parse(body)   },
-      'application/json' => Proc.new { |body| MultiJson.decode(body) }
-    }
-
-    DEFAULT_ERROR_RESPONSE = {
-      'default' =>
-      Proc.new do |e, content_type|
-        format = content_type.split('/').last
-        meth   = "to_#{format}"
-        meth   = "inspect" unless ::Hash.respond_to? meth
-        [400, {'Content-Type' => content_type }, [ { 'errors' => e.to_s }.method(meth).call ] ]
-      end
-    }
+    JSON_PARSER   = proc { |data| JSON.parse data }
+    ERROR_HANDLER = proc { |err, type| [400, {}, ''] }
 
-    attr_reader :content_types, :error_responses
+    attr_reader :parsers, :handlers, :logger
 
-    # Usage:
-    # use Rack::Parser, :content_types => {
-    #   'application/xml'  => Proc.new { |body| XmlParser.parse body   } # if you don't want the default
-    #   'application/json' => Proc.new { |body| JsonParser.decode body } # if you don't want the default
-    #   'application/foo'  => Proc.new { |body| FooParser.parse body   } # Add custom content_types to parse.
-    # }
-    #
-    # # use Rack::Parser,
-    #   :content_types  => {
-    #     'application/xml'  => Proc.new { |body| XmlParser.parse body   } # if you don't want the default
-    #   },
-    #   :error_responses => {
-    #     'default'          => Proc.new { |e, content_type| [500, {}, ["boo hoo"] ] },                         # Override the default error response..
-    #     'application/json' => Proc.new { |e, content_type| [400, {'Content-Type'=>content_type}, ["broke"]] } # Customize error responses based on content type.
-    #   }
     def initialize(app, options = {})
-      @app             = app
-      @content_types   = DEFAULT_CONTENT_TYPE.merge(options.delete(:content_types) || {})
-      @error_responses = DEFAULT_ERROR_RESPONSE.merge(options.delete(:error_responses) || {})
+      @app      = app
+      @parsers  = options.delete(:parsers)  || { %r{json} => JSON_PARSER }
+      @handlers = options.delete(:handlers) || {}
+      @logger   = options.delete(:logger)
     end
 
     def call(env)
@@ -62,20 +22,32 @@ module Rack
     end
 
     def _call(env)
-      content_type = Rack::Request.new(env).media_type
-      return @app.call(env) if !@content_types[content_type] && !@error_responses[content_type]
-      body = env[POST_BODY].read if content_type
-      return @app.call(env) if (body.respond_to?(:empty?) ? body.empty? : !body) # Send it down the stack immediately
+      type   = Rack::Request.new(env).media_type
+      parser = parsers.detect { |content_type, _| type.match(content_type) } if type
+      return @app.call(env) unless parser
+      body = env[POST_BODY].read ; env[POST_BODY].rewind
+      return @app.call(env) unless body && !body.empty?
       begin
-        result = @content_types[content_type].call(body)
-        env.update FORM_HASH => result, FORM_INPUT => env[POST_BODY]
+        parsed = parser.last.call body
+        env.update FORM_HASH => parsed, FORM_INPUT => env[POST_BODY]
       rescue Exception => e
-        logger.warn "#{self.class} #{content_type} parsing error: #{e.to_s}" if respond_to? :logger # Send to logger if its there.
-        err = @error_responses[content_type] ? content_type : 'default'
-        return @error_responses[err].call(e, content_type) # call the error responses
+        warn! e, type
+        handler   = handlers.detect { |content_type, _|  type.match(content_type) }
+        handler ||= ['default', ERROR_HANDLER]
+        return handler.last.call(e, type)
       end
       @app.call env
     end
 
+    # Private: send a warning out to the logger
+    #
+    # error - Exception object
+    # type  - String of the Content-Type
+    #
+    def warn!(error, type)
+      return unless logger
+      message = "[Rack::Parser] Error on %s : %s" % [type, error.to_s]
+      logger.warn message
+    end
   end
 end

data/rack-parser.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "rack-parser"
-  s.version     = "0.3.0"
+  s.version     = "0.4.0"
   s.authors     = ["Arthur Chiu"]
   s.email       = ["mr.arthur.chiu@gmail.com"]
   s.homepage    = "https://www.github.com/achiu/rack-parser"
@@ -18,9 +18,6 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency 'rack'
-  s.add_dependency 'multi_json'
-  s.add_dependency 'multi_xml', '>= 0.5.2'
-  s.add_development_dependency 'riot'
+  s.add_development_dependency 'minitest'
   s.add_development_dependency 'rack-test'
-  s.add_development_dependency 'json'
 end

data/spec/parser_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Rack::Parser do
+
+  it "allows you to setup parsers for content types" do
+    middleware = Rack::Parser.new ParserApp, :parsers => { 'foo' => 'bar' } 
+    assert_equal 'bar', middleware.parsers['foo']
+  end
+
+  it "allows you to setup error handlers" do
+    stack = Rack::Parser.new ParserApp, :handlers => { 'foo' => 'bar' } 
+    assert_equal 'bar', stack.handlers['foo']
+  end
+
+  it "parses a Content-Type" do
+    payload = JSON.dump(:a => 1)
+    parser = proc { |data| JSON.parse data }
+    stack Rack::Parser, :parsers => { 'application/json' => parser }
+    post '/post', payload, { 'CONTENT_TYPE' => 'application/json' }
+
+    assert last_response.ok?
+    assert_equal "{\"a\"=>1}", last_response.body
+  end
+
+  it "does nothing if unmatched Content-Type" do
+    payload = JSON.dump(:a => 1)
+    parser = proc { |data| JSON.parse data }
+    stack Rack::Parser, :parsers => { 'application/json' => parser }
+    post '/post', payload, { 'CONTENT_TYPE' => 'application/xml' }
+
+    assert last_response.ok?
+    assert_equal "{}", last_response.body # request.params won't pick up this content type
+  end
+
+  it "matches Content-Type by regex" do
+    payload = JSON.dump(:a => 2)
+    parser = proc { |data| JSON.parse data }
+    stack Rack::Parser, :parsers => { %r{json} => parser }
+    post '/post', payload, { 'CONTENT_TYPE' => 'application/vnd.foo+json' }
+
+    assert last_response.ok?
+    assert_equal "{\"a\"=>2}", last_response.body
+  end
+
+  it "handles upstream errors" do
+    assert_raises Exception, 'error!' do
+      parser = proc { |data| JSON.parse data }
+      stack Rack::Parser, :parsers => { %r{json} => parser }
+      post '/error', '{}', { 'CONTENT_TYPE' => 'application/json' }
+    end
+  end
+
+  it "returns a default error" do
+    parser  = proc { |data| raise Exception, 'wah wah' }
+    stack Rack::Parser, :parsers  => { %r{json} => parser } 
+    post '/post', '{}', { 'CONTENT_TYPE' => 'application/vnd.foo+json' }
+
+    assert_equal 400, last_response.status
+  end
+
+  it "returns a custom error message" do
+    parser  = proc { |data| raise Exception, "wah wah" }
+    handler = proc { |err, type| [500, {}, "%s : %s"  % [type, err]] }
+    stack Rack::Parser, :parsers  => { %r{json} => parser }, 
+                        :handlers => { %r{json} => handler }
+    post '/post', '{}', { 'CONTENT_TYPE' => 'application/vnd.foo+json' }
+
+    assert_equal 500, last_response.status
+    assert_equal 'application/vnd.foo+json : wah wah', last_response.body
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+gem 'minitest'
+require 'minitest/autorun'
+require 'rack'
+require 'rack/test'
+require 'rack/builder'
+require 'json'
+require File.expand_path('../../lib/rack/parser', __FILE__)
+
+class ParserApp
+  def call(env)
+    request = Rack::Request.new(env)
+    type    = { 'Content-Type' => 'text/plain' }
+    code, body =
+      case request.path
+      when '/'      then [200, 'Hello World']
+      when '/post'  then [200, request.params.inspect]
+      when '/error' then raise(Exception, 'error!')
+      else
+        [404, 'Nothing']
+      end
+    [code, type, body]
+  end
+end
+
+class Minitest::Spec
+  include Rack::Test::Methods
+
+  def app(*middleware)
+    @builder = Rack::Builder.new
+    @builder.use(*@stack)
+    @builder.run ParserApp.new
+    @builder.to_app
+  end
+
+  def stack(*middleware)
+    @stack = middleware
+  end
+end

metadata

@@ -1,97 +1,62 @@
 --- !ruby/object:Gem::Specification
 name: rack-parser
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
+  prerelease: 
 platform: ruby
 authors:
 - Arthur Chiu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-09 00:00:00.000000000 Z
+date: 2013-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: multi_xml
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.5.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.5.2
-- !ruby/object:Gem::Dependency
-  name: riot
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Rack Middleware for parsing post body data for json, xml and various
@@ -109,32 +74,32 @@ files:
 - Rakefile
 - lib/rack/parser.rb
 - rack-parser.gemspec
-- test/parser_test.rb
-- test/teststrap.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
 homepage: https://www.github.com/achiu/rack-parser
 licenses: []
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: rack-parser
-rubygems_version: 2.0.3
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Rack Middleware for parsing post body data
 test_files:
-- test/parser_test.rb
-- test/teststrap.rb
-has_rdoc: 
+- spec/parser_spec.rb
+- spec/spec_helper.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 669beb8cc96fc852dc771cd9c9a95639668c4e13
-  data.tar.gz: dc190ec4551249620a769cb0ee42a1157903f5c1
-SHA512:
-  metadata.gz: 7c957776b51e2325400b40bc52ac23fe7c0f7b175ec6ca20aa89329b8a93a12c362414e885b8ee5a5c14bcbb49796f93b11441bb7ff75d7dd811e199eba88bc6
-  data.tar.gz: d46f6696f9e4b74a84cb0157c8a2bc4130682592a6774a97d1fb4cf696687a7175f9697c4ae4d7bae915ab0e208c3f99bb3bf3b28db673f8cdcdeab0ab6d4886

data/test/parser_test.rb

@@ -1,100 +0,0 @@
-require File.expand_path('../teststrap', __FILE__)
-
-class FooApp
-  def call(env); env; end
-end
-
-context "Rack::Parser" do
-
-  context "default configuration" do
-    setup do
-      Rack::Parser.new(FooApp.new).content_types
-    end
-
-    asserts(:[],'application/xml').kind_of Proc
-    asserts(:[],'application/json').kind_of Proc
-  end
-
-  context "with custom configuration" do
-    setup do
-      Rack::Parser.new(FooApp.new, :content_types => {
-        'application/xml' => :meh,
-        'application/foo' => :bar
-      }).content_types
-    end
-
-    asserts(:[], 'application/xml').equals :meh
-    asserts(:[], 'application/foo').equals :bar
-  end
-
-  context "with json" do
-    setup do
-      post '/post', "{\"test\":1,\"foo\":2,\"bar\":\"3\"}", { 'CONTENT_TYPE' => 'application/json' }
-    end
-
-    asserts(:status).equals 200
-    asserts(:body).equals "{\"test\"=>1, \"foo\"=>2, \"bar\"=>\"3\"}"
-  end
-
-  context "with xml" do
-    setup do
-      put '/post', "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<hash>\n  <a type=\"integer\">1</a>\n</hash>\n", { 'CONTENT_TYPE' => 'application/xml'}
-    end
-
-    asserts(:status).equals 200
-    asserts(:body).equals "{\"hash\"=>{\"a\"=>1}}"
-  end
-
-  context "with custom 'foo'" do
-    setup do
-      post '/post', 'something that does not matter', { 'CONTENT_TYPE' => 'application/foo' }
-    end
-
-    asserts(:status).equals 200
-    asserts(:body).equals({'foo' => 'bar'}.inspect)
-  end
-
-  context "for errors" do
-
-    context "with default error message" do
-      setup do
-        post '/post', "fuuuuuuuuuu", { 'CONTENT_TYPE' => 'application/json' }
-      end
-
-      asserts(:status).equals 400
-      asserts(:body).matches %r!{"errors":"\d+: unexpected token at 'fuuuuuuuuuu'"}!
-    end
-
-    context "with custom default error message" do
-      setup do
-        post '/post', "fuuuuuuuuuu", { 'CONTENT_TYPE' => 'application/wahh' }
-      end
-
-      asserts(:status).equals 500
-      asserts(:body).equals "wahh"
-    end
-  end
-
-  context "for get with no content_type" do
-    setup { get '/' }
-
-    asserts(:status).equals 200
-    asserts(:body).matches %r{Hello world}
-  end
-
-  context "for get with unconcerned content_type" do
-    setup do
-      post '/post', 'foo=bar', { 'CONTENT_TYPE' => 'application/x-www-form-urlencoded' }
-    end
-
-    asserts(:status).equals 200
-    asserts(:body).equals({'foo' => 'bar'}.inspect)
-  end
-
-  context "for upstream errors" do
-    asserts('/error') do
-      post '/error', '{}', { 'CONTENT_TYPE' => 'application/json' }
-    end.raises(Exception, 'OOOPS!!')
-  end
-
-end

data/test/teststrap.rb

@@ -1,42 +0,0 @@
-require 'rack'
-require 'riot'
-require 'rack/test'
-require 'rack/builder'
-require 'json'
-
-require File.expand_path('../../lib/rack/parser', __FILE__)
-
-class Riot::Situation
-  include Rack::Test::Methods
-
-  def app
-    main_app = lambda { |env|
-      request = Rack::Request.new(env)
-      return_code, body_text =
-      case request.path
-      when '/' then [200,'Hello world']
-      when '/post'
-        [200,  Rack::Request.new(env).params]
-      when '/error'
-        raise Exception, 'OOOPS!!'
-      else
-        [404,'Nothing here']
-      end
-      [return_code,{'Content-type' => 'text/plain'}, [body_text]]
-    }
-
-    builder = Rack::Builder.new
-    builder.use Rack::Parser,
-      :content_types => {
-        'application/foo' => Proc.new { |b| {'foo' => 'bar'} } 
-      },
-      :error_responses => {
-        'application/wahh' => Proc.new { |e, content_type| [500,{'Content-Type' => content_type},['wahh']]}
-      }
-    builder.run main_app
-    builder.to_app
-  end
-end
-
-class Riot::Context
-end