rswagger-specs 2.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07ef0bb21168f580423f62453332be25318c4f296580f1b755c8c3e27f60e846
+  data.tar.gz: 0f85ca14858c869889399105a5d310015eceb69d00a9e116ff452125f50534c4
+SHA512:
+  metadata.gz: a214421cb832a47bd52d513deea3f1bf2a621ad063dc20aee4a4ff2c42c1819d060238507c0a5f23ebf5e5bcd8ed89b3f9cdfa91ac0c893d16e5e61a68ba944b
+  data.tar.gz: b820e6b33417d0bffa691930b6f380df859c1b4ba297d3e0743577b79d2ec091f05b30b67c759f9d41567f09c1a8ddfadc639123a7c6cd5a7b20b9305784ede6

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 domaindrivendev
+
+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/Rakefile

@@ -0,0 +1,27 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'rswag-specs'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/generators/rswag/specs/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+  Adds swagger_helper to enable Swagger DSL in integration specs
+
+Example:
+    rails generate rswag:specs:install
+
+    This will create:
+        spec/swagger_helper.rb

data/lib/generators/rswag/specs/install/install_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+
+module Rswag
+  module Specs
+
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def add_swagger_helper
+        template('swagger_helper.rb', 'spec/swagger_helper.rb')
+      end
+    end
+  end
+end

data/lib/generators/rswag/specs/install/templates/swagger_helper.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+
+RSpec.configure do |config|
+  # Specify a root folder where Swagger JSON files are generated
+  # NOTE: If you're using the rswag-api to serve API descriptions, you'll need
+  # to ensure that it's configured to serve Swagger from the same folder
+  config.swagger_root = Rails.root.join('swagger').to_s
+
+  # Define one or more Swagger documents and provide global metadata for each one
+  # When you run the 'rswag:specs:swaggerize' rake task, the complete Swagger will
+  # be generated at the provided relative path under swagger_root
+  # By default, the operations defined in spec files are added to the first
+  # document below. You can override this behavior by adding a swagger_doc tag to the
+  # the root example_group in your specs, e.g. describe '...', swagger_doc: 'v2/swagger.json'
+  config.swagger_docs = {
+    'v1/swagger.json' => {
+      swagger: '2.0',
+      info: {
+        title: 'API V1',
+        version: 'v1'
+      },
+      paths: {}
+    }
+  }
+end

data/lib/rswag/specs/configuration.rb

@@ -0,0 +1,43 @@
+module Rswag
+  module Specs
+
+    class Configuration
+
+      def initialize(rspec_config)
+        @rspec_config = rspec_config
+      end
+
+      def swagger_root
+        @swagger_root ||= begin
+          if @rspec_config.swagger_root.nil?
+            raise ConfigurationError, 'No swagger_root provided. See swagger_helper.rb'
+          end
+          @rspec_config.swagger_root
+        end
+      end
+
+      def swagger_docs
+        @swagger_docs ||= begin
+          if @rspec_config.swagger_docs.nil? || @rspec_config.swagger_docs.empty?
+            raise ConfigurationError, 'No swagger_docs defined. See swagger_helper.rb'
+          end
+          @rspec_config.swagger_docs
+        end
+      end
+
+      def swagger_dry_run
+        @swagger_dry_run ||= begin
+          @rspec_config.swagger_dry_run.nil? || @rspec_config.swagger_dry_run
+        end
+      end
+
+      def get_swagger_doc(name)
+        return swagger_docs.values.first if name.nil?
+        raise ConfigurationError, "Unknown swagger_doc '#{name}'" unless swagger_docs[name]
+        swagger_docs[name]
+      end
+    end
+
+    class ConfigurationError < StandardError; end
+  end
+end

data/lib/rswag/specs/example_group_helpers.rb

