openapi-rswag-specs 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7fe4364f6d0dabffc857791ff28c23dc133635743b276d7131099e2b981ebcc2
+  data.tar.gz: c2a7f905dfed6852891d1b5a6bdaa4720efb7a3bada3c5b5b735f0924374ea5e
+SHA512:
+  metadata.gz: 925d424f35bf7d0d8d58766e6b2b7752be4f0a1b414dbc2757fe7af12e70bcdc624ad61e009a6b82427a570835ab721ec94d454c0481dce87f36510aa9d9a95e
+  data.tar.gz: 4ae03e3e2f9a7e851fa0e3d8115dcc8d536b7f7648ce409bb57ed3d3e4a96917a80500a507c327387d5a59612c270783dc73c4ff059d3fe717e6b3b499ebc984

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/rspec/USAGE

@@ -0,0 +1,9 @@
+Description:
+    This creates an RSpec request spec to define Swagger documentation for a
+    controller. It will create a test for each of the controller's methods.
+
+Example:
+    rails generate rspec:swagger V3::AccountsController
+
+    This will create:
+        spec/requests/v3/accounts_spec.rb

data/lib/generators/rspec/swagger_generator.rb

@@ -0,0 +1,22 @@
+require 'openapi/rswag/route_parser'
+require 'rails/generators'
+
+module Rspec
+  class SwaggerGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    def setup
+      @routes = Openapi::Rswag::RouteParser.new(controller_path).routes
+    end
+
+    def create_spec_file
+      template 'spec.rb', File.join('spec', 'requests', "#{controller_path}_spec.rb")
+    end
+
+    private
+
+    def controller_path
+      file_path.chomp('_controller')
+    end
+  end
+end

data/lib/generators/rspec/templates/spec.rb

@@ -0,0 +1,30 @@
+require 'swagger_helper'
+
+RSpec.describe '<%= controller_path %>', type: :request do
+<%  @routes.each do | template, path_item | %>
+  path '<%= template %>' do
+<%    unless path_item[:params].empty? -%>
+    # You'll want to customize the parameter types...
+<%      path_item[:params].each do |param| -%>
+    parameter name: '<%= param %>', in: :path, type: :string, description: '<%= param %>'
+<%      end -%>
+<%    end -%>
+<%    path_item[:actions].each do | action, details | %>
+    <%= action %>('<%= details[:summary] %>') do
+      response(200, 'successful') do
+<%      unless path_item[:params].empty? -%>
+<%        path_item[:params].each do |param| -%>
+        let(:<%= param %>) { '123' }
+<%        end -%>
+<%      end -%>
+
+        after do |example|
+          example.metadata[:response][:examples] = { 'application/json' => JSON.parse(response.body, symbolize_names: true) }
+        end
+        run_test!
+      end
+    end
+<%    end -%>
+  end
+<%  end -%>
+end

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,31 @@
+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.yaml' => {
+      openapi: '3.0.1',
+      info: {
+        title: 'API V1',
+        version: 'v1'
+      },
+      paths: {}
+    }
+  }
+
+  # Specify the format of the output Swagger file when running 'rswag:specs:swaggerize'.
+  # The swagger_docs configuration option has the filename including format in
+  # the key, this may want to be changed to avoid putting yaml in json files.
+  # Defaults to json. Accepts ':json' and ':yaml'.
+  config.swagger_format = :yaml
+end

data/lib/openapi/rswag/route_parser.rb

@@ -0,0 +1,60 @@
+module Openapi
+  module Rswag
+    class RouteParser
+      attr_reader :controller
+  
+      def initialize(controller)
+        @controller = controller
+      end
+  
+      def routes
+        ::Rails.application.routes.routes.select do |route|
+          route.defaults[:controller] == controller
+        end.reduce({}) do |tree, route|
+          path = path_from(route)
+          verb = verb_from(route)
+          tree[path] ||= { params: params_from(route), actions: {} }
+          tree[path][:actions][verb] = { summary: summary_from(route) }
+          tree
+        end
+      end
+  
+      private
+  
+      def path_from(route)
+        route.path.spec.to_s
+          .chomp('(.:format)') # Ignore any format suffix
+          .gsub(/:([^\/.?]+)/, '{\1}') # Convert :id to {id}
+      end
+  
+      def verb_from(route)
+        verb = route.verb
+        if verb.kind_of? String
+          verb.downcase
+        else
+          verb.source.gsub(/[$^]/, '').downcase
+        end
+      end
+  
+      def summary_from(route)
+        verb = route.requirements[:action]
+        noun = route.requirements[:controller].split('/').last.singularize
+  
+        # Apply a few customizations to make things more readable
+        case verb
+        when 'index'
+          verb = 'list'
+          noun = noun.pluralize
+        when 'destroy'
+          verb = 'delete'
+        end
+  
+        "#{verb} #{noun}"
+      end
+  
+      def params_from(route)
+        route.segments - ['format']
+      end
+    end
+  end  
+end

data/lib/openapi/rswag/specs.rb

@@ -0,0 +1,30 @@
+require 'rspec/core'
+require 'openapi/rswag/specs/example_group_helpers'
+require 'openapi/rswag/specs/example_helpers'
+require 'openapi/rswag/specs/configuration'
+require 'openapi/rswag/specs/railtie' if defined?(Rails::Railtie)
+
+module Openapi
+  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.add_setting :swagger_format
+        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
+end

