swagger-diff 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 48e4764f21be525db2bdb268245bd3bb4be88e33
+  data.tar.gz: a756a2111d804ce0612185f1778cec7c559eec9f
+SHA512:
+  metadata.gz: 9739b31a7a4036a78972a4c9a8fd41dff57b0dfd02174655fe87cbe848cf45e3acfbc73cc9522a5192130b88aa644293c79b29e08de149de81829cc9386ff5f1
+  data.tar.gz: fc583c80d81fc78c737e7713f865abd2b682a8064455179f7c0a8d236dd3a3006fd8d32dd708e28a55063d0086a4dbf9dfa2fd6a549cb1a303f4ff8f11ab58e9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,20 @@
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/ClassLength:
+  Max: 200
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/PerceivedComplexity:
+  Max: 10
+
+Style/Documentation:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+cache: bundler
+script:
+  - bundle exec rubocop

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in swagger-diff.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2015, Civis Analytics
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of Civis Analytics nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,126 @@
+# Swagger::Diff
+
+[![Build Status](https://travis-ci.org/civisanalytics/swagger-diff.svg?branch=master)](https://travis-ci.org/civisanalytics/swagger-diff)
+[![Gem Version](https://badge.fury.io/rb/swagger-diff.svg)](http://badge.fury.io/rb/swagger-diff)
+
+![Swagger::Diff in action](swagger-diff.gif)
+
+> You can tell me by the way I walk - Genesis
+
+Swagger::Diff is a utility for comparing two different
+[Swagger](http://swagger.io/) specifications.
+Its intended use is to determine whether a newer API specification is
+backwards-compatible with an older API specification.
+It provides both an [RSpec](http://rspec.info/) matcher and helper functions
+that can be used directly.
+Specifications are considered backwards compatible if:
+
+- all path and verb combinations in the old specification are present in the
+  new one
+- no request parameters are required in the new specification that were not
+  required in the old one
+- all request parameters in the old specification are present in the new one
+- all request parameters in the old specification have the same type in the
+  new one
+- all response attributes in the old specification are present in the new one
+- all response attributes in the old specification have the same type in the new
+  one
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'swagger-diff'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install swagger-diff
+
+## Usage
+
+Swagger::Diff uses the [Swagger](https://github.com/swagger-rb/swagger-rb) gem
+to parse Swagger specifications.
+Specifications can be any
+[supported format](https://github.com/swagger-rb/swagger-rb/tree/v0.2.3#parsing):
+
+- the path to a file containing a Swagger specification.
+  This may be local (*e.g.*, `/path/to/swagger.json`) or remote (*e.g.*,
+  `http://host.domain/swagger.yml`)
+- a Hash containing a parsed Swagger specification (*e.g.*, the output of
+  `JSON.parse`)
+- a string of JSON containing Swagger specification
+- a string of YAML containing Swagger specification
+
+### RSpec
+
+```ruby
+expect(<new>).to be_compatible_with(<old>)
+```
+
+If `new` is incompatible with `old`, the spec will fail and print a list of
+backwards-incompatibilities.
+
+### Direct Invocation
+
+If you are not using RSpec, you can directly invoke the comparison function:
+
+```ruby
+diff = Swagger::Diff::Diff.new(<old>, <new>)
+diff.compatible?
+```
+
+It will return `true` if `new` is compatible with `old`, `false` otherwise.
+`#incompatibilities` will return a hash containing the incompatible endpoints,
+request parameters, and response attributes; *e.g.*,
+
+```ruby
+{ endpoints: ['put /a/{}'],
+  request_params: {
+    'get /a/' => ['missing request param: limit (type: integer)'],
+    'post /a/' => ['new required request param: extra'],
+    'put /b/{}' => ['new required request param: extra']
+  },
+  response_attributes: {
+    'post /a/' => ['missing attribute from 200 response: description (type: string)'],
+    'get /a/{}' => ['missing attribute from 200 response: description (type: string)'],
+    'put /b/{}' => ['missing attribute from 200 response: description (type: string)']
+  }
+}
+```
+
+### Command-Line
+
+It also includes a command-line version:
+
+```bash
+$ swagger-diff <old> <new>
+```
+
+`swagger-diff` will print a list of any backwards-incompatibilities `new` has
+when compared to `old`.
+
+## Gem Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/civisanalytics/swagger-diff/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+Swagger::Diff is released under the [BSD 3-Clause License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'swagger/diff'
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/swagger-diff

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'swagger/diff'
+
+if ARGV.length == 2
+  diff = Swagger::Diff::Diff.new(ARGV[0], ARGV[1])
+
+  unless diff.compatible?
+    puts diff.incompatibilities_message
+    exit 1
+  end
+else
+  puts 'Usage: swagger-diff <old> <new>
+
+Checks <new> for backwards-compatibility with <old>. If <new> is incompatible,
+a list of incompatibilities will be printed.'
+end

data/lib/swagger/diff.rb

@@ -0,0 +1,8 @@
+require 'forwardable' # Needed to require swagger-core.
+require 'swagger'
+require 'rspec/expectations'
+require 'swagger/diff/diff'
+require 'swagger/diff/patch'
+require 'swagger/diff/rspec_matchers'
+require 'swagger/diff/specification'
+require 'swagger/diff/version'

data/lib/swagger/diff/diff.rb

@@ -0,0 +1,138 @@
+module Swagger
+  module Diff
+    class Diff
+      def initialize(old, new)
+        @new_specification = Swagger::Diff::Specification.new(new)
+        @old_specification = Swagger::Diff::Specification.new(old)
+      end
+
+      def compatible?
+        endpoints_compatible? && requests_compatible? && responses_compatible?
+      end
+
+      def incompatibilities
+        { endpoints: missing_endpoints.to_a.sort,
+          request_params: incompatible_request_params,
+          response_attributes: incompatible_response_attributes }
+      end
+
+      def incompatibilities_message
+        msg = ''
+        if incompatibilities[:endpoints]
+          msg += incompatibilities_message_endpoints(incompatibilities[:endpoints])
+        end
+        if incompatibilities[:request_params]
+          msg += incompatibilities_message_params(incompatibilities[:request_params])
+        end
+        if incompatibilities[:response_attributes]
+          msg += incompatibilities_message_attributes(incompatibilities[:response_attributes])
+        end
+        msg
+      end
+
+      private
+
+      def incompatibilities_message_endpoints(endpoints)
+        if endpoints.empty?
+          ''
+        else
+          msg = "- missing endpoints\n"
+          endpoints.each do |endpoint|
+            msg += "  - #{endpoint}\n"
+          end
+          msg
+        end
+      end
+
+      def incompatibilities_message_inner(typestr, collection)
+        if collection.nil? || collection.empty?
+          ''
+        else
+          msg = "- incompatible #{typestr}\n"
+          collection.sort.each do |endpoint, attributes|
+            msg += "  - #{endpoint}\n"
+            attributes.each do |attribute|
+              msg += "    - #{attribute}\n"
+            end
+          end
+          msg
+        end
+      end
+
+      def incompatibilities_message_params(params)
+        incompatibilities_message_inner('request params', params)
+      end
+
+      def incompatibilities_message_attributes(attributes)
+        incompatibilities_message_inner('response attributes', attributes)
+      end
+
+      def missing_endpoints
+        @old_specification.endpoints - @new_specification.endpoints
+      end
+
+      def incompatible_request_params
+        ret = {}
+        incompatible_request_params_enumerator.each do |key, val|
+          ret[key] ||= []
+          ret[key] << val
+        end
+        ret
+      end
+
+      def incompatible_request_params_enumerator
+        Enumerator.new do |yielder|
+          @old_specification.request_params.each do |key, old_params|
+            new_params = @new_specification.request_params[key]
+            next if new_params.nil?
+            (new_params[:required] - old_params[:required]).each do |req|
+              yielder << [key, "new required request param: #{req}"]
+            end
+            (old_params[:all] - new_params[:all]).each do |req|
+              yielder << [key, "missing request param: #{req}"]
+            end
+          end
+        end.lazy
+      end
+
+      def incompatible_response_attributes
+        ret = {}
+        incompatible_response_attributes_enumerator.each do |key, val|
+          ret[key] ||= []
+          ret[key] << val
+        end
+        ret
+      end
+
+      def incompatible_response_attributes_enumerator
+        Enumerator.new do |yielder|
+          @old_specification.response_attributes.each do |key, old_attributes|
+            new_attributes = @new_specification.response_attributes[key]
+            next if new_attributes.nil?
+            old_attributes.keys.each do |code|
+              if new_attributes.key?(code)
+                (old_attributes[code] - new_attributes[code]).each do |resp|
+                  yielder << [key, "missing attribute from #{code} response: #{resp}"]
+                end
+              else
+                yielder << [key, "missing #{code} response"]
+              end
+            end
+          end
+        end.lazy
+      end
+
+      def endpoints_compatible?
+        missing_endpoints.empty?
+      end
+
+      def requests_compatible?
+        incompatible_request_params_enumerator.none?
+      end
+
+      def responses_compatible?
+        incompatible_response_attributes_enumerator.none?
+      end
+    end
+  end
+end

data/lib/swagger/diff/patch.rb

@@ -0,0 +1,15 @@
+# Workaround for Swagger::V2::SecurityScheme[1] incorrectly specifying
+# required fields. maxlinc is right: the Swagger specification[2] is
+# misleading. Fixed Fields suggests many parameters are required that are not
+# required by Swagger's official validator[3]. Working around this by removing
+# them from the array of required properties.
+#
+# [1] https://github.com/swagger-rb/swagger-rb/blob/v0.2.3/lib/swagger/v2/security_scheme.rb#L9-L11
+# [2] http://swagger.io/specification/#securityDefinitionsObject
+# [3] https://github.com/swagger-api/validator-badge
+
+OAUTH2_PARAMS = [:flow, :authorizationUrl, :scopes]
+
+Swagger::V2::SecurityScheme.required_properties.reject! do |k, _|
+  OAUTH2_PARAMS.include?(k)
+end

data/lib/swagger/diff/rspec_matchers.rb

@@ -0,0 +1,24 @@
+RSpec::Matchers.define :be_compatible_with do |expected|
+  match do |actual|
+    diff = Swagger::Diff::Diff.new(expected, actual)
+    diff.compatible?
+  end
+
+  failure_message do |actual|
+    diff = Swagger::Diff::Diff.new(expected, actual)
+    with = if File.exist?(expected)
+             " with '#{expected}'"
+           else
+             ''
+           end
+    "expected Swagger to be compatible#{with}, found:\n#{diff.incompatibilities_message}"
+  end
+
+  failure_message_when_negated do
+    "expected Swagger to be incompatible with '#{expected}'"
+  end
+
+  description do
+    'be backwards-compatible with another specification'
+  end
+end

data/lib/swagger/diff/specification.rb

@@ -0,0 +1,194 @@
+module Swagger
+  module Diff
+    class Specification
+      def initialize(spec)
+        @spec = spec
+        @parsed = parse_swagger(spec)
+        @endpoint_hash = parsed_to_hash(@parsed)
+      end
+
+      def endpoints
+        @endpoint_hash.keys.to_set
+      end
+
+      def request_params
+        @request_params ||= begin
+                              ret = {}
+                              @endpoint_hash.each do |key, endpoint|
+                                ret[key] = request_params_inner(params_or_nil(endpoint))
+                              end
+                              ret
+                            end
+      end
+
+      def response_attributes
+        @response_attributes ||= begin
+                                   ret = {}
+                                   @endpoint_hash.each do |key, endpoint|
+                                     ret[key] = response_attributes_inner(endpoint)
+                                   end
+                                   ret
+                                 end
+      end
+
+      private
+
+      def merge_refs!(h1, h2)
+        h2.each do |k, v|
+          if h1.include?(k)
+            h1[k] += h1[k].merge(v)
+          else
+            h1[k] = v
+          end
+        end
+      end
+
+      def params_or_nil(endpoint)
+        endpoint && endpoint.parameters || nil
+      end
+
+      def parse_swagger(swagger)
+        if swagger.is_a? Hash
+          Swagger.build(swagger)
+        elsif File.exist?(swagger)
+          Swagger.load(swagger)
+        else
+          swagger = open(swagger).read if swagger[0..7] =~ %r{^https?://}
+          begin
+            JSON.parse(swagger)
+          rescue JSON::ParserError
+            begin
+              YAML.load(swagger)
+            rescue Psych::SyntaxError
+              raise 'Only filenames or raw or parsed strings of JSON or YAML are supported.'
+            else
+              Swagger.build(swagger, format: :yaml)
+            end
+          else
+            Swagger.build(swagger, format: :json)
+          end
+        end
+      end
+
+      def parsed_to_hash(parsed)
+        ret = {}
+        parsed.operations.each do |endpoint|
+          ret["#{endpoint.verb} #{endpoint.path.gsub(/{.*?}/, '{}')}"] = endpoint
+        end
+        ret
+      end
+
+      # Parses a $ref into a flat list of parameters, recursively if necessary.
+      #
+      # Returns a hash with 2 keys where the value is a set of flattened
+      # parameter definitions (i.e., all parameters, including nested
+      # parameters, are included in a single set).
+      def refs(ref, prefix = '')
+        definitions = @parsed.definitions
+        idx = ref.rindex('/')
+        key = ref[idx + 1..-1]
+        ret = {}
+        if definitions[key].allOf
+          definitions[key].allOf.each do |schema|
+            if schema['$ref']
+              merge_refs!(ret, refs(schema['$ref'], prefix))
+            else
+              merge_refs!(ret, properties(schema.properties, schema.required, prefix))
+            end
+          end
+        else
+          merge_refs!(ret,
+                      properties(definitions[key].properties,
+                                 definitions[key].required, prefix))
+        end
+        ret
+      end
+
+      def nested(ref, prefix, name, list = false)
+        # Check for cycles by testing whether name was already added to
+        # prefix.
+        key = "#{prefix}#{name}#{'[]' if list}"
+        if prefix == "#{name}/" || prefix =~ %r{/#{name}(\[\])?/}
+          # Anonymizing the reference in case the name changed (e.g.,
+          # generated Swagger).
+          { all: ["#{key} (type: reference)"] }
+        else
+          refs(ref, "#{key}/")
+        end
+      end
+
+      def properties_for_ref(prefix, name, schema, required, list = false)
+        key = "#{prefix}#{name}"
+        ret = { required: Set.new, all: Set.new }
+        if schema.key?('$ref')
+          merge_refs!(ret, nested(schema['$ref'], prefix, name, list))
+        else
+          ret[:required].add(key) if required && required.include?(name)
+          ret[:all].add("#{key} (type: #{schema.type}#{'[]' if list})")
+        end
+        ret
+      end
+
+      def properties(properties, required, prefix = '')
+        ret = { required: Set.new, all: Set.new }
+        properties.each do |name, schema|
+          if schema.type == 'array'
+            merge_refs!(ret, properties_for_ref(prefix, name, schema.items, required, true))
+          elsif schema.type == 'object'
+            if schema.allOf
+              # TODO: handle nested allOfs.
+            else
+              # Swagger 2.0 doesn't appear to support non-string keys[1]. If
+              # this changes, this will need to be updated.
+              # [1] https://github.com/swagger-api/swagger-spec/issues/299
+              # TODO: this doesn't handle hashes of objects.
+              type = if schema.additionalProperties &&
+                        schema.additionalProperties.type
+                       schema.additionalProperties.type
+                     else
+                       '*'
+                     end
+              ret[:all].add("#{prefix}#{name} (type: Hash[string, #{type}])")
+            end
+          else
+            merge_refs!(ret, properties_for_ref(prefix, name, schema, required))
+          end
+        end
+        ret
+      end
+
+      def request_params_inner(params)
+        ret = { required: Set.new, all: Set.new }
+        return ret if params.nil?
+        params.each do |param|
+          if param.in == 'path' || param.in == 'query'
+            ret[:required].add(param.name) if param.required
+            ret[:all].add("#{param.name} (type: #{param.type})")
+          else
+            merge_refs!(ret, refs(param.schema['$ref']))
+          end
+        end
+        ret
+      end
+
+      def response_attributes_inner(endpoint)
+        ret = {}
+        endpoint.responses.each do |code, response|
+          if response.schema
+            if response.schema.include?('type') && response.schema.type == 'array'
+              ref = response.schema.items['$ref']
+              prefix = '[]/'
+            else
+              ref = response.schema['$ref']
+              prefix = ''
+            end
+            ret[code] = refs(ref, prefix)[:all]
+          else
+            ret[code] = Set.new
+          end
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/swagger/diff/version.rb

@@ -0,0 +1,5 @@
+module Swagger
+  module Diff
+    VERSION = '1.0.1'
+  end
+end

data/swagger-diff.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'swagger/diff/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'swagger-diff'
+  spec.version       = Swagger::Diff::VERSION
+  spec.authors       = ['Jeff Cousens']
+  spec.email         = ['opensource@civisanalytics.com']
+
+  spec.summary       = 'Utility for comparing two Swagger specifications.'
+  spec.description   = 'Swagger::Diff is a utility for comparing two different Swagger specifications.
+It is intended to determine whether a newer API specification is backwards-
+compatible with an older API specification. It provides both an RSpec matcher
+and helper functions that can be used directly.'
+  spec.homepage      = 'https://github.com/civisanalytics/swagger-diff'
+  spec.license       = 'BSD 3-Clause'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'swagger-core', '~> 0.2.3'
+  spec.add_dependency 'rspec-expectations', '~> 3.3'
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'rake', '~> 10.4'
+  spec.add_development_dependency 'rspec', '~> 3.3'
+  spec.add_development_dependency 'pry', '~> 0.10.1'
+  spec.add_development_dependency 'rubocop', '~> 0.33.0'
+  spec.add_development_dependency 'vcr', '~> 2.9'
+  spec.add_development_dependency 'webmock', '~> 1.21'
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: swagger-diff
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Jeff Cousens
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: swagger-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.33.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.33.0
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: |-
+  Swagger::Diff is a utility for comparing two different Swagger specifications.
+  It is intended to determine whether a newer API specification is backwards-
+  compatible with an older API specification. It provides both an RSpec matcher
+  and helper functions that can be used directly.
+email:
+- opensource@civisanalytics.com
+executables:
+- swagger-diff
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/swagger-diff
+- lib/swagger/diff.rb
+- lib/swagger/diff/diff.rb
+- lib/swagger/diff/patch.rb
+- lib/swagger/diff/rspec_matchers.rb
+- lib/swagger/diff/specification.rb
+- lib/swagger/diff/version.rb
+- swagger-diff.gemspec
+- swagger-diff.gif
+homepage: https://github.com/civisanalytics/swagger-diff
+licenses:
+- BSD 3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Utility for comparing two Swagger specifications.
+test_files: []