@@ -0,0 +1,98 @@
+module Rswag
+  module Specs
+    module ExampleGroupHelpers
+
+      def path(template, metadata={}, &block)
+        metadata[:path_item] = { template: template }
+        describe(template, metadata, &block)
+      end
+
+      [ :get, :post, :patch, :put, :delete, :head ].each do |verb|
+        define_method(verb) do |summary, &block|
+          api_metadata = { operation: { verb: verb, summary: summary } }
+          describe(verb, api_metadata, &block)
+        end
+      end
+
+      [ :operationId, :deprecated, :security ].each do |attr_name|
+        define_method(attr_name) do |value|
+          metadata[:operation][attr_name] = value
+        end
+      end
+
+      # NOTE: 'description' requires special treatment because ExampleGroup already
+      # defines a method with that name. Provide an override that supports the existing
+      # functionality while also setting the appropriate metadata if applicable
+      def description(value=nil)
+        return super() if value.nil?
+        metadata[:operation][:description] = value
+      end
+
+      # These are array properties - note the splat operator
+      [ :tags, :consumes, :produces, :schemes ].each do |attr_name|
+        define_method(attr_name) do |*value|
+          metadata[:operation][attr_name] = value
+        end
+      end
+
+      def parameter(attributes)
+        if attributes[:in] && attributes[:in].to_sym == :path
+          attributes[:required] = true
+        end
+
+        if metadata.has_key?(:operation)
+          metadata[:operation][:parameters] ||= []
+          metadata[:operation][:parameters] << attributes
+        else
+          metadata[:path_item][:parameters] ||= []
+          metadata[:path_item][:parameters] << attributes
+        end
+      end
+
+      def response(code, description, metadata={}, &block)
+        metadata[:response] = { code: code, description: description }
+        context(description, metadata, &block)
+      end
+
+      def schema(value)
+        metadata[:response][:schema] = value
+      end
+
+      def header(name, attributes)
+        metadata[:response][:headers] ||= {}
+        metadata[:response][:headers][name] = attributes
+      end
+
+      # NOTE: Similar to 'description', 'examples' need to handle the case when
+      # being invoked with no params to avoid overriding 'examples' method of
+      # rspec-core ExampleGroup
+      def examples(example = nil)
+        return super() if example.nil?
+        metadata[:response][:examples] = example
+      end
+
+      def run_test!(&block)
+        # NOTE: rspec 2.x support
+        if RSPEC_VERSION < 3
+          before do
+            submit_request(example.metadata)
+          end
+
+          it "returns a #{metadata[:response][:code]} response" do
+            assert_response_matches_metadata(metadata)
+            block.call(response) if block_given?
+          end
+        else
+          before do |example|
+            submit_request(example.metadata)
+          end
+
+          it "returns a #{metadata[:response][:code]} response" do |example|
+            assert_response_matches_metadata(example.metadata, &block)
+            example.instance_exec(response, &block) if block_given?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rswag/specs/example_helpers.rb

@@ -0,0 +1,35 @@
+require 'rswag/specs/request_factory'
+require 'rswag/specs/response_validator'
+
+module Rswag
+  module Specs
+    module ExampleHelpers
+
+      def submit_request(metadata)
+        request = RequestFactory.new.build_request(metadata, self)
+
+        if RAILS_VERSION < 5
+          send(
+            request[:verb],
+            request[:path],
+            request[:payload],
+            request[:headers]
+          )
+        else
+          send(
+            request[:verb],
+            request[:path],
+            {
+              params: request[:payload],
+              headers: request[:headers]
+            }
+          )
+        end
+      end
+
+      def assert_response_matches_metadata(metadata)
+        ResponseValidator.new.validate!(metadata, response)
+      end
+    end
+  end
+end

data/lib/rswag/specs/extended_schema.rb

@@ -0,0 +1,25 @@
+require 'json-schema'
+
+module Rswag
+  module Specs
+    class ExtendedSchema < JSON::Schema::Draft4
+      
+      def initialize
+        super
+        @attributes['type'] = ExtendedTypeAttribute
+        @uri = URI.parse('http://tempuri.org/rswag/specs/extended_schema')
+        @names = ['http://tempuri.org/rswag/specs/extended_schema']
+      end
+    end
+
+    class ExtendedTypeAttribute < JSON::Schema::TypeV4Attribute
+      
+      def self.validate(current_schema, data, fragments, processor, validator, options={})
+        return if data.nil? && current_schema.schema['x-nullable'] == true
+        super
+      end
+    end
+
+    JSON::Validator.register_validator(ExtendedSchema.new)
+  end
+end

data/lib/rswag/specs/railtie.rb

@@ -0,0 +1,10 @@
+module Rswag
+  module Specs
+    class Railtie < ::Rails::Railtie
+
+      rake_tasks do
+        load File.expand_path('../../../tasks/rswag-specs_tasks.rake', __FILE__)
+      end
+    end
+  end
+end