data/lib/openapi/rswag/specs/configuration.rb

@@ -0,0 +1,53 @@
+module Openapi
+  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 swagger_format
+          @swagger_format ||= begin
+            @rspec_config.swagger_format = :json if @rspec_config.swagger_format.nil? || @rspec_config.swagger_format.empty?
+            raise ConfigurationError, "Unknown swagger_format '#{@rspec_config.swagger_format}'" unless [:json, :yaml].include?(@rspec_config.swagger_format)
+            @rspec_config.swagger_format
+          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  
+end

data/lib/openapi/rswag/specs/example_group_helpers.rb

@@ -0,0 +1,100 @@
+module Openapi
+  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, :options, :trace ].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  
+end

data/lib/openapi/rswag/specs/example_helpers.rb

@@ -0,0 +1,37 @@
+require 'openapi/rswag/specs/request_factory'
+require 'openapi/rswag/specs/response_validator'
+
+module Openapi
+  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
+end

data/lib/openapi/rswag/specs/extended_schema.rb

@@ -0,0 +1,27 @@
+require 'json-schema'
+
+module Openapi
+  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
+end

data/lib/openapi/rswag/specs/railtie.rb

@@ -0,0 +1,16 @@
+module Openapi
+  module Rswag
+    module Specs
+      class Railtie < ::Rails::Railtie
+  
+        rake_tasks do
+          load File.expand_path('../../../../tasks/rswag-specs_tasks.rake', __FILE__)
+        end
+  
+        generators do
+          require 'generators/rspec/swagger_generator.rb'
+        end
+      end
+    end
+  end
+end

data/lib/openapi/rswag/specs/request_factory.rb

@@ -0,0 +1,159 @@
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/conversions'
+require 'json'
+
+module Openapi
+  module Rswag
+    module Specs
+      class RequestFactory
+  
+        def initialize(config = ::Openapi::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
+end

data/lib/openapi/rswag/specs/response_validator.rb

@@ -0,0 +1,56 @@
+require 'active_support/core_ext/hash/slice'
+require 'json-schema'
+require 'json'
+require 'openapi/rswag/specs/extended_schema'
+
+module Openapi
+  module Rswag
+    module Specs
+      class ResponseValidator
+  
+        def initialize(config = ::Openapi::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
+end

data/lib/openapi/rswag/specs/swagger_formatter.rb

@@ -0,0 +1,87 @@
+require 'active_support/core_ext/hash/deep_merge'
+require 'swagger_helper'
+
+module Openapi
+  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
+  
+          # !metadata[:document] won't work, since nil means we should generate
+          # docs.
+          return if metadata[:document] == false
+          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(pretty_generate(doc))
+            end
+  
+            @output.puts "Swagger doc generated at #{file_path}"
+          end
+        end
+  
+        private
+  
+        def pretty_generate(doc)
+          if @config.swagger_format == :yaml
+            clean_doc = yaml_prepare(doc)
+            YAML.dump(clean_doc)
+          else # config errors are thrown in 'def swagger_format', no throw needed here
+            JSON.pretty_generate(doc)
+          end
+        end
+  
+        def yaml_prepare(doc)
+          json_doc = JSON.pretty_generate(doc)
+          clean_doc = JSON.parse(json_doc)
+        end
+  
+        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
+end

data/lib/tasks/rswag-specs_tasks.rake

@@ -0,0 +1,23 @@
+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 = ENV.fetch(
+        'PATTERN',
+        'spec/requests/**/*_spec.rb, spec/api/**/*_spec.rb, spec/integration/**/*_spec.rb'
+      )
+
+      # NOTE: rspec 2.x support
+      if Openapi::Rswag::Specs::RSPEC_VERSION > 2 && Openapi::Rswag::Specs.config.swagger_dry_run
+        t.rspec_opts = [ '--format Openapi::Rswag::Specs::SwaggerFormatter', '--dry-run', '--order defined' ]
+      else
+        t.rspec_opts = [ '--format Openapi::Rswag::Specs::SwaggerFormatter', '--order defined' ]
+      end
+    end
+  end
+end
+
+task :rswag => ['rswag:specs:swaggerize']

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: openapi-rswag-specs
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Emmanuel Ndangurura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-06 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'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !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:
+- endangurura@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/generators/rspec/USAGE
+- lib/generators/rspec/swagger_generator.rb
+- lib/generators/rspec/templates/spec.rb
+- lib/generators/rswag/specs/install/USAGE
+- lib/generators/rswag/specs/install/install_generator.rb
+- lib/generators/rswag/specs/install/templates/swagger_helper.rb
+- lib/openapi/rswag/route_parser.rb
+- lib/openapi/rswag/specs.rb
+- lib/openapi/rswag/specs/configuration.rb
+- lib/openapi/rswag/specs/example_group_helpers.rb
+- lib/openapi/rswag/specs/example_helpers.rb
+- lib/openapi/rswag/specs/extended_schema.rb
+- lib/openapi/rswag/specs/railtie.rb
+- lib/openapi/rswag/specs/request_factory.rb
+- lib/openapi/rswag/specs/response_validator.rb
+- lib/openapi/rswag/specs/swagger_formatter.rb
+- lib/tasks/rswag-specs_tasks.rake
+homepage: https://github.com/endangurura/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.1.2
+signing_key: 
+specification_version: 4
+summary: A Swagger-based DSL for rspec-rails & accompanying rake task for generating
+  Swagger files
+test_files: []