oas_parser_reborn 0.25.5

data/lib/oas_parser_reborn/pointer.rb

@@ -0,0 +1,64 @@
+module OasParser
+  class Pointer
+    def initialize(raw_pointer)
+      @raw_pointer = raw_pointer
+    end
+
+    def resolve(document)
+      return document if escaped_pointer == ""
+
+      tokens.reduce(document) do |nested_doc, token|
+        nested_doc.fetch(token) unless !nested_doc.key?(token)
+      end
+    end
+
+    # Detect circular reference by checking whether the ref exists in current path.
+    #
+    # Example:
+    # components:
+    #   schemas:
+    #     Pet:
+    #       type: object
+    #       properties:
+    #         name:
+    #           type: string
+    #         children:
+    #           type: array
+    #           items: # <--- parsing here
+    #             - $ref: '#/components/schemas/Pet'
+    #
+    # path: "/components/schemas/Pet/properties/children/items"
+    # raw_pointer: "#/components/schemas/Pet"
+    #
+    # It'd return true when we're parsing the pet children items where the ref points back to itself.
+    def circular_reference?(path)
+      path.include?("#{escaped_pointer}/")
+    end
+
+    def escaped_pointer
+      if @raw_pointer.start_with?("#")
+        Addressable::URI.unencode(@raw_pointer[1..-1])
+      else
+        @raw_pointer
+      end
+    end
+
+    private
+
+    def parse_token(token)
+      token.gsub("~0", "~").gsub("~1", "/")
+    end
+
+    def tokens
+      tokens = escaped_pointer[1..-1].split("/")
+
+      if @raw_pointer.end_with?("/")
+        tokens << ""
+      end
+
+      tokens.map do |token|
+        parse_token(token)
+      end
+    end
+  end
+end

data/lib/oas_parser_reborn/property.rb

@@ -0,0 +1,54 @@
+module OasParser
+  class Property < AbstractAttribute
+    raw_keys :description, :type, :format, :minimum, :maximum,
+             :example, :default, :items, :nullable
+
+    attr_accessor :owner, :schema, :raw
+    attr_writer :name
+
+    def initialize(owner, schema, name, raw)
+      super(name)
+      @owner = owner
+      @schema = schema
+      @raw = raw
+    end
+
+    def required
+      return false unless schema['required']
+      schema['required'].include? name
+    end
+
+    def nullable?
+      return true if raw['nullable']
+      return false unless schema['nullable']
+    end
+
+    def convert_property_schema_to_properties(schema)
+      if schema['allOf']
+        schema['properties'] = {}
+        schema['allOf'].each do |p|
+          schema['properties'].deep_merge!(p['properties'])
+        end
+        schema.delete('allOf')
+      end
+
+      if schema['oneOf']
+        schema['oneOf'].map do |subschema|
+          subschema['properties'] = convert_property_schema_to_properties(subschema)
+          subschema['subschema_property'] = true
+          subschema
+        end
+      elsif schema['subschema_property']
+        schema = schema['properties'] if schema['properties']
+        schema.map do |definition|
+          OasParser::Property.new(self, raw, definition.name, definition.raw)
+        end
+      else
+        schema = schema['properties'] if schema['properties']
+        schema.map do |key, definition|
+          OasParser::Property.new(self, raw, key, definition)
+        end
+      end
+    end
+  end
+end

data/lib/oas_parser_reborn/raw_accessor.rb

@@ -0,0 +1,26 @@
+module OasParser
+  module RawAccessor
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def method_missing(method_name, *args, &block)
+      super unless self.class.get_raw_keys.include? method_name
+      raw[method_name.to_s]
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      self.class.get_raw_keys.include?(method_name) || super
+    end
+
+    module ClassMethods
+      def raw_keys(*args)
+        @raw_keys = args
+      end
+
+      def get_raw_keys
+        @raw_keys || []
+      end
+    end
+  end
+end

data/lib/oas_parser_reborn/request_body.rb

