interpol 0.0.1

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in interpol.gemspec
+gemspec
+
+group :extras do
+  gem 'debugger' if RUBY_ENGINE == 'ruby' && RUBY_VERSION == '1.9.3'
+end
+
+gem 'json-jruby', platform: 'jruby'

data/License

@@ -0,0 +1,22 @@
+Copyright (c) 2012 SEOmoz
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,263 @@
+# Interpol
+
+[![Build Status](https://secure.travis-ci.org/seomoz/interpol.png)](http://travis-ci.org/seomoz/interpol)
+
+Interpol is a toolkit for policing your HTTP JSON interface. To use it,
+define the endpoints of your HTTP API in simple YAML files.
+Interpol provides multiple tools to work with these endpoint
+definitions:
+
+* `Interpol::TestHelper::RSpec` and `Interpol::TestHelper::TestUnit` are
+  modules that you can mix in to your test context. They provide a means
+  to generate tests from your endpoint definitions that validate example
+  data against your JSON schema definition.
+* `Interpol::StubApp` builds a stub implementation of your API from
+  the endpoint definitions. This can be distributed with your API's
+  client gem so that API users have something local to hit that
+  generates data that is valid according to your schema definition.
+* `Interpol::ResponseSchemaValidator` is a rack middleware that
+  validates your API responses against the JSON schema in your endpoint
+  definition files. This is useful in test/development environments to
+  ensure that your real API returns valid responses.
+* A documentation browser for your API is planned as well (but not yet
+  implemented).
+
+You can use any of these tools individually or some combination of all
+of them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'interpol'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install interpol
+
+## Endpoint Definition
+
+Endpoints are defined in YAML files, using a separate
+file per endpoint. Here's an example:
+
+``` yaml
+---
+name: user_projects
+route: /users/:user_id/projects
+method: GET
+definitions:
+  - versions: ["1.0"]
+    schema:
+      description: Returns a list of projects for the given user.
+      type: object
+      properties:
+        projects:
+          description: List of projects.
+          type: array
+          items:
+            type: object
+            properties:
+              name:
+                description: The name of the project.
+                type: string
+              importance:
+                description: The importance of the project, on a scale of 1 to 10.
+                type: integer
+                minimum: 1
+                maximum: 10
+
+    examples:
+      - projects:
+        - name: iPhone App
+          importance: 5
+        - name: Rails App
+          importance: 7
+```
+
+Let's look at this YAML file, point-by-point:
+
+* `name` can be anything you want. Each endpoint should have a different name. Interpol uses
+  it in schema validation error messages.
+* `route` defines the sinatra route for this endpoint. Note that while
+  Interpol::StubApp supports any sinatra route, Interpol::ResponseSchemaValidator
+  (which has to find a matching endpoint definition from the request path), only
+  supports a subset of Sinatra's routing syntax. Specifically, it supports static
+  segments (`users` and `projects` in the example above) and named
+  parameter segments (`:user_id` in the example above).
+* `method` defines the HTTP method for this endpoint.  The method should be in uppercase.
+* The `definitions` array contains a list of versioned schema definitions, with
+  corresponding examples.  Everytime you modify your schema and change the version,
+  you should add a new entry here.
+* The `versions` array lists the endpoint versions that should be associated with a
+  particular schema definition.
+* The `schema` contains a [JSON schema](http://tools.ietf.org/html/draft-zyp-json-schema-03)
+  description of the contents of the endpoint. This schema definition is used by the
+  `SchemaValidation` middleware to ensure that your implementation of the endpoint
+  matches the definition.
+* `examples` contains a list of valid example data. It is used by the stub app as example data.
+
+## Configuration
+
+Interpol provides two levels of configuration: global default
+configuration, and one-off configuration, set on a particular
+instance of one of the provided tools. Each of the tools accepts
+a configuration block that provides an identical API to the
+global configuration API shown below.
+
+``` ruby
+require 'interpol'
+
+Interpol.default_configuration do |config|
+  # Tells Interpol where to find your endpoint definition files.
+  #
+  # Needed by all tools.
+  config.endpoint_definition_files = Dir["config/endpoints/*.yml"]
+
+  # Determines which versioned endpoint definition Interpol uses
+  # for a request. You can also use a block form, which yields
+  # the rack env hash and the endpoint object as arguments.
+  # This is useful when you need to extract the version from a
+  # request header (e.g. Accept) or from the request URI.
+  #
+  # Needed by Interpol::StubApp and Interpol::ResponseSchemaValidator.
+  config.api_version '1.0'
+
+  # Determines the stub app response when the requested version is not
+  # available. This block will be eval'd in the context of the stub app
+  # sinatra application, so you can use sinatra helpers like `halt` here.
+  #
+  # Needed by Interpol::StubApp.
+  config.on_unavailable_request_version do |requested_version, available_versions|
+    message = JSON.dump(
+      "message" => "Not Acceptable",
+      "requested_version" => requested_version,
+      "available_versions" => available_versions
+    )
+
+    halt 406, message
+  end
+
+  # Determines which responses will be validated against the endpoint
+  # definition when you use Interpol::ResponseSchemaValidator. The
+  # validation is meant to run against the "happy path" response.
+  # For responses like "404 Not Found", you probably don't want any
+  # validation performed. The default validate_if hook will cause
+  # validation to run against any 2xx response except 204 ("No Content").
+  #
+  # Used by Interpol::ResponseSchemaValidator.
+  config.validate_if do |env, status, headers, body|
+    headers['Content-Type'] == my_custom_mime_type
+  end
+
+  # Determines how Interpol::ResponseSchemaValidator handles
+  # invalid data. By default it will raise an error, but you can
+  # make it print a warning instead.
+  #
+  # Used by Interpol::ResponseSchemaValidator.
+  config.validation_mode = :error # or :warn
+end
+
+```
+
+## Tool Usage
+
+### Interpol::TestHelper::RSpec and Interpol::TestHelper::TestUnit
+
+These are modules that you can extend onto an RSpec example group
+or a `Test::Unit::TestCase` subclass, respectively.
+They provide a `define_interpol_example_tests` macro that will define
+a test for each example for each schema definition in your endpoint
+definition files. The tests will validate that your schema is a valid
+JSON schema definition and will validate that the examples are valid
+according to that schema.
+
+RSpec example:
+
+``` ruby
+require 'interpol/test_helper'
+
+describe "My API endpoints" do
+  extend Interpol::TestHelper::RSpec
+
+  # the block is only necessary if you want to override the default
+  # config or if you have not set a default config.
+  define_interpol_example_tests do |ipol|
+    ipol.endpoint_definition_files = Dir["config/endpoints_definitions/*.yml"]
+  end
+end
+```
+
+Test::Unit example:
+
+``` ruby
+require 'interpol/test_helper'
+
+class MyAPIEndpointsTest < Test::Unit::TestCase
+  extend Interpol::TestHelper::TestUnit
+  define_interpol_example_tests
+end
+```
+
+### Interpol::StubApp
+
+This will build a little sinatra app that returns example data from
+your endpoint definition files.
+
+Example:
+
+``` ruby
+# config.ru
+
+require 'interpol/stub_app'
+
+# the block is only necessary if you want to override the default
+# config or if you have not set a default config.
+stub_app = Interpol::StubApp.build do |app|
+  app.endpoint_definition_files = Dir["config/endpoints_definitions/*.yml"]
+  app.api_version do |env|
+    RequestVersion.extract_from(env['HTTP_ACCEPT'])
+  end
+end
+
+run stub_app
+```
+
+### Interpol::ResponseSchemaValidator
+
+This rack middleware validates the responses from your app
+against the schema definition. Here's an example of how you
+might use it with a class-style sinatra app:
+
+``` ruby
+require 'sinatra'
+
+# You probably only want to validate the schema in local development.
+unless ENV['RACK_ENV'] == 'production'
+  require 'interpol/response_schema_validator'
+
+  # the block is only necessary if you want to override the default
+  # config or if you have not set a default config.
+  use Interpol::ResponseSchemaValidator do |config|
+    config.endpoint_definition_files = Dir["config/endpoints_definitions/*.yml"]
+    config.api_version do |env|
+      RequestVersion.extract_from(env['HTTP_ACCEPT'])
+    end
+  end
+end
+
+get '/users/:user_id/projects' do
+  JSON.dump(User.find(params[:user_id]).projects)
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,23 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--profile --format progress]
+  t.ruby_opts  = "-Ispec -rsimplecov_setup"
+end
+
+if RUBY_ENGINE == 'ruby' # MRI only
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.abc_max = 12
+    cane.add_threshold 'coverage/coverage_percent.txt', :==, 100
+    cane.style_measure = 100
+  end
+else
+  task(:quality) { } # no-op
+end
+
+task default: [:spec, :quality]

data/lib/interpol/configuration.rb

@@ -0,0 +1,101 @@
+require 'interpol/endpoint'
+require 'interpol/errors'
+require 'yaml'
+
+module Interpol
+  module DefinitionFinder
+    include HashFetcher
+    NoDefinitionFound = Class.new
+
+    def find_definition(method, path)
+      with_endpoint_matching(method, path) do |endpoint|
+        version = yield endpoint
+        endpoint.definitions.find { |d| d.version == version }
+      end
+    end
+
+  private
+
+    def with_endpoint_matching(method, path)
+      method = method.downcase.to_sym
+      endpoint = find { |e| e.method == method && e.route_matches?(path) }
+      (yield endpoint if endpoint) || NoDefinitionFound
+    end
+  end
+
+  # Public: Defines interpol configuration.
+  class Configuration
+    attr_reader :endpoint_definition_files, :endpoints
+    attr_accessor :validation_mode
+
+    def initialize
+      api_version do
+        raise ConfigurationError, "api_version has not been configured"
+      end
+
+      validate_if do |env, status, headers, body|
+        (200..299).cover?(status) && status != 204 # No Content
+      end
+
+      on_unavailable_request_version do |requested, available|
+        message = "The requested API version is invalid. " +
+                  "Requested: #{requested}. " +
+                  "Available: #{available}"
+        halt 406, JSON.dump(error: message)
+      end
+
+      self.endpoint_definition_files = []
+      yield self if block_given?
+    end
+
+    def endpoint_definition_files=(files)
+      self.endpoints = files.map do |file|
+        Endpoint.new(YAML.load_file file)
+      end
+      @endpoint_definition_files = files
+    end
+
+    def endpoints=(endpoints)
+      @endpoints = endpoints.extend(DefinitionFinder)
+    end
+
+    def api_version(version=nil, &block)
+      if [version, block].compact.size.even?
+        raise ConfigurationError.new("api_version requires a static version " +
+                                     "or a dynamic block, but not both")
+      end
+
+      @api_version_block = block || lambda { |*a| version }
+    end
+
+    def api_version_for(rack_env, endpoint=nil)
+      @api_version_block.call(rack_env, endpoint).to_s
+    end
+
+    def validate_if(&block)
+      @validate_if_block = block
+    end
+
+    def validate?(*args)
+      @validate_if_block.call(*args)
+    end
+
+    def on_unavailable_request_version(&block)
+      @unavailable_request_version_block = block
+    end
+
+    def request_version_unavailable(execution_context, *args)
+      execution_context.instance_exec(*args, &@unavailable_request_version_block)
+    end
+
+    def self.default
+      @default ||= Configuration.new
+    end
+
+    def customized_duplicate(&block)
+      block ||= lambda { |c| }
+      dup.tap(&block)
+    end
+  end
+end
+

data/lib/interpol/endpoint.rb

@@ -0,0 +1,133 @@
+require 'json-schema'
+require 'interpol/errors'
+
+module Interpol
+  module HashFetcher
+    # Unfortunately, on JRuby 1.9, the error raised from Hash#fetch when
+    # the key is not found does not include the key itself :(. So we work
+    # around it here.
+    def fetch_from(hash, key)
+      hash.fetch(key) do
+        raise ArgumentError.new("key not found: #{key.inspect}")
+      end
+    end
+  end
+
+  # Represents an endpoint. Instances of this class are constructed
+  # based on the endpoint definitions in the YAML files.
+  class Endpoint
+    include HashFetcher
+    attr_reader :name, :route, :method
+
+    def initialize(endpoint_hash)
+      @name        = fetch_from(endpoint_hash, 'name')
+      @route       = fetch_from(endpoint_hash, 'route')
+      @method      = fetch_from(endpoint_hash, 'method').downcase.to_sym
+      @definitions = extract_definitions_from(endpoint_hash)
+    end
+
+    def find_example_for!(version)
+      d = @definitions.fetch(version) do
+        message = "No definition found for #{name} endpoint for version #{version}"
+        raise ArgumentError.new(message)
+      end
+      d.examples.first
+    end
+
+    def available_versions
+      definitions.map(&:version)
+    end
+
+    def definitions
+      @definitions.values.sort_by(&:version)
+    end
+
+    def route_matches?(path)
+      path =~ route_regex
+    end
+
+  private
+
+    def route_regex
+      @route_regex ||= begin
+        regex_string = route.split('/').map do |path_part|
+          if path_part.start_with?(':')
+            '[^\/]+' # it's a parameter; match anything
+          else
+            Regexp.escape(path_part)
+          end
+        end.join('\/')
+
+        /\A#{regex_string}\z/
+      end
+    end
+
+    def extract_definitions_from(endpoint_hash)
+      definitions = {}
+
+      fetch_from(endpoint_hash, 'definitions').each do |definition|
+        fetch_from(definition, 'versions').each do |version|
+          definitions[version] = EndpointDefinition.new(self, version, definition)
+        end
+      end
+
+      definitions
+    end
+  end
+
+  # Wraps a single versioned definition for an endpoint.
+  # Provides the means to validate data against that version of the schema.
+  class EndpointDefinition
+    include HashFetcher
+    attr_reader :endpoint, :version, :schema, :examples
+
+    def initialize(endpoint, version, definition)
+      @endpoint = endpoint
+      @version  = version
+      @schema   = fetch_from(definition, 'schema')
+      @examples = fetch_from(definition, 'examples').map { |e| EndpointExample.new(e, self) }
+      make_schema_strict!(@schema)
+    end
+
+    def validate_data!(data)
+      errors = ::JSON::Validator.fully_validate_schema(schema)
+      raise ValidationError.new(errors, nil, description) if errors.any?
+      errors = ::JSON::Validator.fully_validate(schema, data)
+      raise ValidationError.new(errors, data, description) if errors.any?
+    end
+
+    def description
+      "#{endpoint.name} (v. #{version})"
+    end
+
+  private
+
+    def make_schema_strict!(raw_schema, modify_object=true)
+      return unless Hash === raw_schema
+
+      raw_schema.each do |key, value|
+        make_schema_strict!(value, key != 'properties')
+      end
+
+      return unless modify_object
+
+      raw_schema['additionalProperties'] = false
+      raw_schema['required'] = !raw_schema.delete('optional')
+    end
+  end
+
+  # Wraps an example for a particular endpoint entry.
+  class EndpointExample
+    attr_reader :data, :definition
+
+    def initialize(data, definition)
+      @data, @definition = data, definition
+    end
+
+    def validate!
+      definition.validate_data!(data)
+    end
+  end
+end
+
+

data/lib/interpol/errors.rb

@@ -0,0 +1,28 @@
+module Interpol
+  # Base class that interpol errors should subclass.
+  class Error < StandardError; end
+
+  # Error raised when the configuration is invalid.
+  class ConfigurationError < Error; end
+
+  # Error raised when data fails to validate against the schema
+  # for an endpoint.
+  class ValidationError < Error
+    attr_reader :errors
+
+    def initialize(errors = [], data = nil, endpoint_description = '')
+      @errors = errors
+      error_bullet_points = errors.map { |e| "\n  - #{e}" }.join
+      message = "Found #{errors.size} error(s) when validating " +
+                "against endpoint #{endpoint_description}. " +
+                "Errors: #{error_bullet_points}.\n\nData:\n#{data.inspect}"
+
+      super(message)
+    end
+  end
+
+  # Error raised when the schema validator cannot find a matching
+  # endpoint definition for the request.
+  class NoEndpointDefinitionFoundError < Error; end
+end
+

data/lib/interpol/response_schema_validator.rb

@@ -0,0 +1,87 @@
+require 'interpol'
+require 'json'
+
+module Interpol
+  # Rack middleware that validates response data against the schema
+  # definition for the endpoint. Can be configured to raise an
+  # error or warn in this condition. Intended for development and
+  # test use.
+  class ResponseSchemaValidator
+    def initialize(app, &block)
+      @config = Configuration.default.customized_duplicate(&block)
+      @app = app
+      @handler_class = @config.validation_mode == :warn ? HandlerWithWarnings : Handler
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      return status, headers, body unless @config.validate?(env, status, headers, body)
+
+      handler = @handler_class.new(status, headers, body, env, @config)
+      handler.validate!
+
+      return status, headers, handler.extracted_body
+    end
+
+    # Private: handles a responses and validates it. Validation
+    # errors will result in an error.
+    class Handler
+      attr_reader :status, :headers, :body, :env, :config
+
+      def initialize(status, headers, body, env, config)
+        @status, @headers, @body, @env, @config = status, headers, body, env, config
+      end
+
+      def validate!
+        unless validator == Interpol::DefinitionFinder::NoDefinitionFound
+          return validator.validate_data!(data)
+        end
+
+        raise NoEndpointDefinitionFoundError,
+          "No endpoint definition could be found for: #{request_method} '#{path}'"
+      end
+
+      # The only interface we can count on from the body is that it
+      # implements #each. It may not be re-windable. To preserve this
+      # interface while reading the whole thing, we need to extract
+      # it into our own array.
+      def extracted_body
+        @extracted_body ||= [].tap do |extracted_body|
+          body.each { |str| extracted_body << str }
+          body.close if body.respond_to?(:close)
+        end
+      end
+
+    private
+
+      def request_method
+        env.fetch('REQUEST_METHOD')
+      end
+
+      def data
+        @data ||= JSON.parse(extracted_body.join)
+      end
+
+      def path
+        env.fetch('PATH_INFO')
+      end
+
+      def validator
+        @validator ||= @config.endpoints.find_definition(request_method, path) do |endpoint|
+          @config.api_version_for(env, endpoint)
+        end
+      end
+    end
+
+    # Private: Subclasses Handler in order to convert validation errors
+    # to warnings instead.
+    class HandlerWithWarnings < Handler
+      def validate!
+        super
+      rescue ValidationError, NoEndpointDefinitionFoundError => e
+        Kernel.warn e.message
+      end
+    end
+  end
+end
+

data/lib/interpol/stub_app.rb

@@ -0,0 +1,60 @@
+require 'interpol'
+require 'sinatra/base'
+require 'json'
+
+module Interpol
+  module StubApp
+    extend self
+
+    def build(&block)
+      config = Configuration.default.customized_duplicate(&block)
+      builder = Builder.new(config)
+      builder.build
+      builder.app
+    end
+
+    module Helpers
+      def interpol_config
+        self.class.interpol_config
+      end
+
+      def example_for(endpoint, version)
+        endpoint.find_example_for!(version)
+      rescue ArgumentError
+        interpol_config.request_version_unavailable(self, version, endpoint.available_versions)
+      end
+    end
+
+    # Private: Builds a stub sinatra app for the given interpol
+    # configuration.
+    class Builder
+      attr_reader :app
+
+      def initialize(config)
+        @app = Sinatra.new do
+          set            :interpol_config, config
+          helpers        Helpers
+          not_found      { JSON.dump(error: "The requested resource could not be found") }
+          before         { content_type "application/json;charset=utf-8" }
+          get('/__ping') { JSON.dump(message: "Interpol stub app running.") }
+        end
+      end
+
+      def build
+        @app.interpol_config.endpoints.each do |endpoint|
+          app.send(endpoint.method, endpoint.route, &endpoint_definition(endpoint))
+        end
+      end
+
+      def endpoint_definition(endpoint)
+        lambda do
+          version = interpol_config.api_version_for(request.env, endpoint)
+          example = example_for(endpoint, version)
+          example.validate!
+          JSON.dump(example.data)
+        end
+      end
+    end
+  end
+end
+

data/lib/interpol/test_helper.rb

@@ -0,0 +1,44 @@
+require 'interpol'
+
+module Interpol
+  module TestHelper
+    module Common
+      def each_example_from(endpoints)
+        endpoints.each do |endpoint|
+          endpoint.definitions.each do |definition|
+            definition.examples.each_with_index do |example, index|
+              yield endpoint, definition, example, index
+            end
+          end
+        end
+      end
+
+      def define_interpol_example_tests(&block)
+        config = Configuration.default.customized_duplicate(&block)
+
+        each_example_from(config.endpoints) do |endpoint, definition, example, example_index|
+          description = "#{endpoint.name} (v #{definition.version}) has " +
+                        "valid data for example #{example_index + 1}"
+          define_test(description) { example.validate! }
+        end
+      end
+    end
+
+    module RSpec
+      include Common
+
+      def define_test(name, &block)
+        it(name, &block)
+      end
+    end
+
+    module TestUnit
+      include Common
+
+      def define_test(name, &block)
+        define_method("test_#{name.gsub(/\W+/, '_')}", &block)
+      end
+    end
+  end
+end
+

data/lib/interpol/version.rb

@@ -0,0 +1,3 @@
+module Interpol
+  VERSION = "0.0.1"
+end

data/lib/interpol.rb

@@ -0,0 +1,12 @@
+require "interpol/configuration"
+require "interpol/version"
+
+module Interpol
+  extend self
+
+  def default_configuration(&block)
+    block ||= lambda { |c| }
+    Configuration.default.tap(&block)
+  end
+end
+

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: interpol
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Myron Marston
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &2152119280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+    - - <
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152119280
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: &2152116920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152116920
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152114860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: *2152114860
+- !ruby/object:Gem::Dependency
+  name: rspec-fire
+  requirement: &2152112940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: *2152112940
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &2152112120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: *2152112120
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: &2152111100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: *2152111100
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2151941140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *2151941140
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &2151939360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *2151939360
+description: Interpol is a toolkit for working with API endpoint definition files,
+  giving you a stub app, a schema validation middleware, and browsable documentation.
+email:
+- myron.marston@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- License
+- Gemfile
+- Rakefile
+- lib/interpol/configuration.rb
+- lib/interpol/endpoint.rb
+- lib/interpol/errors.rb
+- lib/interpol/response_schema_validator.rb
+- lib/interpol/stub_app.rb
+- lib/interpol/test_helper.rb
+- lib/interpol/version.rb
+- lib/interpol.rb
+homepage: ''
+licenses: []
+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.15
+signing_key: 
+specification_version: 3
+summary: Interpol is a toolkit for policing your HTTP JSON interface.
+test_files: []