data/lib/rswag/specs/request_factory.rb

@@ -0,0 +1,157 @@
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/conversions'
+require 'json'
+
+module Rswag
+  module Specs
+    class RequestFactory
+
+      def initialize(config = ::Rswag::Specs.config)
+        @config = config
+      end
+
+      def build_request(metadata, example)
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+        parameters = expand_parameters(metadata, swagger_doc, example)
+
+        {}.tap do |request|
+          add_verb(request, metadata)
+          add_path(request, metadata, swagger_doc, parameters, example)
+          add_headers(request, metadata, swagger_doc, parameters, example)
+          add_payload(request, parameters, example)
+        end
+      end
+
+      private
+
+      def expand_parameters(metadata, swagger_doc, example)
+        operation_params = metadata[:operation][:parameters] || []
+        path_item_params = metadata[:path_item][:parameters] || []
+        security_params = derive_security_params(metadata, swagger_doc)
+
+        # NOTE: Use of + instead of concat to avoid mutation of the metadata object
+        (operation_params + path_item_params + security_params)
+          .map { |p| p['$ref'] ? resolve_parameter(p['$ref'], swagger_doc) : p }
+          .uniq { |p| p[:name] }
+          .reject { |p| p[:required] == false && !example.respond_to?(p[:name]) }
+      end
+
+      def derive_security_params(metadata, swagger_doc)
+        requirements = metadata[:operation][:security] || swagger_doc[:security] || []
+        scheme_names = requirements.flat_map { |r| r.keys }
+        schemes = (swagger_doc[:securityDefinitions] || {}).slice(*scheme_names).values
+
+        schemes.map do |scheme|
+          param = (scheme[:type] == :apiKey) ? scheme.slice(:name, :in) : { name: 'Authorization', in: :header }
+          param.merge(type: :string, required: requirements.one?)
+        end
+      end
+
+      def resolve_parameter(ref, swagger_doc)
+        key = ref.sub('#/parameters/', '').to_sym
+        definitions = swagger_doc[:parameters]
+        raise "Referenced parameter '#{ref}' must be defined" unless definitions && definitions[key]
+        definitions[key]
+      end
+
+      def add_verb(request, metadata) 
+        request[:verb] = metadata[:operation][:verb]
+      end
+
+      def add_path(request, metadata, swagger_doc, parameters, example)
+        template = (swagger_doc[:basePath] || '') + metadata[:path_item][:template]
+
+        request[:path] = template.tap do |template|
+          parameters.select { |p| p[:in] == :path }.each do |p|
+            template.gsub!("{#{p[:name]}}", example.send(p[:name]).to_s)
+          end
+
+          parameters.select { |p| p[:in] == :query }.each_with_index do |p, i|
+            template.concat(i == 0 ? '?' : '&')
+            template.concat(build_query_string_part(p, example.send(p[:name])))
+          end
+        end
+      end
+
+      def build_query_string_part(param, value)
+        name = param[:name]
+        return "#{name}=#{value.to_s}" unless param[:type].to_sym == :array
+
+        case param[:collectionFormat]
+        when :ssv
+          "#{name}=#{value.join(' ')}"
+        when :tsv
+          "#{name}=#{value.join('\t')}"
+        when :pipes
+          "#{name}=#{value.join('|')}"
+        when :multi
+          value.map { |v| "#{name}=#{v}" }.join('&')
+        else
+          "#{name}=#{value.join(',')}" # csv is default
+        end
+      end
+
+      def add_headers(request, metadata, swagger_doc, parameters, example)
+        tuples = parameters
+          .select { |p| p[:in] == :header }
+          .map { |p| [ p[:name], example.send(p[:name]).to_s ] }
+
+        # Accept header
+        produces = metadata[:operation][:produces] || swagger_doc[:produces]
+        if produces
+          accept = example.respond_to?(:'Accept') ? example.send(:'Accept') : produces.first
+          tuples << [ 'Accept', accept ]
+        end
+
+        # Content-Type header
+        consumes = metadata[:operation][:consumes] || swagger_doc[:consumes] 
+        if consumes
+          content_type = example.respond_to?(:'Content-Type') ? example.send(:'Content-Type') : consumes.first
+          tuples << [ 'Content-Type', content_type ]
+        end
+
+        # Rails test infrastructure requires rackified headers
+        rackified_tuples = tuples.map do |pair|
+          [
+            case pair[0]
+              when 'Accept' then 'HTTP_ACCEPT'
+              when 'Content-Type' then 'CONTENT_TYPE'
+              when 'Authorization' then 'HTTP_AUTHORIZATION'
+              else pair[0]
+            end,
+            pair[1]
+          ]
+        end
+
+        request[:headers] = Hash[ rackified_tuples ]
+      end
+
+      def add_payload(request, parameters, example)
+        content_type = request[:headers]['CONTENT_TYPE']
+        return if content_type.nil?
+
+        if [ 'application/x-www-form-urlencoded', 'multipart/form-data' ].include?(content_type)
+          request[:payload] = build_form_payload(parameters, example)
+        else
+          request[:payload] = build_json_payload(parameters, example)
+        end
+      end
+
+      def build_form_payload(parameters, example)
+        # See http://seejohncode.com/2012/04/29/quick-tip-testing-multipart-uploads-with-rspec/
+        # Rather that serializing with the appropriate encoding (e.g. multipart/form-data),
+        # Rails test infrastructure allows us to send the values directly as a hash
+        # PROS: simple to implement, CONS: serialization/deserialization is bypassed in test
+        tuples = parameters
+          .select { |p| p[:in] == :formData }
+          .map { |p| [ p[:name], example.send(p[:name]) ] }
+        Hash[ tuples ]
+      end
+
+      def build_json_payload(parameters, example)
+        body_param = parameters.select { |p| p[:in] == :body }.first
+        body_param ? example.send(body_param[:name]).to_json : nil
+      end
+    end
+  end
+end

