open_api_import 0.10.9 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e1707e266a2104ec005d5c7d5081ffd51c9a012bf1bc6320403377c934998d3
-  data.tar.gz: 1babbe0d881bd6f1823935cf6d66447cfa8f5a91df4106e9d87f1ac0fe792aac
+  metadata.gz: f325c36f3cd721eaeedafc552c28ae05aeaca61e1b28db412b1a43c7b1eb94b9
+  data.tar.gz: '08e087bd46c830537ff2302af6f9d0ec71003ea48836bb36f59890a41ef5a1da'
 SHA512:
-  metadata.gz: efb801027685d7156f499f110028ffae75fac89032598bc447d2b1c6e1f4acd7fe61905a509e3d6faa4d5d74348257faa98adc3c69d6c1e90f5719a55b1dfac7
-  data.tar.gz: 7bf47753113ba141a5e7798f40caa958f27534082484286d483d03fbcf8a1f6881c4ddb3cb1111154790a21bcee77eecfbc366e2af8b75ae261507985f3c3dd4
+  metadata.gz: 416f1458f279a4a1c6e4c69ee55997fd36c133ff72ffa12b584777e4f60baffcf5327c0e685dd21c7f02c84d85a2c3152137784d86354e0cfe59abbd93aaf2eb
+  data.tar.gz: 8b63487982fe8884a9ad220e707c847a03cad7d1aada0e0d9ad156492cb65e51d027063e9320e5898335ecf26b4b7eb9f3c066ba58539815538764dfe32a7e2b

data/lib/open_api_import/filter.rb

@@ -0,0 +1,28 @@
+module LibOpenApiImport
+  #filter hash
+  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 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
+          kn = k.to_s.split(".")
+          vn = kn[1].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}}
+          result[k.keys[0]][k.values[0]] = filter(hash[k.keys[0]], k.values[0]).values[0]
+        end
+      end
+    end
+    return result
+  end
+end

data/lib/open_api_import/get_data_all_of_bodies.rb

@@ -0,0 +1,22 @@
+module LibOpenApiImport
+  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)
+      q = p[:schema][:allOf]
+    else
+      q = [p]
+    end
+    q.each do |pt|
+      if pt.is_a?(Hash) and 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
+  end
+end

data/lib/open_api_import/get_examples.rb

@@ -0,0 +1,88 @@
+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
+    example = []
+    example << "{" unless properties.empty? or 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"
+        end
+        if val.key?(:items) and !val.key?(:example) and !val.key?(:type)
+          val[: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
+          else
+            if val[:example].is_a?(String)
+              val[:example].gsub!('"', "'")
+              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
+          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].size == 1 and val[:items].is_a?(Hash) and val[:items].key?(:type)
+              val[:items][:enum] = [val[:items][:type]]
+            end
+
+            if val.key?(:items) 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 type == :only_value
+                if val[:items][:enum][0].is_a?(String)
+                  example << " [\"" + val[:items][:enum][0] + "\"] "
+                else
+                  example << " [" + val[:items][:enum][0] + "] "
+                end
+              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
+              end
+            else
+              #todo: differ between response examples and data examples
+              examplet = get_response_examples({ schema: val }, remove_readonly).join("\n")
+              examplet = '[]' if examplet.empty?
+              if type == :only_value
+                example << examplet
+              else
+                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
+              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
+    end
+    example << "}" unless properties.empty? or type == :only_value
+    example
+  end
+end

data/lib/open_api_import/get_patterns.rb

@@ -0,0 +1,67 @@
+module LibOpenApiImport
+  # Get patterns
+  private def get_patterns(dpk, dpv)
+    data_pattern = []
+    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].include?('\\x')
+        data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s.gsub('\\x', '\\u')}/"
+      else
+        data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s}/"
+      end
+    elsif dpv.key?(:minLength) and dpv.key?(:maxLength)
+      data_pattern << "'#{dpk}': :'#{dpv[:minLength]}-#{dpv[:maxLength]}:LN$'"
+    elsif dpv.key?(:minLength) and !dpv.key?(:maxLength)
+      data_pattern << "'#{dpk}': :'#{dpv[:minLength]}:LN$'"
+    elsif !dpv.key?(:minLength) and dpv.key?(:maxLength)
+      data_pattern << "'#{dpk}': :'0-#{dpv[:maxLength]}:LN$'"
+    elsif dpv.key?(:minimum) and dpv.key?(:maximum) and dpv[:type] == "string"
+      data_pattern << "'#{dpk}': :'#{dpv[:minimum]}-#{dpv[:maximum]}:LN$'"
+    elsif dpv.key?(:minimum) and dpv.key?(:maximum)
+      data_pattern << "'#{dpk}': #{dpv[:minimum]}..#{dpv[:maximum]}"
+    elsif dpv.key?(:minimum) and !dpv.key?(:maximum)
+      if RUBY_VERSION >= "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)
+      data_pattern << "'#{dpk}': 0..#{dpv[:maximum]}"
+    elsif dpv[:format] == "date-time"
+      data_pattern << "'#{dpk}': DateTime"
+    elsif dpv[: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"}}
+      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']}}}
+      dpv[:items][:properties].each do |dpkk, dpvv|
+        if dpk == ""
+          data_pattern += get_patterns("#{dpkk}", 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)
+      dpv[:properties].each do |dpkk, dpvv|
+        if dpk == ""
+          data_pattern += get_patterns("#{dpkk}", dpvv)
+        else
+          data_pattern += get_patterns("#{dpk}.#{dpkk}", dpvv)
+        end
+      end
+    end
+    data_pattern.uniq!
+    return data_pattern
+  end
+end

data/lib/open_api_import/get_required_data.rb

@@ -0,0 +1,30 @@
+module LibOpenApiImport
+  # Get required data
+  private def get_required_data(body)
+    data_required = []
+    if body.keys.include?(:required) and body[:required].size > 0
+      body[:required].each do |r|
+        data_required << r.to_sym
+      end
+    end
+    if body.key?(:allOf)
+      body[:allOf].each do |r|
+        if r.key?(:required)
+          r[:required].each do |r2|
+            data_required << r2.to_sym
+          end
+        end
+      end
+    end
+    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
+        dr = get_required_data(body[:properties][key])
+        dr.each do |k|
+          data_required.push("#{key}.#{k}".to_sym)
+        end
+      end
+    end
+    return data_required
+  end
+end

data/lib/open_api_import/get_response_examples.rb

@@ -0,0 +1,104 @@
+module LibOpenApiImport
+  # Retrieve the response examples from the hash
+  private 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()
+    # 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
+    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
+        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
+      # 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.
+        # we need to decide how to manage to do it correctly
+        if tv.key?(:value)
+          tresp = tv[:value]
+        else
+          tresp = ""
+        end
+        if tresp.is_a?(String)
+          response_example << tresp
+        elsif tresp.is_a?(Hash)
+          exs = tresp.to_s
+          exs.gsub!(/:(\w+)=>/, "\n\\1: ")
+          response_example << exs
+        elsif tresp.is_a?(Array)
+          response_example << "["
+          tresp.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
+        break #only the first one it is considered
+      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, :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
+      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
+    response_example.each do |rs|
+      #(@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
+  end
+end