@@ -0,0 +1,61 @@
+module OasParser
+  class RequestBody < Payload
+    include OasParser::RawAccessor
+    raw_keys :description, :required, :content
+
+    attr_accessor :endpoint, :raw
+
+    def initialize(endpoint, raw)
+      @endpoint = endpoint
+      @raw = raw
+    end
+
+    def properties_for_format(format)
+      s = schema(format)
+      s = handle_all_of(s)
+      s['properties'].map do |name, definition|
+        OasParser::Property.new(self, s, name, definition)
+      end
+    end
+
+    def split_properties_for_format(format)
+      split_schemas(format).map do |schema|
+        schema = handle_all_of(schema)
+        schema['properties'].map do |name, definition|
+          OasParser::Property.new(self, schema, name, definition)
+        end
+      end
+    end
+
+    def handle_all_of(schema)
+      newSchema = {}
+      if schema['allOf']
+        schema['allOf'].each do |p|
+          newSchema = deep_safe_merge(newSchema, p)
+          if newSchema['allOf']
+            newSchema = deep_safe_merge(newSchema, handle_all_of(newSchema))
+            newSchema.delete('allOf')
+          end
+        end
+      else
+        newSchema = schema
+      end
+
+      newSchema
+    end
+
+     def deep_safe_merge(source_hash, new_hash)
+       source_hash.merge(new_hash) do |key, old, new|
+         if new.respond_to?(:blank) && new.blank?
+           old
+         elsif (old.kind_of?(Hash) and new.kind_of?(Hash))
+           old.deep_merge(new)
+         elsif (old.kind_of?(Array) and new.kind_of?(Array))
+           old.concat(new).uniq
+         else
+           new
+         end
+       end
+     end
+  end
+end

data/lib/oas_parser_reborn/response.rb

@@ -0,0 +1,18 @@
+module OasParser
+  class Response < Payload
+    include OasParser::RawAccessor
+    raw_keys :description, :content
+
+    attr_accessor :endpoint, :code, :raw
+
+    def initialize(endpoint, code, raw)
+      @endpoint = endpoint
+      @code = code
+      @raw = raw
+    end
+
+    def success?
+      code.match?(/^2\d\d$/)
+    end
+  end
+end

data/lib/oas_parser_reborn/response_parser.rb