data/lib/rswag/specs/response_validator.rb

@@ -0,0 +1,54 @@
+require 'active_support/core_ext/hash/slice'
+require 'json-schema'
+require 'json'
+require 'rswag/specs/extended_schema'
+
+module Rswag
+  module Specs
+    class ResponseValidator
+
+      def initialize(config = ::Rswag::Specs.config)
+        @config = config
+      end
+
+      def validate!(metadata, response)
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+
+        validate_code!(metadata, response)
+        validate_headers!(metadata, response.headers)
+        validate_body!(metadata, swagger_doc, response.body)
+      end
+
+      private
+
+      def validate_code!(metadata, response)
+        expected = metadata[:response][:code].to_s
+        if response.code != expected
+          raise UnexpectedResponse,
+                "Expected response code '#{response.code}' to match '#{expected}'\n" \
+                "Response body: #{response.body}"
+        end
+      end
+
+      def validate_headers!(metadata, headers)
+        expected = (metadata[:response][:headers] || {}).keys
+        expected.each do |name|
+          raise UnexpectedResponse, "Expected response header #{name} to be present" if headers[name.to_s].nil?
+        end
+      end
+
+      def validate_body!(metadata, swagger_doc, body)
+        response_schema = metadata[:response][:schema]
+        return if response_schema.nil?
+
+        validation_schema = response_schema
+          .merge('$schema' => 'http://tempuri.org/rswag/specs/extended_schema')
+          .merge(swagger_doc.slice(:definitions))
+        errors = JSON::Validator.fully_validate(validation_schema, body)
+        raise UnexpectedResponse, "Expected response body to match schema: #{errors[0]}" if errors.any?
+      end
+    end
+
+    class UnexpectedResponse < StandardError; end
+  end
+end

data/lib/rswag/specs/swagger_formatter.rb

