open_api_import 0.11.6 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a01ca19a4354a284ca035b69bd944630714368e614b9284dfcf9ccb46763101
-  data.tar.gz: 20fd5d69e55c0085e1be0785f29e9ecd7e40201fbed6dd839253460c8c8a03e3
+  metadata.gz: 41480087861a00b2fce54a5096291bcfa12db19f719cfcf1e133b069610c4786
+  data.tar.gz: c02407e9c86894f23aea9c3ba28522ddb91f0c1957722a7d51cd99c231f6ff9d
 SHA512:
-  metadata.gz: 4ece74df6c4bb6ae7f74c71c5f185abb42ae08ea28b1be551b57e16dc714568d96d6bb344df0334b1f3f8d3f96cf36f1994f0a98f72a0beb0ca78c8940c40e00
-  data.tar.gz: 7327cff8935f77502f418451e0635b9a3814ecb76b227141dbf0155e37e4f02f88e26c04148c679b0e0ea8658c3eb6c8de2ed0acdc4d576d11f841d5cb81921a
+  metadata.gz: e7bbc02cd6f7abed67c1476da7f83bce7d4ad5a538453c300059824d24f68816e511a8c7ce19d2274d011b7e1364d5c58455b600f734f76a82790fd55220422c
+  data.tar.gz: 43cfb5083b2188484dae5d2b637c75774915fd75356a95425ca252dde067da7863a9db68269271ec46e71100a5083818ce529a270bd16ff2f37d4f21a3e728e9

data/README.md

@@ -1,10 +1,10 @@
 # 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)
