open_api_import 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 378a413d85facc074f8b7e8f1231c4fb34fa22b59485ab68be86a9634ef6152c
+  data.tar.gz: e7f07d0d064edf63db793934c300e4476244533d9efc7b28db65be72de720aa9
+SHA512:
+  metadata.gz: bbb86c25b23282f190f62973f012d12b8c0323b2c3a925b70912ecc1b1219514d79dee7a43bb1d4978d5fdb5bef3ba86908e23c675118b95c8fd30c32873f6f0
+  data.tar.gz: b3312d3571d8d95fcbaf97d535e4090345cc94877f61e8878ccd21a3f8958499b3b51be44f1bcac866f654e9ccf6d1eb938ecfe2624e8b3a9d6865ac61f4af08

data/.yardopts

@@ -0,0 +1,5 @@
+--readme README.md
+--title 'open_api_import - OpenApiImport -- Import a swagger or Open API file and create a Ruby Request Hash file including all requests and responses'
+--charset utf-8
+--markup markdown
+'lib/*.rb' - '*.md' - 'LICENSE'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Mario Ruiz
+
+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,405 @@
+# OpenApiImport
+
+[![Gem Version](https://badge.fury.io/rb/open_api_import.svg)](https://rubygems.org/gems/open_api_import)
+[![Build Status](https://travis-ci.com/MarioRuiz/open_api_import.svg?branch=master)](https://github.com/MarioRuiz/open_api_import)
+[![Coverage Status](https://coveralls.io/repos/github/MarioRuiz/open_api_import/badge.svg?branch=master)](https://coveralls.io/github/MarioRuiz/open_api_import?branch=master)
+
+Import a Swagger or Open API file and create a Ruby Request Hash file including all requests and responses with all the examples. The file can be in JSON or YAML.
+
+The Request Hash will include also the pattern (regular expressions) of the fields,  parameters, default values...
+
+On this first preliminary version we only fully support Open API v2. Open API v3 is not fully supported yet.
+
+The output of this gem will be following the specification of Request Hashes: https://github.com/MarioRuiz/Request-Hash
+
+The Request Hashes generated will be able to be used with any Ruby Http Client and it is adapted even better with nice_http gem: https://github.com/MarioRuiz/nice_http
+
+To be able to generate random requests take a look at the documentation for nice_hash gem: https://github.com/MarioRuiz/nice_hash
+
+This is an example of a generated request hash: 
+
+```ruby
+
+        # operationId: addPet, method: post
+        # summary: Example
+        # description: Creates a new pet in the store.  Duplicates are allowed
+        # required data: name
+        def self.add_pet()
+          {
+            path: "/api/pets",
+            data_required: [
+              :name,
+            ],
+            data_examples: [
+              {
+                name: "",
+                tag: "",
+              },
+            ],
+            responses: {
+              '200': {message: "pet response"},
+              'default': {message: "unexpected error"},
+            },
+          }
+        end
+
+
+```
+
+## Installation
+
+Install it yourself as:
+
+    $ gem install open_api_import
+
+
+Take in consideration open_api_import gem is using the 'rufo' gem that executes in command line the `rufo` command. In case you experience any trouble with it, visit: https://github.com/ruby-formatter/rufo
+
+## Usage
+
+You have all the json and yaml examples that the Open API project supplies on /spec/fixtures/ folder. You can use any of those ones or your own Swagger or Open API file. To convert the Swagger or Open API file into a Request Hash:
+
+```ruby
+  require 'open_api_import'
+  
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/uber.yaml"
+
+  OpenApiImport.from "my_file.json"
+
+```
+
+The supported HTTP methods are: `GET`, `POST`, `PUT`, `DELETE` and `PATCH`
+
+The requests will be organized by modules generated from the content in the Swagger file. 
+For example this would be generated when run this: `OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml"`
+
+```ruby
+##################################################
+# Swagger Petstore
+# version: 1.0.0
+# description:
+#     A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification
+##################################################
+module Swagger
+  module SwaggerPetstore
+    module V1_0_0
+      module Pets
+        # operationId: findPetById, method: get
+        # summary:
+        # description:
+        #     Returns a user based on a single ID, if the user does not have access to the pet
+        # parameters description:
+        #    id: (integer) ID of pet to fetch
+        def self.find_pet_by_id(id)
+          {
+            path: "/api/pets/#{id}",
+            method: :get,
+            responses: {
+...
+...
+
+```
+
+## Parameters
+
+The parameters can be supplied alone or with other parameters. In case a parameter is not supplied then it will be used the default value.
+
+### create_method_name
+
+How the name of the methods will be generated.
+
+Accepts three different options: :path, :operation_id and :operationId. By default :operation_id. 
+
+  path: it will be used the path and http method, for example for a GET on path: /users/list, the method name will be get_users_list
+
+  operation_id: it will be used the operationId field but using the snake_case version, for example for listUsers: list_users
+
+  operationId: it will be used the operationId field like it is, for example: listUsers
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", create_method_name: :path
+
+```
+
+The output will generate methods like this:
+
+```ruby
+        # operationId: findPets, method: get
+        # summary:
+        # description:
+        #     Returns all pets from the system that the user has access to
+        # parameters description:
+        #    tags: (array) tags to filter by
+        #    limit: (integer) maximum number of results to return
+        def self.get_pets(tags: "", limit: "")
+          {
+            path: "/api/pets?tags=#{tags}&limit=#{limit}&",
+... 
+...
+```
+
+if create_method_name is :operation_id
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", create_method_name: :operation_id
+
+```
+
+The output will generate methods like this:
+
+```ruby
+        # operationId: findPets, method: get
+        # summary:
+        # description:
+        #     Returns all pets from the system that the user has access to
+        # parameters description:
+        #    tags: (array) tags to filter by
+        #    limit: (integer) maximum number of results to return
+        def self.find_pets(tags: "", limit: "")
+          {
+            path: "/api/pets?tags=#{tags}&limit=#{limit}&",
+... 
+...
+```
+
+if create_method_name is :operationId
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", create_method_name: :operationId
+
+```
+
+The output will generate methods like this:
+
+```ruby
+        # operationId: findPets, method: get
+        # summary:
+        # description:
+        #     Returns all pets from the system that the user has access to
+        # parameters description:
+        #    tags: (array) tags to filter by
+        #    limit: (integer) maximum number of results to return
+        def self.findPets(tags: "", limit: "")
+          {
+            path: "/api/pets?tags=#{tags}&limit=#{limit}&",
+... 
+...
+```
+
+### name_for_module
+
+How the module names will be created.
+
+Accepts three different options: :path, :path_file and :fixed. By default :path. 
+
+  path: It will be used the first folder of the path to create the module name, for example the path /users/list will be in the module Users and all the requests from all modules in the same file.
+  
+  path_file: It will be used the first folder of the path to create the module name, for example the path /users/list will be in the module Users and each module will be in a new requests file.
+
+  fixed: all the requests will be under the module Requests
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", name_for_module: :fixed
+
+```
+
+It will generate just one file including all requests under the Requests module
+
+```ruby
+module Swagger
+  module SwaggerPetstore
+    module V1_0_0
+      module Requests
+
+        # operationId: findPets, method: get
+        # summary:
+        # description:
+        #     Returns all pets from the system that the user has access to
+        # parameters description:
+        #    tags: (array) tags to filter by
+        #    limit: (integer) maximum number of results to return
+        def self.find_pets(tags: "", limit: "")
+...
+...
+```
+
+In case using :path
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", name_for_module: :path
+
+```
+
+It will generate just one file including every request under the module generated from the first folder of the path
+
+```ruby
+module Swagger
+  module SwaggerPetstore
+    module V1_0_0
+      module Pets
+
+        # operationId: findPetById, method: get
+        # summary:
+        # description:
+        #     Returns a user based on a single ID, if the user does not have access to the pet
+        # parameters description:
+        #    id: (integer) ID of pet to fetch
+        def self.find_pet_by_id(id)
+...
+...
+```
+
+In case using :path_file
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", name_for_module: :path_file
+
+```
+
+It will generate one file per module including every request under the module generated from the first folder of the path. Also it will be generated one file that will have all the `require_relative` for the generated request files.
+
+This is the output of the run:
+
+```
+** Generated files that contain the code of the requests after importing the Swagger file:
+  - /petstore-simple.yaml_Root.rb
+  - /petstore-simple.yaml_Pets.rb
+** File that contains all the requires for all Request files:
+  - /petstore-simple.yaml.rb
+```
+
+### include_responses
+
+If you want to add the examples of responses in the resultant file.
+
+Accepts true or false, by default is true.
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", include_responses: false
+
+```
+
+A method that will be included in the output:
+
+```ruby
+        # operationId: findPetById, method: get
+        # summary:
+        # description:
+        #     Returns a user based on a single ID, if the user does not have access to the pet
+        # parameters description:
+        #    id: (integer) ID of pet to fetch
+        def self.find_pet_by_id(id)
+          {
+            path: "/api/pets/#{id}",
+            method: :get,
+          }
+        end
+```
+
+In case we run this
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", include_responses: true
+
+```
+
+A method that will be included in the output:
+
+```ruby
+        # operationId: findPetById, method: get
+        # summary:
+        # description:
+        #     Returns a user based on a single ID, if the user does not have access to the pet
+        # parameters description:
+        #    id: (integer) ID of pet to fetch
+        def self.find_pet_by_id(id)
+          {
+            path: "/api/pets/#{id}",
+            method: :get,
+            responses: {
+              '200': {
+                message: "pet response",
+                data: {
+                  name: "string",
+                  tag: "string",
+                  id: 0,
+                },
+              },
+              'default': {
+                message: "unexpected error",
+                data: {
+                  code: 0,
+                  message: "string",
+                },
+              },
+            },
+          }
+        end
+```
+
+### mock_response
+
+Add the first response on the request as mock_response to be used.
+
+Admits true or false. By default false.
+
+In case using nice_http gem: if NiceHttp.use_mocks = true will use it instead of getting the real response from the WS.
+
+```ruby
+  require 'open_api_import'
+
+  OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore.yaml", mock_response: true
+
+```
+
+It will include this on the output file: 
+
+```ruby
+        # operationId: listPets, method: get
+        # summary: List all pets
+        # description:
+        # parameters description:
+        #    limit: (integer) How many items to return at one time (max 100)
+        def self.list_pets(limit: "")
+          {
+            path: "/v1/pets?limit=#{limit}&",
+            method: :get,
+            mock_response: {
+              code: "200",
+              message: "A paged array of pets",
+              data: [
+                {
+                  id: 0,
+                  name: "string",
+                  tag: "string",
+                },
+              ],
+            },
+...
+...
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marioruiz/open_api_import.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/open_api_import.rb

@@ -0,0 +1,552 @@
+require_relative "open_api_import/utils"
+
+require "oas_parser"
+require "rufo"
+require "nice_hash"
+require "logger"
+
+class OpenApiImport
+  ##############################################################################################
+  # Import a Swagger or Open API file and create a Ruby Request Hash file including all requests and responses.
+  # The http methods that will be treated are: 'get','post','put','delete', 'patch'.
+  # @param swagger_file [String]. Path and file name. Could be absolute or relative to project root folder.
+  # @param include_responses [Boolean]. (default: true) if you want to add the examples of responses in the resultant file.
+  # @param mock_response [Boolean]. (default:false) Add the first response on the request as mock_response to be used.
+  #   In case using nice_http gem: if NiceHttp.use_mocks = true will use it instead of getting the real response from the WS.
+  # @param create_method_name [Symbol]. (:path, :operation_id, :operationId) (default: operation_id). How the name of the methods will be generated.
+  #   path: it will be used the path and http method, for example for a GET on path: /users/list, the method name will be get_users_list
+  #   operation_id: it will be used the operationId field but using the snake_case version, for example for listUsers: list_users
+  #   operationId: it will be used the operationId field like it is, for example: listUsers
+  # @param name_for_module [Symbol]. (:path, :path_file, :fixed) (default: :path). How the module names will be created.
+  #   path: It will be used the first folder of the path to create the module name, for example the path /users/list will be in the module Users and all the requests from all modules in the same file.
+  #   path_file: It will be used the first folder of the path to create the module name, for example the path /users/list will be in the module Users and each module will be in a new requests file.
+  #   fixed: all the requests will be under the module Requests
+  ##############################################################################################
+  def self.from(swagger_file, create_method_name: :operation_id, include_responses: true, mock_response: false, name_for_module: :path)
+    begin
+      f = File.new("#{swagger_file}_open_api_import.log", "w")
+      f.sync = true
+      @logger = Logger.new f
+    rescue StandardError => e
+      warn "Not possible to create the Logger file"
+      warn e
+      @logger = Logger.new nil
+    end
+
+    begin
+      @logger.info "swagger_file: #{swagger_file}, include_responses: #{include_responses}, mock_response: #{mock_response}\n"
+      @logger.info "create_method_name: #{create_method_name}, name_for_module: #{name_for_module}\n"
+
+      file_to_convert = if swagger_file["./"].nil?
+                          swagger_file
+                        else
+                          Dir.pwd.to_s + "/" + swagger_file.gsub("./", "")
+                        end
+      unless File.exist?(file_to_convert)
+        raise "The file #{file_to_convert} doesn't exist"
+      end
+
+      file_errors = file_to_convert + ".errors.log"
+      File.delete(file_errors) if File.exist?(file_errors)
+      import_errors = ""
+
+      definition = OasParser::Definition.resolve(swagger_file)
+      raw = definition.raw.deep_symbolize_keys
+
+      if raw.key?(:openapi) && (raw[:openapi].to_f > 0)
+        raw[:swagger] = raw[:openapi]
+      end
+      if raw[:swagger].to_f < 2.0
+        raise "Unsupported Swagger version. Only versions >= 2.0 are valid."
+      elsif raw[:swagger].to_f >= 3.0
+        message = "Take in consideration Open API #{raw[:swagger]} is not fully supported for the moment while we are in preliminary version of open_api_import."
+        warn message
+        @logger.warn message
+      end
+
+      base_host = ""
+      base_path = ""
+
+      base_host = raw[:host] if raw.key?(:host)
+      base_path = raw[:basePath] if raw.key?(:basePath)
+      module_name = raw[:info][:title].camel_case
+      module_version = "V#{raw[:info][:version].to_s.snake_case}"
+
+      output = []
+      output_header = []
+      output_header << "#" * 50
+      output_header << "# #{raw[:info][:title]}"
+      output_header << "# version: #{raw[:info][:version]}"
+      output_header << "# description: "
+      raw[:info][:description].to_s.split("\n").each do |d|
+        output_header << "#     #{d}" unless d == ""
+      end
+      output_header << "#" * 50
+
+      output_header << "module Swagger"
+      output_header << "module #{module_name}"
+      output_header << "module #{module_version}"
+      output_header << "module Requests" if name_for_module == :fixed
+
+      files = {}
+
+      module_requests = ""
+
+      definition.paths.each do |path|
+        raw = path.raw.deep_symbolize_keys
+
+        if raw.key?(:parameters)
+          raw.each do |met, cont|
+            if met != :parameters
+              if raw[met].key?(:parameters)
+                raw[met][:parameters] = raw[met][:parameters] & raw[:parameters]
+              else
+                raw[met][:parameters] = raw[:parameters]
+              end
+            end
+          end
+          raw.delete(:parameters)
+        end
+
+        raw.each do |met, cont|
+          if %w[get post put delete patch].include?(met.to_s.downcase)
+            params = []
+            params_path = []
+            params_query = []
+            description_parameters = []
+            data_required = []
+            data_read_only = []
+            data_default = []
+            data_examples = []
+            data_pattern = []
+            responses = []
+
+            # for the case operationId is missing
+            cont[:operationId] = "unknown" unless cont.key?(:operationId)
+
+            if create_method_name == :path
+              method_name = (met.to_s + "_" + path.path.to_s).snake_case
+              method_name.chop! if method_name[-1] == "_"
+            elsif create_method_name == :operation_id
+              method_name = (cont[:operationId]).to_s.snake_case
+            else
+              method_name = cont[:operationId]
+            end
+
+            path_txt = path.path.dup.to_s
+            if name_for_module == :path or name_for_module == :path_file
+              old_module_requests = module_requests
+              # to remove version from path fex: /v1/Customer
+              path_requests = path_txt.gsub(/^\/v[\d\.]*\//i, "")
+              # to remove version from path fex: /1.0/Customer
+              path_requests = path_requests.gsub(/^\/[\d\.]*\//i, "")
+              if (path_requests == path_txt) && (path_txt.scan("/").size == 1)
+                # no folder in path
+                module_requests = "Root"
+              else
+                res_path = path_requests.scan(/(\w+)/)
+                module_requests = res_path[0][0].camel_case
+              end
+              if old_module_requests != module_requests
+                output << "end" unless old_module_requests == "" or name_for_module == :path_file
+                if name_for_module == :path
+                  # to add the end for the previous module unless is the first one
+                  output << "module #{module_requests}"
+                else #:path_file
+                  if old_module_requests != ""
+                    unless files.key?(old_module_requests)
+                      files[old_module_requests] = Array.new
+                    end
+                    files[old_module_requests].concat(output)
+                    output = Array.new
+                  end
+                  output << "module #{module_requests}" unless files.key?(module_requests) # dont add in case already existed
+                end
+              end
+            end
+
+            output << ""
+            output << "# operationId: #{cont[:operationId]}, method: #{met}"
+            output << "# summary: #{cont[:summary]}"
+            if !cont[:description].to_s.split("\n").empty?
+              output << "# description: "
+              cont[:description].to_s.split("\n").each do |d|
+                output << "#     #{d}" unless d == ""
+              end
+            else
+              output << "# description: #{cont[:description]}"
+            end
+
+            mock_example = []
+            if include_responses && cont.key?(:responses) && cont[:responses].is_a?(Hash)
+              cont[:responses].each do |k, v|
+                response_example = []
+
+                response_example = get_response_examples(v)
+                
+
+                if !response_example.empty?
+                  responses << "'#{k}': { "
+                  responses << "message: '#{v[:description]}', "
+                  responses << "data: "
+                  responses << response_example
+                  responses << "},"
+                  
+                  if mock_response and mock_example.size==0
+                    mock_example << "code: '#{k}',"
+                    mock_example << "message: '#{v[:description]}',"
+                    mock_example << "data: "
+                    mock_example << response_example
+                  end
+                  
+                else
+                  responses << "'#{k}': { message: '#{v[:description]}'}, "
+                end
+
+              end
+            end
+
+            # todo: for open api 3.0 is not getting the required params
+            if cont.key?(:parameters) && cont[:parameters].is_a?(Array)
+              cont[:parameters].each do |p|
+                if p[:in] == "path"
+                  if create_method_name == :operationId
+                    params_path << p[:name]
+                    path_txt.gsub!("{#{p[:name]}}", "\#{#{p[:name]}}")
+                  else
+                    params_path << p[:name].to_s.snake_case
+                    path_txt.gsub!("{#{p[:name]}}", "\#{#{p[:name].to_s.snake_case}}")
+                  end
+                  if p.keys.include?(:description)
+                    description_parameters << "#    #{p[:name]}: (#{p[:type]}) #{p[:description]}"
+                  end
+                elsif p[:in] == "query"
+                  params_query << p[:name]
+                  if p.keys.include?(:description)
+                    description_parameters << "#    #{p[:name]}: (#{p[:type]}) #{p[:description]}"
+                  end
+                elsif p[:in] == "body"
+                  if p.keys.include?(:schema)
+                    #jal
+                    if p[:schema].key?(:oneOf)
+                      bodies = p[:schema][:oneOf]
+                    elsif p[:schema].key?(:anyOf)
+                      bodies = p[:schema][:anyOf]
+                    elsif p[:schema].key?(:allOf)
+                      bodies = p[:schema][:allOf]
+                    else
+                      bodies = [p[:schema]]
+                    end
+
+                    params_data = []
+
+                    bodies.each do |body|
+                      if body.keys.include?(:required) and body[:required].size > 0
+                        output << "# required data: #{body[:required].join(", ")}"
+                        data_required += body[:required]
+                      end
+
+                      if body.keys.include?(:properties) and body[:properties].size > 0
+                        body[:properties].each { |dpk, dpv|
+                          if dpv.keys.include?(:example)
+                            valv = dpv[:example]
+                          else
+                            valv = ""
+                          end
+                          if dpv.keys.include?(:description)
+                            description_parameters << "#    #{dpk}: (#{dpv[:type]}) #{dpv[:description]}"
+                          end
+                          if dpv.keys.include?(:pattern)
+                            data_pattern << "#{dpk}: /#{dpv[:pattern].to_s.gsub("\\/", "\/")}/"
+                          end
+                          if dpv.keys.include?(:readOnly) and dpv[:readOnly] == true
+                            data_read_only << dpk
+                          end
+                          if dpv.keys.include?(:default)
+                            if dpv.type != "string"
+                              data_default << "#{dpk}: #{dpv[:default]}"
+                            else
+                              data_default << "#{dpk}: '#{dpv[:default]}'"
+                            end
+                          end
+
+                          if dpv[:type].downcase == "string"
+                            valv = '"' + valv + '"'
+                          else
+                            #todo: consider check default and insert it
+                            if valv.to_s == ""
+                              valv = '"' + valv + '"'
+                            end
+                          end
+                          params_data << "#{dpk}: #{valv}"
+                        }
+                        if params_data.size > 0
+                          data_examples << params_data
+                          params_data = []
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+
+              params = params_path
+
+              unless params_query.empty?
+                path_txt += "?"
+                params_query.each do |pq|
+                  if create_method_name == :operationId
+                    path_txt += "#{pq}=\#{#{pq}}&"
+                    params << "#{pq}: ''"
+                  else
+                    path_txt += "#{pq}=\#{#{pq.to_s.snake_case}}&"
+                    params << "#{pq.to_s.snake_case}: ''"
+                  end
+                end
+              end
+            end
+
+            if description_parameters.size > 0
+              output << "# parameters description: "
+              output << description_parameters
+            end
+
+            output << "def self.#{method_name} (#{params.join(", ")})"
+
+            output << "{"
+
+            output << "path: \"#{base_path}#{path_txt}\","
+
+            output << "method: :#{met}," if met.to_s != ""
+
+            unless data_required.empty?
+              output << "data_required: ["
+              output << ":#{data_required.uniq.join(", :")}"
+              output << "],"
+            end
+            unless data_read_only.empty?
+              output << "data_read_only: ["
+              output << ":#{data_read_only.uniq.join(", :")}"
+              output << "],"
+            end
+            unless data_default.empty?
+              output << "data_default: {"
+              output << data_default.join(", \n")
+              output << "},"
+            end
+
+            unless data_pattern.empty?
+              output << "data_pattern: {"
+              output << data_pattern.uniq.join(", \n")
+              output << "},"
+            end
+
+            unless data_examples.empty?
+              output << "data_examples: ["
+              data_examples.each do |data|
+                output << "{"
+                output << data.join(", \n")
+                output << "}, "
+              end
+              output << "],"
+            end
+
+            unless mock_example.empty?
+              output << "mock_response: {"
+              output << mock_example
+              output << "},"
+            end
+
+            unless responses.empty?
+              output << "responses: {"
+              output << responses
+              output << "},"
+            end
+
+            output << "}"
+            output << "end"
+          else
+            @logger.warn "Not imported method: #{met} for path: #{path.path} since it is not supported by OpenApiImport"
+          end
+        end
+      end
+
+      output_footer = []
+
+      output_footer << "end" unless (module_requests == "") && (name_for_module == :path or name_for_module == :path_file)
+      output_footer << "end" << "end" << "end"
+
+      if files.size == 0
+        output = output_header + output + output_footer
+        output_txt = output.join("\n")
+        requests_file_path = file_to_convert + ".rb"
+        File.open(requests_file_path, "w") { |file| file.write(output_txt) }
+        `rufo #{requests_file_path}`
+        message = "** Requests file: #{swagger_file}.rb that contains the code of the requests after importing the Swagger file"
+        puts message
+        @logger.info message
+      else
+        files[module_requests] = output #for the last one
+        requires_txt = ""
+        message = "** Generated files that contain the code of the requests after importing the Swagger file: "
+        puts message
+        @logger.info message
+        files.each do |mod, out_mod|
+          output = output_header + out_mod + output_footer
+          output_txt = output.join("\n")
+          requests_file_path = file_to_convert + "_" + mod + ".rb"
+          requires_txt += "require_relative '#{File.basename(swagger_file)}_#{mod}'\n"
+          File.open(requests_file_path, "w") { |file| file.write(output_txt) }
+          `rufo #{requests_file_path}`
+          message = "  - #{requests_file_path}"
+          puts message
+          @logger.info message
+        end
+
+        requests_file_path = file_to_convert + ".rb"
+        File.open(requests_file_path, "w") { |file| file.write(requires_txt) }
+        `rufo #{requests_file_path}`
+        message = "** File that contains all the requires for all Request files: \n"
+        message += "   - #{requests_file_path} "
+        puts message
+        @logger.info message
+      end
+
+      begin
+        res = eval(output_txt)
+      rescue Exception => stack
+        import_errors += "\n\nResult evaluating the ruby file generated: \n" + stack.to_s
+      end
+
+      if import_errors.to_s != ""
+        File.open(file_errors, "w") { |file| file.write(import_errors) }
+        message = "* It seems there was a problem importing the Swagger file #{file_to_convert}\n"
+        message += "* Take a look at the detected errors at #{file_errors}\n"
+        warn message
+        @logger.fatal message
+        return false
+      else
+        return true
+      end
+    rescue StandardError => stack
+      puts stack.message
+      @logger.fatal stack.message
+      @logger.fatal stack.backtrace
+      puts stack.backtrace
+    end
+  end
+
+  class << self
+    # Retrieve the examples from the properties hash
+    private def get_examples(properties)
+      #todo: consider using this method also to get data examples
+      example = []
+      example << "{" unless properties.empty?
+      properties.each do |prop, val|
+        if val.key?(:example)
+          example << if val[:example].is_a?(String)
+            " #{prop.to_sym}: \"#{val[:example]}\", "
+          else
+            " #{prop.to_sym}: #{val[:example]}, "
+          end
+        elsif val.key?(:type)
+          format = val[:format]
+          format = val[:type] if format.to_s == ""
+          case val[:type].downcase
+          when "string"
+            example << " #{prop.to_sym}: \"#{format}\", "
+          when "integer", "number"
+            example << " #{prop.to_sym}: 0, "
+          when "boolean"
+            example << " #{prop.to_sym}: true, "
+          when "array"
+            if val.key?(:items) and val[:items].key?(:enum)
+              if val[:items][:enum][0].is_a?(String)
+                example << " #{prop.to_sym}: \"" + val[:items][:enum].sample + "\", "
+              else
+                example << " #{prop.to_sym}: " + val[:items][:enum].sample + ", "
+              end
+            else
+              #todo: differ between response examples and data examples
+              example << " #{prop.to_sym}: " + get_response_examples({schema: val}).join("\n") + ", "
+            end
+          when "object"
+            #todo: differ between response examples and data examples
+            res_ex = get_response_examples({schema: val})
+            if res_ex.size == 0
+              res_ex = "{ }"
+            else
+              res_ex = res_ex.join("\n")
+            end
+            example << " #{prop.to_sym}: " + res_ex + ", "
+          else
+            example << " #{prop.to_sym}: \"#{format}\", "
+          end
+        end
+      end
+      example << "}" unless properties.empty?
+      example
+    end
+
+    # Retrieve the response examples from the hash
+    private def get_response_examples(v)
+      # TODO: take in consideration the case allOf, oneOf... schema.items.allOf[0].properties schema.items.allOf[1].properties
+      # example on https://github.com/OAI/OpenAPI-Specification/blob/master/examples/v2.0/yaml/petstore-expanded.yaml
+      response_example = Array.new()
+      if v.key?(:examples) && v[:examples].is_a?(Hash) && v[:examples].key?(:'application/json')
+        if v[:examples][:'application/json'].is_a?(String)
+          response_example << v[:examples][:'application/json']
+        elsif v[:examples][:'application/json'].is_a?(Hash)
+          exs = v[:examples][:'application/json'].to_s
+          exs.gsub!(/:(\w+)=>/, "\n\\1: ")
+          response_example << exs
+        elsif v[:examples][:'application/json'].is_a?(Array)
+          response_example << "["
+          v[:examples][:'application/json'].each do |ex|
+            exs = ex.to_s
+            if ex.is_a?(Hash)
+              exs.gsub!(/:(\w+)=>/, "\n\\1: ")
+            end
+            response_example << (exs + ", ")
+          end
+          response_example << "]"
+        end
+      elsif v.key?(:schema) && v[:schema].is_a?(Hash) &&
+            (v[:schema].key?(:properties) ||
+             (v[:schema].key?(:items) && v[:schema][:items].key?(:properties)) ||
+             (v[:schema].key?(:items) && v[:schema][:items].key?(:allOf)) ||
+             v[:schema].key?(:allOf))
+        properties = {}
+        if v[:schema].key?(:properties)
+          properties = v[:schema][:properties]
+        elsif v[:schema].key?(:allOf)
+          v[:schema][:allOf].each do |pr|
+            properties.merge!(pr[:properties]) if pr.key?(:properties)
+          end
+        elsif v[:schema][:items].key?(:properties)
+          properties = v[:schema][:items][:properties]
+          response_example << "["
+        elsif v[:schema][:items].key?(:allOf)
+          v[:schema][:items][:allOf].each do |pr|
+            properties.merge!(pr[:properties]) if pr.key?(:properties)
+          end
+          response_example << "["
+        end
+
+        response_example += get_examples(properties) unless properties.empty?
+
+        unless response_example.empty?
+          if v[:schema].key?(:properties) || v[:schema].key?(:allOf)
+            #
+          else # array, items
+            response_example << "]"
+          end
+        end
+      elsif v.key?(:schema) and v[:schema].key?(:items) and v[:schema][:items].key?(:type)
+        # for the case only type supplied but nothing else for the array
+        response_example << "[\"#{v[:schema][:items][:type]}\"]"
+      end
+      return response_example
+    end
+  end
+end

data/lib/open_api_import/utils.rb

@@ -0,0 +1,22 @@
+class String
+  ########################################################
+  # Convert to snake_case a string
+  ########################################################
+  def snake_case
+    gsub(/\W/, '_')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z])([A-Z])/, '\1_\2')
+      .downcase
+      .gsub(/_+/, '_')
+  end
+
+  ########################################################
+  # Convert to CamelCase a string
+  ########################################################
+  def camel_case
+    return self if self !~ /_/ && self !~ /\s/ && self =~ /[A-Z]+.*/
+
+    gsub(/\W/, '_')
+      .split('_').map(&:capitalize).join
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: open_api_import
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mario Ruiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oas_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+- !ruby/object:Gem::Dependency
+  name: rufo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: nice_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.22
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.22
+description: OpenApiImport -- Import a Swagger or Open API file and create a Ruby
+  Request Hash file including all requests and responses with all the examples. The
+  file can be in JSON or YAML
+email: marioruizs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- lib/open_api_import.rb
+- lib/open_api_import/utils.rb
+homepage: https://github.com/MarioRuiz/open_api_import
+licenses:
+- MIT
+metadata: {}
+post_install_message: Thanks for installing! Visit us on https://github.com/MarioRuiz/open_api_import
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: OpenApiImport -- Import a Swagger or Open API file and create a Ruby Request
+  Hash file including all requests and responses with all the examples. The file can
+  be in JSON or YAML
+test_files: []