open_api_import 0.10.11 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ff3ff403e355b1f422b8d005c1302c2c22f77507d2c1785fe5446050e044096
-  data.tar.gz: 5f2c733cac57f1db5e88504e3aba1db7b61241378ecdb89d7ed68e1012e95012
+  metadata.gz: a1a667b9e2ed3c9f4edc515345bdc6d85929fa6274138b6201ed8c72de085174
+  data.tar.gz: 4824ac5351b6e45e9ac82ef3979e39c706a28134469de1dde945f88278728337
 SHA512:
-  metadata.gz: 583ae4003d2bb422e87cd0502b4f0cd317ffbb0919c1113d44d8173546dee5afdb32a0e8b62b1bea89aa18a713c4b8fb2a6299a90ed2de233c9d1890aeffcdd5
-  data.tar.gz: f392b2a77e39447efec45dca83a13deb22d2561e96432487a7bf25861b95d9e059006311fd316fa6e989de22b66c6d3c981e6d0c80b60cca9618b75364ded7f0
+  metadata.gz: 5795d34e5541ba890be3804f6d14fe13eec276f66e5dc5ab14430bd4eecda2ae633e2ae1fc50a1a7c60ba5d52d1627072770cce8c996f4e4a11503f8981ee79b
+  data.tar.gz: be67993cee72e6df7d7d81a4e572c0db3ed814c6c637fb5c57ac6a3e59dcfc98b7f3a1e5eeca856b8a9578c766c8396540fb2fe26b3340a931e8d7681fc72bdd

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