@@ -0,0 +1,227 @@
+module OasParser
+  class ResponseParser
+    attr_accessor :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def parse(mode = nil)
+      @mode = mode
+      route(@raw)
+    end
+
+    def json
+      parse('json').to_json
+    end
+
+    def xml(xml_options = {})
+      xml_options ||= {}
+      xml_options = default_xml_options.merge(xml_options)
+
+      raw_xml = parse('xml').to_xml(xml_options)
+
+      xml_document = Nokogiri::XML(raw_xml)
+
+      xml_document.xpath('//__attributes').each do |attributes|
+        attributes.children.each do |attribute|
+          next unless attribute.class == Nokogiri::XML::Element
+          attribute.parent.parent.css("> #{attribute.name}").remove
+          attribute.parent.parent[attribute.name] = attribute.content
+        end
+      end
+
+      xml_document.xpath('//__array_attributes').each do |attributes|
+        attributes.children.each do |attribute|
+          next unless attribute.class == Nokogiri::XML::Element
+
+          parameter = {}
+          parameter['example'] = attribute.css('example').text if attribute.css('example')
+          parameter['type'] = attribute.css('type').text if attribute.css('type')
+
+          attribute.parent.parent.parent[attribute.name] = parameter_value(parameter)
+        end
+        attributes.parent.remove
+      end
+
+      xml_document.xpath('//__text').each do |attribute|
+        value = attribute.children.last.content
+        attribute.parent.content = value
+      end
+
+      xml_document.xpath('//__attributes').each(&:remove)
+
+      xml_document.to_xml.each_line.reject { |x| x.strip == '' }.join
+    end
+
+    private
+
+    def default_xml_options
+      {
+        dasherize: false,
+        skip_types: true,
+      }
+    end
+
+    def route(root_object)
+      case root_object['type']
+      when 'object'
+        parse_object(root_object)
+      when 'array' then parse_array(root_object)
+      when 'string' then root_object['example']
+      when 'integer' then root_object['example']
+      when 'number' then root_object['example']
+      when nil
+        return nil if root_object['additionalProperties'] == false
+        return nil if root_object['properties'] == {}
+
+        if treat_as_object?(root_object)
+          # Handle objects with missing type
+          return parse_object(root_object.merge({ 'type' => 'object' }))
+        end
+
+        raise StandardError.new("Unhandled object #{root_object} with missing type")
+      else
+        raise StandardError.new("Don't know how to parse #{root_object['type']}")
+      end
+    end
+
+    def parse_object(object)
+      raise StandardError.new("Not a hash") unless object.class == Hash
+      raise StandardError.new("Not an object") unless treat_as_object?(object)
+
+      if object['allOf']
+        merged_object = { 'type' => 'object' }
+        object['allOf'].each { |o| merged_object.deep_merge!(o) }
+        return parameter_value(merged_object)
+      elsif object['properties']
+        o = {}
+        object['properties'].each do |key, value|
+          if @mode == 'xml'
+            if is_xml_attribute?(value)
+              o['__attributes'] ||= {}
+              o['__attributes'][key] = parameter_value(value)
+            end
+
+            if is_xml_text?(value)
+              o['__text'] = parameter_value(value)
+            end
+
+            if has_xml_name?(value)
+              key = xml_name(value)
+            end
+          end
+
+          o[key] = parameter_value(value)
+        end
+
+        return o
+      end
+
+      {}
+    end
+
+    def parse_array(object)
+      raise StandardError.new("Not an array") unless object['type'] == 'array'
+
+      attributes = {}
+
+      if object['properties']
+        if @mode == 'xml'
+          object['properties'].each do |key, value|
+            if is_xml_attribute?(value)
+              attributes[key] = value
+            end
+          end
+        end
+      end
+
+      if object['items'] && (object['items']['oneOf'] || object['items']['anyOf'])
+        key = object['items']['oneOf'] ? 'oneOf' : 'anyOf'
+        items = object['items'][key].map do |obj|
+          route(obj)
+        end
+
+        items.push({ '__array_attributes' => attributes }) if attributes.any? && @mode == 'xml'
+        return items
+      end
+
+      case object['items']['type']
+      when 'object'
+        if attributes.any? && @mode == 'xml'
+          [parse_object(object['items']), { '__array_attributes' => attributes }]
+        else
+          [parse_object(object['items'])]
+        end
+      else
+        if object['items']
+          # Handle objects with missing type
+          object['items']['type'] = 'object'
+          if @mode == 'xml'
+            [parse_object(object['items']), { '__array_attributes' => attributes }]
+          else
+            [parse_object(object['items'])]
+          end
+        else
+          raise StandardError.new("parse_array: Don't know how to parse object")
+        end
+      end
+    end
+
+    def parameter_value(parameter)
+      return parameter['example'] if parameter['example']
+      case (parameter['schema'] ? parameter['schema']['type'] : parameter['type'])
+      when 'integer' then return 1
+      when 'number' then return 1.0
+      when 'string' then return 'abc123'
+      when 'boolean' then return false
+      when 'object' then return parse_object(parameter)
+      when 'array' then return parse_array(parameter)
+      else
+        if treat_as_object?(parameter)
+          return parse_object(parameter)
+        end
+
+        if parameter['type']
+          raise StandardError.new("Can not resolve parameter type of #{parameter['type']}")
+        else
+          raise StandardError.new("Parameter #{parameter} is missing type.")
+        end
+      end
+    end
+
+
+    def treat_as_object?(object)
+      return true if object['type'] == 'object'
+      return true if object['allOf']
+      return true if object['oneOf']
+      return true if object['properties']
+      false
+    end
+
+    def has_xml_options?(object)
+      object['xml'].present?
+    end
+
+    def is_xml_attribute?(object)
+      return false unless has_xml_options?(object)
+      object['xml']['attribute'] || false
+    end
+
+    def is_xml_text?(object)
+      # See: https://github.com/OAI/OpenAPI-Specification/issues/630#issuecomment-350680346
+      return false unless has_xml_options?(object)
+      return true if object['xml']['text'] || false
+      object['xml']['x-text'] || false
+    end
+
+    def has_xml_name?(object)
+      return false unless has_xml_options?(object)
+      xml_name(object) || false
+    end
+
+    def xml_name(object)
+      object['xml']['name']
+    end
+  end
+end

data/lib/oas_parser_reborn/version.rb

@@ -0,0 +1,3 @@
+module OasParser
+  VERSION = '0.25.5'.freeze
+end

data/lib/oas_parser_reborn/webhook.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OasParser
+  class Webhook < Path
+    def name
+      path
+    end
+  end
+end

data/lib/oas_parser_reborn.rb

@@ -0,0 +1,22 @@
+require 'json'
+require 'uri'
+require 'yaml'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/conversions'
+require 'nokogiri'
+
+require 'addressable/uri'
+require 'deep_merge'
+
+require_relative 'oas_parser_reborn/path.rb'
+require_relative 'oas_parser_reborn/payload.rb'
+require_relative 'oas_parser_reborn/raw_accessor.rb'
+require_relative 'oas_parser_reborn/abstract_attribute.rb'
+
+Dir["#{File.dirname(__FILE__)}/oas_parser_reborn/**/*.rb"].each do |file|
+  require file
+end
+
+module OasParser
+  # Your code goes here...
+end