+[![CI](https://github.com/MarioRuiz/open_api_import/actions/workflows/ci.yml/badge.svg)](https://github.com/MarioRuiz/open_api_import/actions/workflows/ci.yml)
 [![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.
+Import a Swagger or Open API file (including Open API 3.1) 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...
 
@@ -68,6 +68,10 @@ This is the output of the previous run:
 - Helper: ./spec/helper.rb
 ```
 
+## Requirements
+
+- Ruby >= 3.0
+
 ## Installation
 
 Install it yourself as:
@@ -102,6 +106,7 @@ More info: https://github.com/MarioRuiz/open_api_import
 In case no options supplied:
   * It will be used the value of operation_id on snake_case for the name of the methods
   * It will be used the first folder of the path to create the module name
+    -v, --version                    Display the version
     -n, --no_responses               if you don't want to add the examples of responses in the resultant file.
     -m, --mock                       Add the first response on the request as mock_response
     -p, --path_method                it will be used the path and http method to create the method names
@@ -111,6 +116,7 @@ In case no options supplied:
     -F, --fixed_module               all the requests will be under the module Requests
     -s, --silent                     It will display only errors
     -c, --create_constants           For required arguments, it will create keyword arguments assigning by default a constant.
+    -d, --dry_run                    Preview the generated output without writing files
 ```
 
 
@@ -490,6 +496,23 @@ It will include this on the output file:
 ...
 ```
 
+### return_data
+
+Instead of writing files to disk, return a Hash of `{filename => content}`. This is useful for previewing the output or programmatically processing the generated code.
+
+Accepts true or false, by default is false.
+
+```ruby
+  require 'open_api_import'
+
+  result = OpenApiImport.from "./spec/fixtures/v2.0/yaml/petstore-simple.yaml", return_data: true
+
+  result.each do |filepath, content|
+    puts "--- #{filepath} ---"
+    puts content
+  end
+```
+
 ### create_constants
 
 The methods will be generated using keyword arguments and for required arguments, it will create keyword arguments assigning by default a constant.

data/bin/open_api_import

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
-require 'optparse'
-require 'open_api_import'
+require "optparse"
+require "open_api_import"
 
 options = {
   name_for_module: :path
@@ -8,12 +8,17 @@ options = {
 
 optparse = OptionParser.new do |opts|
   opts.banner = "Usage: open_api_import [open_api_file] [options]\n"
-  opts.banner+= "Import a Swagger or Open API file and create a Ruby Request Hash file including all requests and responses.\n"
-  opts.banner+= "More info: https://github.com/MarioRuiz/open_api_import\n\n"
-  opts.banner+= "In case no options supplied: \n"
-  opts.banner+= "  * It will be used the value of operation_id on snake_case for the name of the methods\n"
-  opts.banner+= "  * It will be used the first folder of the path to create the module name\n"
-  
+  opts.banner += "Import a Swagger or Open API file and create a Ruby Request Hash file including all requests and responses.\n"
+  opts.banner += "More info: https://github.com/MarioRuiz/open_api_import\n\n"
+  opts.banner += "In case no options supplied: \n"
+  opts.banner += "  * It will be used the value of operation_id on snake_case for the name of the methods\n"
+  opts.banner += "  * It will be used the first folder of the path to create the module name\n"
+
+  opts.on("-v", "--version", "Display the version") do
+    puts "open_api_import #{OpenApiImport::VERSION}"
+    exit
+  end
+
   opts.on("-n", "--no_responses", "if you don't want to add the examples of responses in the resultant file.") do
     options[:include_responses] = false
   end
@@ -50,7 +55,9 @@ optparse = OptionParser.new do |opts|
     options[:create_constants] = true
   end
 
-
+  opts.on("-d", "--dry_run", "Preview the generated output without writing files") do
+    options[:return_data] = true
+  end
 end
 
 optparse.parse!
@@ -65,9 +72,16 @@ if options.key?(:create_files)
 end
 
 filename = ARGV.pop
-if filename.to_s==''
+if filename.to_s == ""
   puts optparse
   puts "** Need to specify at least a file to import."
 else
-  OpenApiImport.from filename, **options
+  result = OpenApiImport.from filename, **options
+  if options[:return_data] && result.is_a?(Hash)
+    result.each do |filepath, content|
+      puts "--- #{filepath} ---"
+      puts content
+      puts
+    end
+  end
 end

data/lib/open_api_import/filter.rb

@@ -1,28 +1,32 @@
+# frozen_string_literal: true
+
 module LibOpenApiImport
-  #filter hash
+  private
+
   def filter(hash, keys, nested = false)
     result = {}
     keys = [keys] unless keys.is_a?(Array)
     if nested
       result = hash.nice_filter(keys)
     else
-      #to be backwards compatible
       keys.each do |k|
-        if k.is_a?(Symbol) and hash.key?(k)
+        if k.is_a?(Symbol) && hash.key?(k)
           if hash[k].is_a?(Hash)
             result[k] = {}
           else
             result[k] = hash[k]
           end
-        elsif k.is_a?(Symbol) and k.to_s.include?(".") and hash.key?((k.to_s.scan(/(\w+)\./).join).to_sym) #nested 'uno.dos.tres
+        elsif k.is_a?(Symbol) && k.to_s.include?(".") && hash.key?(k.to_s.scan(/(\w+)\./).join.to_sym)
           kn = k.to_s.split(".")
           vn = kn[1].to_sym
+          result[kn.first.to_sym] ||= {}
           result[kn.first.to_sym][vn] = filter(hash[kn.first.to_sym], vn).values[0]
-        elsif k.is_a?(Hash) and hash.key?(k.keys[0]) #nested {uno: {dos: :tres}}
+        elsif k.is_a?(Hash) && hash.key?(k.keys[0])
+          result[k.keys[0]] ||= {}
           result[k.keys[0]][k.values[0]] = filter(hash[k.keys[0]], k.values[0]).values[0]
         end
       end
     end
-    return result
+    result
   end
 end

data/lib/open_api_import/get_data_all_of_bodies.rb

@@ -1,22 +1,26 @@
+# frozen_string_literal: true
+
 module LibOpenApiImport
-  private def get_data_all_of_bodies(p)
+  private
+
+  def get_data_all_of_bodies(p)
     bodies = []
     data_examples_all_of = false
     if p.is_a?(Array)
       q = p
-    elsif p.key?(:schema) and p[:schema].key?(:allOf)
+    elsif p.key?(:schema) && p[:schema].key?(:allOf)
       q = p[:schema][:allOf]
     else
       q = [p]
     end
     q.each do |pt|
-      if pt.is_a?(Hash) and pt.key?(:allOf)
+      if pt.is_a?(Hash) && pt.key?(:allOf)
         bodies += get_data_all_of_bodies(pt[:allOf])[1]
         data_examples_all_of = true
       else
         bodies << pt
       end
     end
-    return data_examples_all_of, bodies
+    [data_examples_all_of, bodies]
   end
 end

data/lib/open_api_import/get_examples.rb

@@ -1,34 +1,41 @@
+# frozen_string_literal: true
+
 module LibOpenApiImport
-  # Retrieve the examples from the properties hash
-  private def get_examples(properties, type = :key_value, remove_readonly = false)
-    #todo: consider using this method also to get data examples
+  private
+
+  def get_examples(properties, type = :key_value, remove_readonly = false)
     example = []
-    example << "{" unless properties.empty? or type == :only_value
+    example << "{" unless properties.empty? || (type == :only_value)
     properties.each do |prop, val|
-      unless remove_readonly and val.key?(:readOnly) and val[:readOnly] == true
-        if val.key?(:properties) and !val.key?(:example) and !val.key?(:type)
-          val[:type] = "object"
+      unless remove_readonly && val.key?(:readOnly) && (val[:readOnly] == true)
+        effective_type = val[:type]
+        if val.key?(:properties) && !val.key?(:example) && !val.key?(:type)
+          effective_type = "object"
         end
-        if val.key?(:items) and !val.key?(:example) and !val.key?(:type)
-          val[:type] = "array"
+        if val.key?(:items) && !val.key?(:example) && !val.key?(:type)
+          effective_type = "array"
         end
-        if val.key?(:example)
-          if val[:example].is_a?(Array) and val.key?(:type) and val[:type] == "string"
-            example << " #{prop.to_sym}: \"#{val[:example][0]}\", " # only the first example
+
+        effective_type = Array(effective_type).reject { |t| t == "null" }.first if effective_type.is_a?(Array)
+
+        effective_example = val[:example]
+        effective_example ||= val[:examples]&.first if val.key?(:examples) && val[:examples].is_a?(Array) && !val[:examples].empty?
+
+        if effective_example
+          if effective_example.is_a?(Array) && val.key?(:type) && (val[:type] == "string")
+            example << " #{prop.to_sym}: \"#{effective_example[0]}\", "
+          elsif effective_example.is_a?(String)
+            escaped = effective_example.include?("'") ? effective_example : effective_example.gsub('"', "'")
+            example << " #{prop.to_sym}: \"#{escaped}\", "
+          elsif effective_example.is_a?(Time)
+            example << " #{prop.to_sym}: \"#{effective_example}\", "
           else
-            if val[:example].is_a?(String)
-              val[:example].gsub!('"', "'") unless val.include?("'")
-              example << " #{prop.to_sym}: \"#{val[:example]}\", "
-            elsif val[:example].is_a?(Time)
-              example << " #{prop.to_sym}: \"#{val[:example]}\", "
-            else
-              example << " #{prop.to_sym}: #{val[:example]}, "
-            end
+            example << " #{prop.to_sym}: #{effective_example}, "
           end
-        elsif val.key?(:type)
+        elsif effective_type
           format = val[:format]
-          format = val[:type] if format.to_s == ""
-          case val[:type].downcase
+          format = effective_type if format.to_s == ""
+          case effective_type.downcase
           when "string"
             example << " #{prop.to_sym}: \"#{format}\", "
           when "integer"
@@ -36,61 +43,56 @@ module LibOpenApiImport
           when "number"
             format_name = format.to_s.downcase
             number_value = if %w[float double decimal].include?(format_name)
-              "0.0"
-            else
-              "0"
-            end
+                             "0.0"
+                           else
+                             "0"
+                           end
             example << " #{prop.to_sym}: #{number_value}, "
           when "boolean"
             example << " #{prop.to_sym}: true, "
           when "array"
-            if val.key?(:items) and val[:items].is_a?(Hash) and val[:items].size == 1 and val[:items].key?(:type)
-              val[:items][:enum] = [val[:items][:type]]
-            end
+            items_enum = if val.key?(:items) && val[:items].is_a?(Hash) && (val[:items].size == 1) && val[:items].key?(:type)
+                           [val[:items][:type]]
+                         elsif val.key?(:items) && !val[:items].nil? && val[:items].key?(:enum)
+                           val[:items][:enum]
+                         end
 
-            if val.key?(:items) and !val[:items].nil? and val[:items].key?(:enum)
-              #before we were getting in all these cases a random value from the enum, now we are getting the first position by default
-              #the reason is to avoid confusion later in case we want to compare two swaggers and verify the changes
+            if items_enum
               if type == :only_value
-                if val[:items][:enum][0].is_a?(String)
-                  example << " [\"" + val[:items][:enum][0] + "\"] "
+                if items_enum[0].is_a?(String)
+                  example << " [\"#{items_enum[0]}\"] "
                 else
-                  example << " [" + val[:items][:enum][0] + "] "
+                  example << " [#{items_enum[0]}] "
                 end
+              elsif items_enum[0].is_a?(String)
+                example << " #{prop.to_sym}: [\"#{items_enum[0]}\"], "
               else
-                if val[:items][:enum][0].is_a?(String)
-                  example << " #{prop.to_sym}: [\"" + val[:items][:enum][0] + "\"], "
-                else
-                  example << " #{prop.to_sym}: [" + val[:items][:enum][0] + "], "
-                end
+                example << " #{prop.to_sym}: [#{items_enum[0]}], "
               end
             else
-              #todo: differ between response examples and data examples
               examplet = get_response_examples({ schema: val }, remove_readonly).join("\n")
-              examplet = '[]' if examplet.empty?
+              examplet = "[]" if examplet.empty?
               if type == :only_value
                 example << examplet
               else
-                example << " #{prop.to_sym}: " + examplet + ", "
-              end              
-
+                example << " #{prop.to_sym}: #{examplet}, "
+              end
             end
           when "object"
-            #todo: differ between response examples and data examples
             res_ex = get_response_examples({ schema: val }, remove_readonly)
-            if res_ex.size == 0
+            if res_ex.empty?
               res_ex = "{ }"
             else
               res_ex = res_ex.join("\n")
             end
-            example << " #{prop.to_sym}: " + res_ex + ", "
+            example << " #{prop.to_sym}: #{res_ex}, "
           else
             example << " #{prop.to_sym}: \"#{format}\", "
           end
         end
       end
     end
-    example << "}" unless properties.empty? or type == :only_value
+    example << "}" unless properties.empty? || (type == :only_value)
     example
   end
 end

data/lib/open_api_import/get_patterns.rb

@@ -1,69 +1,77 @@
+# frozen_string_literal: true
+
 module LibOpenApiImport
-  # Get patterns
-  private def get_patterns(dpk, dpv)
+  private
+
+  def get_patterns(dpk, dpv)
     data_pattern = []
+    effective_type = dpv[:type]
+    effective_type = Array(effective_type).reject { |t| t == "null" }.first if effective_type.is_a?(Array)
+
     if dpv.keys.include?(:pattern)
-      #todo: control better the cases with back slashes
       if dpv[:pattern].include?('\\\\/')
-        #for cases like this: ^[^\.\\/:*?"<>|][^\\/:*?"<>|]{0,13}[^\.\\/:*?"<>|]?$
         data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s.gsub('\/', "/")}/"
-      elsif dpv[:pattern].match?(/\\x[0-9ABCDEF][0-9ABCDEF]\-/)
+      elsif dpv[:pattern].match?(/\\x[0-9ABCDEF][0-9ABCDEF]-/)
         data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s.gsub('\\x', '\\u00')}/"
       elsif dpv[:pattern].include?('\\x')
         data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s.gsub('\\x', '\\u')}/"
       else
-        data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s}/"
+        data_pattern << "'#{dpk}': /#{dpv[:pattern]}/"
       end
-    elsif dpv.key?(:minLength) and dpv.key?(:maxLength)
+    elsif dpv.key?(:minLength) && dpv.key?(:maxLength)
       data_pattern << "'#{dpk}': :'#{dpv[:minLength]}-#{dpv[:maxLength]}:LN$'"
-    elsif dpv.key?(:minLength) and !dpv.key?(:maxLength)
+    elsif dpv.key?(:minLength) && !dpv.key?(:maxLength)
       data_pattern << "'#{dpk}': :'#{dpv[:minLength]}:LN$'"
-    elsif !dpv.key?(:minLength) and dpv.key?(:maxLength)
+    elsif !dpv.key?(:minLength) && dpv.key?(:maxLength)
       data_pattern << "'#{dpk}': :'0-#{dpv[:maxLength]}:LN$'"
-    elsif dpv.key?(:minimum) and dpv.key?(:maximum) and dpv[:type] == "string"
+    elsif dpv.key?(:minimum) && dpv.key?(:maximum) && (effective_type == "string")
       data_pattern << "'#{dpk}': :'#{dpv[:minimum]}-#{dpv[:maximum]}:LN$'"
-    elsif dpv.key?(:minimum) and dpv.key?(:maximum)
+    elsif dpv.key?(:minimum) && dpv.key?(:maximum)
       data_pattern << "'#{dpk}': #{dpv[:minimum]}..#{dpv[:maximum]}"
-    elsif dpv.key?(:minimum) and !dpv.key?(:maximum)
-      if RUBY_VERSION >= "2.6.0"
+    elsif dpv.key?(:minimum) && !dpv.key?(:maximum)
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
         data_pattern << "'#{dpk}': #{dpv[:minimum]}.. "
       else
         data_pattern << "#'#{dpk}': #{dpv[:minimum]}.. # INFINITE only working on ruby>=2.6.0"
       end
-    elsif !dpv.key?(:minimum) and dpv.key?(:maximum)
+    elsif !dpv.key?(:minimum) && dpv.key?(:maximum)
       data_pattern << "'#{dpk}': 0..#{dpv[:maximum]}"
     elsif dpv[:format] == "date-time"
       data_pattern << "'#{dpk}': DateTime"
-    elsif dpv[:type] == "boolean"
+    elsif effective_type == "boolean"
       data_pattern << "'#{dpk}': Boolean"
     elsif dpv.key?(:enum)
       data_pattern << "'#{dpk}': :'#{dpv[:enum].join("|")}'"
-    elsif dpv[:type] == "array" and dpv.key?(:items) and dpv[:items].is_a?(Hash) and dpv[:items].key?(:enum) and dpv[:items][:enum].is_a?(Array)
-      #{:title=>"Balala", :type=>"array", :items=>{:type=>"string", :enum=>["uno","dos"], :example=>"uno"}}
+    elsif (effective_type == "array") && dpv.key?(:items) && dpv[:items].is_a?(Hash) && dpv[:items].key?(:enum) && dpv[:items][:enum].is_a?(Array)
       data_pattern << "'#{dpk}': [:'#{dpv[:items][:enum].join("|")}']"
-    elsif dpv[:type] == "array" and dpv.key?(:items) and dpv[:items].is_a?(Hash) and !dpv[:items].key?(:enum) and dpv[:items].key?(:properties)
-      #{:title=>"Balala", :type=>"array", :items=>{title: 'xxxx, properties: {server: {enum:['ibm','msa','pytan']}}}
+    elsif (effective_type == "array") && dpv.key?(:items) && dpv[:items].is_a?(Hash) && !dpv[:items].key?(:enum) && dpv[:items].key?(:properties)
       dpv[:items][:properties].each do |dpkk, dpvv|
         if dpk == ""
-          data_pattern += get_patterns("#{dpkk}", dpvv)
+          data_pattern += get_patterns(dpkk.to_s, dpvv)
         else
           data_pattern += get_patterns("#{dpk}.#{dpkk}", dpvv)
         end
       end
-    elsif dpv[:type] == "array" and dpv.key?(:items) and dpv[:items].is_a?(Hash) and
-          !dpv[:items].key?(:enum) and !dpv[:items].key?(:properties) and dpv[:items].key?(:type)
-      #{:title=>"labels", :description=>"Labels specified for the file system", :type=>"array", :items=>{:type=>"string", :enum=>["string"]}}
-      data_pattern << "'#{dpk}': [ #{get_patterns("", dpv[:items]).join[4..-1]} ]"
-    elsif dpv[:type] == "object" and dpv.key?(:properties)
+    elsif (effective_type == "array") && dpv.key?(:items) && dpv[:items].is_a?(Hash) &&
+          !dpv[:items].key?(:enum) && !dpv[:items].key?(:properties) && dpv[:items].key?(:type)
+      result = get_patterns("", dpv[:items])
+      if result.empty?
+        item_type = dpv[:items][:type]
+        item_type = Array(item_type).reject { |t| t == "null" }.first if item_type.is_a?(Array)
+        data_pattern << "'#{dpk}': [:'#{item_type}']"
+      else
+        data_pattern << "'#{dpk}': [ #{result.join[4..]} ]"
+      end
+    elsif (effective_type == "object") && dpv.key?(:properties)
       dpv[:properties].each do |dpkk, dpvv|
         if dpk == ""
-          data_pattern += get_patterns("#{dpkk}", dpvv)
+          data_pattern += get_patterns(dpkk.to_s, dpvv)
         else
           data_pattern += get_patterns("#{dpk}.#{dpkk}", dpvv)
         end
       end
     end
     data_pattern.uniq!
-    return data_pattern
+    data_pattern
   end
 end

data/lib/open_api_import/get_required_data.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module LibOpenApiImport
-  # Get required data
-  private def get_required_data(body)
+  private
+
+  def get_required_data(body)
     data_required = []
-    if body.keys.include?(:required) and body[:required].size > 0
+    if body.key?(:required) && body[:required].size.positive?
       body[:required].each do |r|
         data_required << r.to_sym
       end
@@ -16,15 +19,17 @@ module LibOpenApiImport
         end
       end
     end
+    nested_required = []
     data_required.each do |key|
-      if body.key?(:properties) and body[:properties][key].is_a?(Hash) and
-         body[:properties][key].key?(:required) and body[:properties][key][:required].size > 0
+      if body.key?(:properties) && body[:properties][key].is_a?(Hash) &&
+         body[:properties][key].key?(:required) && body[:properties][key][:required].size.positive?
         dr = get_required_data(body[:properties][key])
         dr.each do |k|
-          data_required.push("#{key}.#{k}".to_sym)
+          nested_required << :"#{key}.#{k}"
         end
       end
     end
-    return data_required
+    data_required.concat(nested_required)
+    data_required
   end
 end

data/lib/open_api_import/get_response_examples.rb

@@ -1,38 +1,42 @@
+# frozen_string_literal: true
+
 module LibOpenApiImport
+  private
+
   # Retrieve the response examples from the hash
-  private def get_response_examples(v, remove_readonly = false)
+  def get_response_examples(v, remove_readonly = false)
     # 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
     v = v.dup
-    response_example = Array.new()
+    response_example = []
     # for open api 3.0 with responses schema inside content
-    if v.key?(:content) && v[:content].is_a?(Hash) && v[:content].key?(:'application/json') &&
-       v[:content][:'application/json'].key?(:schema)
-      v = v[:content][:'application/json'].dup
+    if v.key?(:content) && v[:content].is_a?(Hash) && v[:content].key?(:"application/json") &&
+       v[:content][:"application/json"].key?(:schema)
+      v = v[:content][:"application/json"].dup
     end
-    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
+    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)
+      elsif v[:examples][:"application/json"].is_a?(Array)
         response_example << "["
-        v[:examples][:'application/json'].each do |ex|
+        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 + ", ")
+          response_example << "#{exs}, "
         end
         response_example << "]"
       end
       # for open api 3.0. examples on reponses, for example: api-with-examples.yaml
-    elsif v.key?(:content) && v[:content].is_a?(Hash) && v[:content].key?(:'application/json') &&
-          v[:content][:'application/json'].key?(:examples)
-      v[:content][:'application/json'][:examples].each do |tk, tv|
-        #todo: for the moment we only take in consideration the first example of response.
+    elsif v.key?(:content) && v[:content].is_a?(Hash) && v[:content].key?(:"application/json") &&
+          v[:content][:"application/json"].key?(:examples)
+      v[:content][:"application/json"][:examples].each_value do |tv|
+        # TODO: for the moment we only take in consideration the first example of response.
         # we need to decide how to manage to do it correctly
         if tv.key?(:value)
           tresp = tv[:value]
@@ -52,11 +56,11 @@ module LibOpenApiImport
             if ex.is_a?(Hash)
               exs.gsub!(/:(\w+)=>/, "\n\\1: ")
             end
-            response_example << (exs + ", ")
+            response_example << "#{exs}, "
           end
           response_example << "]"
         end
-        break #only the first one it is considered
+        break # only the first one it is considered
       end
     elsif v.key?(:schema) && v[:schema].is_a?(Hash) &&
           (v[:schema].key?(:properties) ||
@@ -82,23 +86,19 @@ module LibOpenApiImport
 
       response_example += get_examples(properties, :key_value, remove_readonly) unless properties.empty?
 
-      unless response_example.empty?
-        if v[:schema].key?(:properties) || v[:schema].key?(:allOf)
-          #
-        else # array, items
-          response_example << "]"
-        end
+      if !response_example.empty? && !(v[:schema].key?(:properties) || v[:schema].key?(:allOf)) # array, items
+        response_example << "]"
       end
-    elsif v.key?(:schema) and v[:schema].key?(:items) and v[:schema][:items].is_a?(Hash) and v[:schema][:items].key?(:type)
+    elsif v.key?(:schema) && v[:schema].key?(:items) && v[:schema][:items].is_a?(Hash) && v[:schema][:items].key?(:type)
       # for the case only type supplied but nothing else for the array
       response_example << "[\"#{v[:schema][:items][:type]}\"]"
     end
     response_example.each do |rs|
-      #(@type Google) for the case in example the key is something like: @type:
+      # (@type Google) for the case in example the key is something like: @type:
       if rs.match?(/^\s*@\w+:/)
         rs.gsub!(/@(\w+):/, '\'@\1\':')
       end
     end
-    return response_example
+    response_example
   end
 end