jsonatra 1.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+.DS_Store
+tags
+jsonatra-*.gem

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gem 'sinatra'
+gem 'webmock'
+gem 'rack-test'
+gem 'pry'
+gem 'pry-nav'
+gem 'rake'

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2013 Esri, Inc
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,197 @@
+jsonatra
+========
+
+[![Build Status](https://travis-ci.org/esripdx/jsonatra.png?branch=master)](https://travis-ci.org/esripdx/jsonatra)
+
+This is a very opinionated gem. Some of its strongly held views:
+
+* [Sinatra](http://sinatrarb.com) is the BEST.
+* JSON is awesome!
+* REST is fo' suckas.
+* HTTP status codes are for **transport**!
+
+To that end, this gem subclasses `Sinatra::Base` and `Sinatra::Response` adding
+some helpful defaults to achieve the following goals:
+
+* always respond with JSON, route blocks' return hashes are automatically converted
+* all GET routes also respond to POST for large query values
+* accept form encoded **OR** JSON POST body parameters
+* always supply CORS headers
+* short-circuit OPTIONS requests
+* *application* errors (i.e. param validation) should still 200, respond with error object
+* 404s still 404 with a JSON body
+* have handy error helpers
+
+### Settings
+
+##### :arrayified_params
+
+Accepts all the following formats for the given param names, always turning it into an
+`Array` in the `params` hash.
+
+`set :arrayified_params, [:foo, :bar]`
+
+* formencoded name
+`(ex: tags[]=foo&tags[]=bar => ['foo', 'bar'])`
+
+* JSON POST body Array type
+`(ex: { "tags": ["foo", "bar"] } => ['foo', 'bar'])`
+
+* formencoded comma-separated
+`(ex: tags=foo%2Cbar => ['foo', 'bar'])`
+
+* JSON POST body comma-separated
+`(ex: { "tags": "foo,bar"] } => ['foo', 'bar'])`
+
+
+##### :camelcase_error_types
+
+For whatever reason, you may want to have camelCase goin' on. Here's to working with
+legacy systems, eh?
+
+`enable :camelcase_error_types`
+
+### Customizing Access Headers
+
+Standard [CORS](http://en.wikipedia.org/wiki/Cross-origin_resource_sharing) headers
+not enough? Customize everything about them with:
+
+```ruby
+class Example < Jsonatra::Base
+
+  def access_control_headers
+    if crazy_header_mode?
+      {
+        "these" => "headers",
+        "are" =>   "CRAZY"
+      }
+    else
+      Jsonatra::ACCESS_CONTROL_HEADERS
+    end
+  end
+
+end
+```
+
+### Example
+
+example `config.ru`:
+
+```ruby
+require 'jsonatra'
+
+class Foo < Jsonatra::Base
+
+  configure do
+    set :arrayified_params, [:foos]
+  end
+
+  get '/hi' do
+    { hello: "there", foos: params[:foos] }
+  end
+
+  get '/error' do
+    param_error :foo, 'type', 'message' unless params[:foo]
+    { you: "shouldn't", see: "this", unless: "foo" }
+  end
+
+  get '/halt_on_error' do
+    param_error :foo, 'type', 'message' unless params[:foo]
+    param_error :bar, 'type', 'message' unless params[:bar]
+
+    # since errors in the response always take precendence,
+    # halt if you need to just stop now
+    #
+    halt if response.error?
+
+    { you: "shouldn't", see: "this", unless: "foo", and: "bar" }
+  end
+
+end
+
+map '/' do
+  run Foo
+end
+```
+
+The above would respond like this:
+
+#### http://localhost:9292/hi?foos=bars,bats
+
+```
+< HTTP/1.1 200 OK
+< Content-Type: application/json;charset=utf-8
+< Access-Control-Allow-Origin: *
+< Access-Control-Allow-Methods: GET, POST
+< Access-Control-Allow-Headers: Accept, Authorization, Content-Type, Origin
+
+# ...
+
+{"hello":"there","foos":["bars","bats"]}
+```
+
+#### http://localhost:9292/hi?foos[]=bars&foos[]=bats
+
+```javascript
+{
+  "hello": "there",
+  "foos": [
+    "bars",
+    "bats"
+  ]
+}
+```
+
+#### http://localhost:9292/error
+
+```javascript
+{
+  "error": {
+    "type": "invalidInput",
+    "message": "invalid parameter or parameter value",
+    "parameters": {
+      "foo": [
+        {
+          "type": "type",
+          "message": "message"
+        }
+      ]
+    }
+  }
+}
+```
+
+#### http://localhost:9292/error?foo=bar
+
+```javascript
+{
+  "you": "shouldn't",
+  "see": "this",
+  "unless": "foo"
+}
+```
+
+#### http://localhost:9292/halt_on_error
+
+```javascript
+{
+  "error": {
+    "type": "invalidInput",
+    "message": "invalid parameter or parameter value",
+    "parameters": {
+      "foo": [
+        {
+          "type": "type",
+          "message": "message"
+        }
+      ],
+      "bar": [
+        {
+          "type": "type",
+          "message": "message"
+        }
+      ]
+    }
+  }
+}
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = ENV['TEST_PATTERN'] || "test/**/*_spec.rb"
+end
+
+task :default => :test

data/jsonatra.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/jsonatra/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Kenichi Nakamura"]
+  gem.email         = ["kenichi.nakamura@gmail.com"]
+  gem.description   = gem.summary = "An opinionated, non-ReST, JSON API extension for Sinatra"
+  gem.homepage      = "https://github.com/esripdx/jsonatra"
+  gem.files         = `git ls-files | grep -Ev '^(myapp|examples)'`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "jsonatra"
+  gem.require_paths = ["lib"]
+  gem.version       = Jsonatra::VERSION
+  gem.license       = 'apache'
+  gem.add_dependency 'sinatra'
+end

data/lib/jsonatra/helpers/error.rb

@@ -0,0 +1,18 @@
+module Jsonatra
+  module ErrorHelpers
+
+    # sets a default root error type and message if not present, and appends this
+    # error to the list for this parameter
+    #
+    def param_error parameter, type, message, &block
+      response.add_parameter_error parameter.to_sym, type, message, &block
+    end
+
+    # sets a default root error type and message if not present, and appends this
+    # error to the list for this header
+    #
+    def header_error header, type, message, &block
+      response.add_header_error header, type, message, &block
+    end
+  end
+end

data/lib/jsonatra/helpers/params.rb

@@ -0,0 +1,85 @@
+module Jsonatra
+  module ParamsHelpers
+
+    JSON_CONTENT_TYPE = 'application/json'.freeze
+
+    # merges JSON POST body data over query params if provided
+    #
+    def params
+      unless @_params_hash
+        @_params_hash = super
+
+        # if we see what looks like JSON data, but have no Content-Type header...
+        #
+        if request.content_type.nil? or request.content_type == ''
+          check_for_content_type_mismatch
+        else
+          content_type_header = request.content_type.split ';'
+          if content_type_header.include? JSON_CONTENT_TYPE
+            begin
+              json_params_hash = JSON.parse request.body.read
+              @_params_hash.merge! json_params_hash unless json_params_hash.nil?
+            rescue JSON::ParserError => e
+              begin
+                msg = e.message.match(/\d+: (.+)/).captures.first
+              rescue NoMethodError => noe
+                msg = e.message
+              end
+              response.error = {
+                type: 'json_parse_error',
+                message: "could not process JSON: #{msg}"
+              }
+              halt
+            end
+
+            request.body.rewind
+          else
+            check_for_content_type_mismatch
+          end
+        end
+
+        if settings.respond_to? :arrayified_params and settings.arrayified_params
+          settings.arrayified_params.each do |param_name|
+            array_or_comma_sep_param param_name
+          end
+        end
+
+      end
+      @_params_hash
+    end
+
+    private
+
+    # convert param value to `Array` if String
+    #
+    #   * formencoded name
+    #       (ex: tags[]=foo&tags[]=bar => ['foo', 'bar'])
+    #   * JSON POST body Array type
+    #       (ex: { "tags": ["foo", "bar"] } => ['foo', 'bar'])
+    #   * formencoded comma-separated
+    #       (ex: tags=foo%2Cbar => ['foo', 'bar'])
+    #   * JSON POST body comma-separated
+    #       (ex: { "tags": "foo,bar"] } => ['foo', 'bar'])
+    #
+    def array_or_comma_sep_param param_name
+      if @_params_hash[param_name] and String === @_params_hash[param_name]
+        @_params_hash[param_name] = @_params_hash[param_name].split ','
+      end
+    end
+
+    # halt with a contentTypeMismatch error
+    #
+    def check_for_content_type_mismatch
+      body = request.body.read
+      request.body.rewind
+      if body =~ /^[\{\[].*[\}\]]$/
+        response.error = {
+          type: 'content_type_mismatch',
+          message: 'Request looks like JSON but Content-Type header was not set to application/json'
+        }
+        halt
+      end
+    end
+
+  end
+end

data/lib/jsonatra/response.rb

@@ -0,0 +1,85 @@
+module Jsonatra
+  class Response < Sinatra::Response
+
+    # do a `response.override_processing = true` in your route if you need to
+    #
+    @override_processing = false
+    attr_accessor :override_processing
+
+    # set this and the `content_type` in the `before` filter
+    #
+    attr_writer :jsonp_callback
+
+    # new #finish method to handle error reporting and json(p)-ification
+    #
+    alias sinatra_finish finish
+    def finish
+      unless @override_processing
+        if self.error?
+          self.body = {error: @error.delete_if {|k,v| v.nil?}}.to_json
+        else
+
+          # TODO what if there are more elements in the array?
+          #
+          if Array === self.body
+            self.body = self.body[0]
+
+            # JSON is not valid unless it's "{}" or "[]"
+            #
+            self.body ||= {}
+          end
+
+          if Hash === self.body
+            json_body = self.body.to_json
+            if @jsonp_callback
+              self.body = "#{@jsonp_callback}(#{json_body});"
+            else
+              self.body = json_body
+            end
+          end
+        end
+      end
+      sinatra_finish
+    end
+
+    # new methods for adding and appending errors
+    #
+    attr_writer :error
+
+    def error
+      @error ||= {}
+      @error
+    end
+
+    def error?; !error.empty?; end
+
+    def add_parameter_error parameter, type, message
+      error[:type] ||= 'invalid_input'
+      error[:message] ||= 'invalid parameter or parameter value'
+      error[:parameters] ||= {}
+      error[:parameters][parameter.to_sym] ||= []
+      yield error if block_given?
+      error[:parameters][parameter.to_sym] << {type: type, message: message}
+    end
+
+    def add_header_error header, type, message
+      error[:type] ||= 'invalid_header'
+      error[:message] ||= 'invalid header or header value'
+      error[:headers] ||= {}
+      error[:headers][header.to_sym] ||= []
+      yield error if block_given?
+      error[:headers][header.to_sym] << {type: type, message: message}
+    end
+
+    def camelcase_error_types
+      error[:type] = error[:type].camelcase
+      if error[:headers]
+        error[:headers].each {|k,v| v.each {|he| he[:type] = he[:type].camelcase}}
+      end
+      if error[:parameters]
+        error[:parameters].each {|k,v| v.each {|pe| pe[:type] = pe[:type].camelcase}}
+      end
+    end
+
+  end
+end

data/lib/jsonatra/version.rb

@@ -0,0 +1,3 @@
+module Jsonatra
+  VERSION = '1.0.2'
+end

data/lib/jsonatra.rb

@@ -0,0 +1,149 @@
+require 'sinatra/base'
+require 'json'
+
+require 'jsonatra/response'
+require 'jsonatra/helpers/error'
+require 'jsonatra/helpers/params'
+
+module Jsonatra
+
+  ACCESS_CONTROL_HEADERS = {
+    'Access-Control-Allow-Origin' => '*',
+    'Access-Control-Allow-Methods' => 'GET, POST',
+    'Access-Control-Allow-Headers' => 'Accept, Authorization, Content-Type, Origin'
+  }
+
+  class Base < Sinatra::Base
+
+    helpers ErrorHelpers
+    helpers ParamsHelpers
+
+    # copied here so we can override Response.new with Jsonatra::Response.new
+    #
+    # https://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb#L880
+    #
+    def call!(env) # :nodoc:
+      @env      = env
+      @request  = ::Sinatra::Request.new(env)
+      @response = ::Jsonatra::Response.new
+      @params   = indifferent_params(@request.params)
+      template_cache.clear if settings.reload_templates
+      force_encoding(@params)
+
+      @response['Content-Type'] = nil
+      invoke { dispatch! }
+      invoke { error_block!(response.status) } unless @env['sinatra.error']
+
+      unless @response['Content-Type']
+        if Array === body and body[0].respond_to? :content_type
+          content_type body[0].content_type
+        else
+          content_type :html
+        end
+      end
+
+      @response.finish
+    end
+
+    configure do
+      disable :show_exceptions
+      disable :protection
+    end
+
+    before do
+
+      # default to Content-Type to JSON, or javascript if request is JSONP
+      #
+      content_type :json
+      unless params[:callback].nil? or params[:callback] == ''
+        halt param_error(:callback, :invalid, 'invalid callback') if params[:callback].index('"')
+        response.jsonp_callback = params[:callback]
+        content_type :js
+      end
+
+      # grok access control headers
+      #
+      achs = begin
+               self.access_control_headers
+             rescue NoMethodError
+               ACCESS_CONTROL_HEADERS
+             end
+
+      # immediately return on OPTIONS
+      #
+      if request.request_method == 'OPTIONS'
+        halt [200, achs, '']
+      end
+
+      # allow origin, oauth from everywhere
+      #
+      achs.each {|k,v| headers[k] = v}
+
+    end
+
+    after do
+      if settings.respond_to? :camelcase_error_types? and settings.camelcase_error_types?
+        response.camelcase_error_types if response.error?
+      end
+    end
+
+    error do
+      response.error = {
+        type: :unexpected,
+        message: 'An unexpected error has occured, please try your request again later'
+      }
+    end
+
+    # sinatra installs special handlers during development
+    # this runs the "real" `not_found` block instead
+    #
+    error(Sinatra::NotFound){ not_found } if development?
+
+    # set error values for JSON 404 response body
+    #
+    not_found do
+      response.error = {
+        type: :not_found,
+        message: "The requested path was not found: #{request.path}"
+      }
+    end
+
+    class << self
+
+      # because some parameters can be too large for normal GET query strings,
+      # all GET routes also accept a POST with body data, with the same parameter
+      # names and behavior
+      #
+      alias_method :sinatra_get, :get
+      def get(*args, &block)
+        sinatra_get *args, &block
+        post *args, &block
+      end
+    end
+
+  end
+
+end
+
+
+class String
+  # ripped from:
+  # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+  #
+  unless instance_methods.include? :camelcase
+    def camelcase
+      string = self.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!('/', '::')
+      string
+    end
+  end
+end
+
+class Symbol
+  unless instance_methods.include? :camelcase
+    def camelcase
+      self.to_s.camelcase.to_sym
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,61 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'rack/test'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'pry'
+require 'pry-nav'
+
+$:.push File.expand_path '../../lib', __FILE__
+require 'jsonatra'
+
+include Rack::Test::Methods
+
+def app
+  @controller
+end
+
+def mock_app &block
+  @controller = Sinatra.new Jsonatra::Base, &block
+end
+
+def r
+  JSON.parse last_response.body
+end
+
+def get_and_post *args, &block
+  get *args
+  yield
+  setup
+  post *args
+  yield
+end
+
+JSON_CT = { 'CONTENT_TYPE' => 'application/json' }
+def post_json path, params = {}, headers = {}
+  post path, params.to_json, headers.merge(JSON_CT)
+end
+
+def get_and_post_and_post_json path, params = {}, headers = {}, &block
+  get_and_post path, params, headers, &block
+  post_json path, params, headers, &block
+end
+alias gapapj get_and_post_and_post_json
+
+def must_have_parameter_error_for parameter, type = :invalid, error_type = :invalid_input
+  last_response.status.must_equal 200
+  r['error'].wont_be_nil
+  r['error']['type'].must_equal error_type.to_s
+  r['error']['parameters'].wont_be_nil
+  r['error']['parameters'][parameter.to_s].wont_be_empty
+  r['error']['parameters'][parameter.to_s].first['type'].must_equal type.to_s
+end
+
+def must_have_header_error_for header, type = :invalid, error_type = :invalid_header
+  last_response.status.must_equal 200
+  r['error'].wont_be_nil
+  r['error']['type'].must_equal error_type.to_s
+  r['error']['headers'].wont_be_nil
+  r['error']['headers'][header.to_s].wont_be_empty
+  r['error']['headers'][header.to_s].first['type'].must_equal type.to_s
+end

data/test/helpers/error_spec.rb

@@ -0,0 +1,121 @@
+require_relative '../helper'
+
+describe Jsonatra::ErrorHelpers do
+
+  before do
+    mock_app do
+      get '/pe' do
+        param_error :foo, :invalid, 'foo bar'
+      end
+      get '/he' do
+        header_error :foo, :invalid, 'foo bar'
+      end
+
+      get '/pec' do
+        param_error :foo, :invalid, 'foo bar' do |e|
+          e[:code] = 401
+        end
+      end
+      get '/hec' do
+        header_error :foo, :invalid, 'foo bar' do |e|
+          e[:code] = 498
+        end
+      end
+    end
+  end
+
+  describe '404 handler' do
+
+    it 'includes code: 404 in the json body of the response' do
+      get '/not_found'
+      last_response.status.must_equal 404
+    end
+
+  end
+
+  describe 'param_error' do
+
+    it 'creates error messages properly' do
+      gapapj '/pe' do
+        must_have_parameter_error_for :foo
+        r['error']['parameters']['foo'].first['message'].must_equal 'foo bar'
+      end
+    end
+
+    it 'can arbitrarily add to error object' do
+      gapapj '/pec' do
+        must_have_parameter_error_for :foo
+        r['error']['code'].must_equal 401
+      end
+    end
+
+  end
+
+  describe 'header_error' do
+
+    it 'creates error messages properly' do
+      gapapj '/he' do
+        must_have_header_error_for :foo
+        r['error']['headers']['foo'].first['message'].must_equal 'foo bar'
+      end
+    end
+
+    it 'can arbitrarily add to error object' do
+      gapapj '/hec' do
+        must_have_header_error_for :foo
+        r['error']['code'].must_equal 498
+      end
+    end
+
+  end
+
+  describe 'camelcase_error_tyeps' do
+
+    before do
+      mock_app do
+        configure do
+          enable :camelcase_error_types
+        end
+        get '/pe' do
+          param_error :foo, :snakey_snake, 'foo bar'
+        end
+        get '/he' do
+          header_error :foo, :snakey_snake, 'foo bar'
+        end
+      end
+    end
+
+    it 'camelcases parameter error types' do
+      gapapj '/pe' do
+        must_have_parameter_error_for :foo, :snakeySnake, :invalidInput
+      end
+    end
+
+    it 'camelcases header error types' do
+      gapapj '/he' do
+        must_have_header_error_for :foo, :snakeySnake, :invalidHeader
+      end
+    end
+
+    describe 'contentTypeMismatch' do
+
+      before do
+        mock_app do
+          configure do
+            enable :camelcase_error_types
+          end
+          get '/params' do
+            params
+          end
+        end
+      end
+
+      it 'returns an informative error if it notices JSON content without correct header' do
+        post '/params', {foo: 'bar', baz: 42, bat: ['a', 1, 5.75, true]}.to_json
+        r['error'].wont_be_nil
+        r['error']['type'].must_equal "contentTypeMismatch"
+      end
+
+    end
+  end
+end

data/test/helpers/params_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../helper'
+
+describe Jsonatra::ParamsHelpers do
+
+  before do
+    mock_app do
+      get '/params' do
+        params
+      end
+    end
+  end
+
+  it 'returns request params same as default for GET requests' do
+    get '/params', foo: 'bar', baz: 42, bat: ['a', 1, 5.75, true]
+    r['foo'].must_equal 'bar'
+    r['baz'].must_equal '42'
+    r['bat'][0].must_equal 'a'
+    r['bat'][1].must_equal '1'
+    r['bat'][2].must_equal '5.75'
+    r['bat'][3].must_equal 'true'
+  end
+
+  it 'returns request form encoded params same as default for POST requests' do
+    post '/params', foo: 'bar', baz: 42, bat: ['a', 1, 5.75, true]
+    r['foo'].must_equal 'bar'
+    r['baz'].must_equal '42'
+    r['bat'][0].must_equal 'a'
+    r['bat'][1].must_equal '1'
+    r['bat'][2].must_equal '5.75'
+    r['bat'][3].must_equal 'true'
+  end
+
+  it 'parses and returns JSON data POSTed in the request body' do
+    post_json '/params', foo: 'bar', baz: 42, bat: ['a', 1, 5.75, true]
+    r['foo'].must_equal 'bar'
+    r['baz'].must_equal 42
+    r['bat'][0].must_equal 'a'
+    r['bat'][1].must_equal 1
+    r['bat'][2].must_equal 5.75
+    r['bat'][3].must_equal true
+  end
+
+  it 'JSON data POSTed in the request body overrides default params' do
+    qs = Rack::Utils.escape({ foo: 'baR', baz: 43, bat: ['A', 2, 5.76, false] })
+    post_json "/params?#{qs}", foo: 'bar', baz: 42, bat: ['a', 1, 5.75, true]
+    r['foo'].must_equal 'bar'
+    r['baz'].must_equal 42
+    r['bat'][0].must_equal 'a'
+    r['bat'][1].must_equal 1
+    r['bat'][2].must_equal 5.75
+    r['bat'][3].must_equal true
+  end
+
+  it 'returns an informative error if it notices JSON content without correct header' do
+    post '/params', {foo: 'bar', baz: 42, bat: ['a', 1, 5.75, true]}.to_json
+    r['error'].wont_be_nil
+    r['error']['type'].must_equal "content_type_mismatch"
+
+    post '/params', ['a', 1, 5.75, true].to_json
+    r['error'].wont_be_nil
+    r['error']['type'].must_equal "content_type_mismatch"
+
+    post '/params', {foo: 'bar', baz: 42, bat: ['a', 1, 5.75, true]}.to_json, {'Content-Type' => 'text/plain'}
+    r['error'].wont_be_nil
+    r['error']['type'].must_equal "content_type_mismatch"
+
+    post '/params', ['a', 1, 5.75, true].to_json, {'Content-Type' => 'text/plain'}
+    r['error'].wont_be_nil
+    r['error']['type'].must_equal "content_type_mismatch"
+  end
+
+end

data/test/jsonatra_spec.rb

@@ -0,0 +1,133 @@
+require_relative './helper'
+
+describe Jsonatra::Base do
+
+  HI = {
+    'hello' =>  'there',
+    'scinot' => -122.67641415934295823498407,
+    'foo' =>    42,
+    'bar' =>    true,
+    'baz' =>    false
+  }
+
+  before do
+    mock_app do
+      configure do
+        set :arrayified_params, ['foos']
+      end
+      get('/'){}
+      get('/hi'){ HI }
+      get('/aps'){ {foos: params[:foos]} }
+    end
+  end
+
+  describe 'basics' do
+
+    it 'delivers empty object for nil returning routes' do
+      gapapj '/' do
+        r.must_equal({})
+      end
+    end
+
+    it 'sets content type to json' do
+      gapapj '/' do
+        ct = last_response.content_type.split(';')
+        ct.must_include Rack::Mime::MIME_TYPES['.json']
+      end
+    end
+
+    it 'sets content type to js if callback param' do
+      gapapj '/', { callback: 'foo' } do
+        ct = last_response.content_type.split(';')
+        ct.must_include Rack::Mime::MIME_TYPES['.js']
+      end
+    end
+
+    it 'returns json from routes that return hashes' do
+      gapapj '/hi' do
+        r.must_equal HI
+      end
+    end
+
+  end
+
+  describe 'jsonp' do
+
+    it 'wraps response object in func call if callback param' do
+      gapapj '/', callback: 'foo' do
+        last_response.body.must_equal 'foo({});'
+      end
+    end
+
+    it 'errors if callback contains double quote char' do
+      get '/', callback: 'foo"bar"baz'
+      must_have_parameter_error_for :callback
+    end
+
+  end
+
+  describe 'arrayified params' do
+
+    it 'returns an array when an array is given' do
+      a = ['foo', 'bar']
+      get '/aps', foos: a
+      r['foos'].must_equal a
+      post '/aps', foos: a
+      r['foos'].must_equal a
+    end
+
+    it 'returns an array when a comma-separated string is given' do
+      a = ['foo', 'bar']
+      get '/aps', foos: a.join(',')
+      r['foos'].must_equal a
+      post '/aps', foos: a.join(',')
+      r['foos'].must_equal a
+    end
+
+    it 'returns nil if nothing was given' do
+      get '/aps'
+      r['foos'].must_be_nil
+      post '/aps'
+      r['foos'].must_be_nil
+    end
+
+  end
+
+  describe 'CORS header' do
+
+    it 'responds with headers containing an open allow origin policy' do
+      [:get, :post, :options].each do |meth|
+        __send__ meth, '/'
+        last_response.headers.keys.must_include 'Access-Control-Allow-Origin'
+        last_response.headers['Access-Control-Allow-Origin'].must_equal '*'
+        last_response.headers.keys.must_include 'Access-Control-Allow-Headers'
+        last_response.headers['Access-Control-Allow-Headers'].must_equal 'Accept, Authorization, Content-Type, Origin'
+        last_response.headers.keys.must_include 'Access-Control-Allow-Methods'
+        last_response.headers['Access-Control-Allow-Methods'].must_equal 'GET, POST'
+      end
+    end
+
+  end
+
+  describe 'access_control_headers' do
+
+    before do
+      mock_app do
+        def access_control_headers
+          { 'header_fu' => 'value_fu' }
+        end
+        get('/'){}
+      end
+    end
+
+    it 'responds with headers customized by app' do
+      [:get, :post, :options].each do |meth|
+        __send__ meth, '/'
+        last_response.headers.keys.must_include 'header_fu'
+        last_response.headers['header_fu'].must_equal 'value_fu'
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: jsonatra
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Kenichi Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  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'
+description: An opinionated, non-ReST, JSON API extension for Sinatra
+email:
+- kenichi.nakamura@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- jsonatra.gemspec
+- lib/jsonatra.rb
+- lib/jsonatra/helpers/error.rb
+- lib/jsonatra/helpers/params.rb
+- lib/jsonatra/response.rb
+- lib/jsonatra/version.rb
+- test/helper.rb
+- test/helpers/error_spec.rb
+- test/helpers/params_spec.rb
+- test/jsonatra_spec.rb
+homepage: https://github.com/esripdx/jsonatra
+licenses:
+- apache
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: An opinionated, non-ReST, JSON API extension for Sinatra
+test_files:
+- test/helper.rb
+- test/helpers/error_spec.rb
+- test/helpers/params_spec.rb
+- test/jsonatra_spec.rb