@@ -0,0 +1,67 @@
+require 'active_support/core_ext/hash/deep_merge'
+require 'swagger_helper'
+
+module Rswag
+  module Specs
+    class SwaggerFormatter
+
+      # NOTE: rspec 2.x support
+      if RSPEC_VERSION > 2
+        ::RSpec::Core::Formatters.register self, :example_group_finished, :stop
+      end
+
+      def initialize(output, config = Rswag::Specs.config)
+        @output = output
+        @config = config
+
+        @output.puts 'Generating Swagger docs ...'
+      end
+
+      def example_group_finished(notification)
+        # NOTE: rspec 2.x support
+        if RSPEC_VERSION > 2
+          metadata = notification.group.metadata
+        else
+          metadata = notification.metadata
+        end
+
+        return unless metadata.has_key?(:response)
+        swagger_doc = @config.get_swagger_doc(metadata[:swagger_doc])
+        swagger_doc.deep_merge!(metadata_to_swagger(metadata))
+      end
+
+      def stop(notification=nil)
+        @config.swagger_docs.each do |url_path, doc|
+          file_path = File.join(@config.swagger_root, url_path)
+          dirname = File.dirname(file_path)
+          FileUtils.mkdir_p dirname unless File.exists?(dirname)
+
+          File.open(file_path, 'w') do |file|
+            file.write(JSON.pretty_generate(doc))
+          end
+
+          @output.puts "Swagger doc generated at #{file_path}"
+        end
+      end
+
+      private
+
+      def metadata_to_swagger(metadata)
+        response_code = metadata[:response][:code]
+        response = metadata[:response].reject { |k,v| k == :code }
+
+        verb = metadata[:operation][:verb]
+        operation = metadata[:operation]
+          .reject { |k,v| k == :verb }
+          .merge(responses: { response_code => response })
+
+        path_template = metadata[:path_item][:template]
+        path_item = metadata[:path_item]
+          .reject { |k,v| k == :template }
+          .merge(verb => operation)
+
+        { paths: { path_template => path_item } }
+      end
+    end
+  end
+end

data/lib/rswag/specs.rb

@@ -0,0 +1,27 @@
+require 'rspec/core'
+require 'rswag/specs/example_group_helpers'
+require 'rswag/specs/example_helpers'
+require 'rswag/specs/configuration'
+require 'rswag/specs/railtie' if defined?(Rails::Railtie)
+
+module Rswag
+  module Specs
+
+    # Extend RSpec with a swagger-based DSL
+    ::RSpec.configure do |c|
+      c.add_setting :swagger_root
+      c.add_setting :swagger_docs
+      c.add_setting :swagger_dry_run
+      c.extend ExampleGroupHelpers, type: :request
+      c.include ExampleHelpers, type: :request
+    end
+
+    def self.config
+      @config ||= Configuration.new(RSpec.configuration)
+    end
+
+    # Support Rails 3+ and RSpec 2+ (sigh!)
+    RAILS_VERSION = Rails::VERSION::MAJOR
+    RSPEC_VERSION = RSpec::Core::Version::STRING.split('.').first.to_i
+  end
+end

data/lib/tasks/rswag-specs_tasks.rake

@@ -0,0 +1,18 @@
+require 'rspec/core/rake_task'
+
+namespace :rswag do
+  namespace :specs do
+
+    desc 'Generate Swagger JSON files from integration specs'
+    RSpec::Core::RakeTask.new('swaggerize') do |t|
+      t.pattern = 'spec/requests/**/*_spec.rb, spec/api/**/*_spec.rb, spec/integration/**/*_spec.rb'
+
+      # NOTE: rspec 2.x support
+      if Rswag::Specs::RSPEC_VERSION > 2 && Rswag::Specs.config.swagger_dry_run
+        t.rspec_opts = [ '--format Rswag::Specs::SwaggerFormatter', '--dry-run', '--order defined' ]
+      else
+        t.rspec_opts = [ '--format Rswag::Specs::SwaggerFormatter', '--order defined' ]
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: rswagger-specs
+version: !ruby/object:Gem::Version
+  version: 2.0.6
+platform: ruby
+authors:
+- Dmitry Yarikov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: Simplify API integration testing with a succinct rspec DSL and generate
+  Swagger files directly from your rspecs
+email:
+- dmitry@yarikov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/generators/rswag/specs/install/USAGE
+- lib/generators/rswag/specs/install/install_generator.rb
+- lib/generators/rswag/specs/install/templates/swagger_helper.rb
+- lib/rswag/specs.rb
+- lib/rswag/specs/configuration.rb
+- lib/rswag/specs/example_group_helpers.rb
+- lib/rswag/specs/example_helpers.rb
+- lib/rswag/specs/extended_schema.rb
+- lib/rswag/specs/railtie.rb
+- lib/rswag/specs/request_factory.rb
+- lib/rswag/specs/response_validator.rb
+- lib/rswag/specs/swagger_formatter.rb
+- lib/tasks/rswag-specs_tasks.rake
+homepage: https://github.com/yarikov/rswag
+licenses:
+- MIT
+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: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: A Swagger-based DSL for rspec-rails & accompanying rake task for generating
+  Swagger files
+test_files: []