openapi_parser 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be5f0f122cae14b6ae5d17dbc537b63aba01f0f26c677b400c77b5befc3fe43c
-  data.tar.gz: bbdd0f1318dfb9465f7f545545198ce2e3189c2baf8823b85e7c0eab6ed30bc5
+  metadata.gz: ee6c1b21577fd0129c63e8b80fab4f929cccd3220d7888af95bd38f19665e994
+  data.tar.gz: 1107cd65d31bed5e98f2aad6a5629e87b0bd031c1c23e81e2357f4e2cf6dbad2
 SHA512:
-  metadata.gz: c9bc537c05becea794bbe244bcaa8afbc4471c9d64eb142139fbd46adf7efe37d216a0f2890d9d58358d1ba1f371f1fc6a7e704f164b0dc8dd53e41006091206
-  data.tar.gz: 686e47b13639f61f026c75af5eef0a96a1ab7948a4eea592ccaed0f946e5e187b89641d91038142739396cf9a79d1360b1f45e67d996fa07911380c7b532373f
+  metadata.gz: 349707da91353ab6a915b192656731d098c8fc45944ac30f2f25569c9ad1379b72909ef1cf305c950a9afc2c3477414d2c457312d9f88a5030fdf04ea30d26b9
+  data.tar.gz: 06e38d3763f60731baeb3cf650978ad5bcd6ced36701e50122f31df7a2a9855c22e77e75867dec3f63d201878bad10c51d00bf38c560ab35ca3725d502d6807a

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_gem:
+  fincop:
+    - 'config/rails.yml'
+    - 'config/rspec.yml'
+    - 'config/rubocop.yml'
+    # If you are using Rails 4, activate this cop.
+    # - 'config/disabled_for_rails_4.yml'
+
+AllCops:
+  TargetRubyVersion: 2.5

data/Gemfile

@@ -1,6 +1,6 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in openapi_parser.gemspec
 gemspec

data/README.md

@@ -1,4 +1,4 @@
-# OpenapiParser
+# OpenAPI Parser
 
 Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/openapi_parser`. To experiment with that code, run `bin/console` for an interactive prompt.
 
@@ -40,4 +40,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the OpenapiParser project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/openapi_parser/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the OpenAPIParser project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/openapi_parser/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,5 +1,5 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 

data/lib/openapi_parser.rb

@@ -1,5 +1,10 @@
-require "openapi_parser/version"
+require 'openapi_parser/version'
+require 'openapi_parser/concern'
+require 'openapi_parser/schemas'
+require 'openapi_parser/path_item_finder'
+require 'openapi_parser/request_operation'
+require 'openapi_parser/schema_validator'
 
-module OpenapiParser
+module OpenAPIParser
   # Your code goes here...
 end

data/lib/openapi_parser/concern.rb

@@ -0,0 +1,2 @@
+require_relative 'concerns/parseable'
+require_relative 'concerns/findable'

data/lib/openapi_parser/concerns/findable.rb

@@ -0,0 +1,22 @@
+module OpenAPIParser::Findable
+  # @param [String] reference
+  # @return [OpenAPIParser::Findable]
+  def find_object(reference)
+    return nil unless reference.start_with?(object_reference)
+    return self if object_reference == reference
+
+    @find_object_cache = {} unless defined? @find_object_cache
+    if (obj = @find_object_cache[reference])
+      return obj
+    end
+
+    _openapi_all_child_objects.each do |c|
+      if (obj = c.find_object(reference))
+        @find_object_cache[reference] = obj
+        return obj
+      end
+    end
+
+    nil
+  end
+end

data/lib/openapi_parser/concerns/parseable.rb

@@ -0,0 +1,232 @@
+module OpenAPIParser::Parseable
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    attr_reader :_openapi_attr_values,
+                :_openapi_attr_list_objects,
+                :_openapi_attr_objects,
+                :_openapi_attr_hash_objects,
+                :_openapi_attr_hash_body_objects
+
+    # no option support
+    def openapi_attr_values(*names)
+      names.each { |name| openapi_attr_value(name) }
+    end
+
+    def openapi_attr_value(name, options = {})
+      @_openapi_attr_values = {} unless defined?(@_openapi_attr_values)
+
+      attr_reader name
+      @_openapi_attr_values[name] =  options
+    end
+
+    # no option support
+    def openapi_attr_objects(*names, klass)
+      names.each { |name| openapi_attr_object(name, klass) }
+    end
+
+    def openapi_attr_object(name, klass, options = {})
+      @_openapi_attr_objects = {} unless defined?(@_openapi_attr_objects )
+
+      attr_reader name
+      @_openapi_attr_objects[name] = options.merge(klass: klass)
+    end
+
+    def openapi_attr_list_object(name, klass, options = {})
+      @_openapi_attr_list_objects = {} unless defined?(@_openapi_attr_list_objects)
+
+      attr_reader name
+      @_openapi_attr_list_objects[name] = options.merge(klass: klass)
+    end
+
+    def openapi_attr_hash_object(name, klass, options = {})
+      @_openapi_attr_hash_objects = {} unless defined?(@_openapi_attr_hash_objects)
+
+      attr_reader name
+      @_openapi_attr_hash_objects[name] = options.merge(klass: klass)
+    end
+
+    def openapi_attr_hash_body_objects(name, klass, options = {})
+      @_openapi_attr_hash_body_objects = {} unless defined?(@_openapi_attr_hash_body_objects)
+
+      options[:reject_keys] = options[:reject_keys] ? options[:reject_keys].map(&:to_s) : []
+
+      attr_reader name
+      @_openapi_attr_hash_body_objects[name] = options.merge(klass: klass)
+    end
+  end
+
+
+  def _openapi_all_child_objects
+    @_openapi_all_child_objects ||= []
+  end
+
+  def _add_child_object(object)
+    return unless object.is_a?(OpenAPIParser::Parseable)
+    _openapi_all_child_objects << object
+  end
+
+
+  def load_data
+    create_attr_values(self.class._openapi_attr_values)
+
+    create_attr_objects(self.class._openapi_attr_objects)
+    create_attr_list_objects(self.class._openapi_attr_list_objects)
+    create_attr_hash_objects(self.class._openapi_attr_hash_objects)
+    create_attr_hash_body_objects(self.class._openapi_attr_hash_body_objects)
+  end
+
+  def create_attr_list_objects(settings)
+    return unless settings
+
+    settings.each do |variable_name, options|
+      ref_name_base = options[:schema_key] ? options[:schema_key] : variable_name
+      klass = options[:klass]
+      allow_reference = options[:reference] || false
+      allow_data_type = options[:allow_data_type]
+      
+      create_attr_list_object(variable_name, raw_schema[ref_name_base.to_s], ref_name_base, klass, allow_reference, allow_data_type)
+    end
+  end
+
+  def create_attr_hash_objects(settings)
+    return unless settings
+
+    settings.each do |variable_name, options|
+      ref_name_base = options[:schema_key] ? options[:schema_key] : variable_name
+      klass = options[:klass]
+      allow_reference = options[:reference] || false
+      allow_data_type = options[:allow_data_type]
+      
+      create_attr_hash_object(variable_name, raw_schema[ref_name_base .to_s], ref_name_base, klass, allow_reference, allow_data_type)
+    end
+  end
+
+  def create_attr_objects(values)
+    return unless values
+
+    values.each do |name, options|
+      key = options[:schema_key] ? options[:schema_key] : name
+      klass = options[:klass]
+      allow_reference = options[:reference] || false
+      allow_data_type = options[:allow_data_type]
+      
+      obj = create_attr_object(name, key, raw_schema[key.to_s], klass, allow_reference, allow_data_type)
+      _add_child_object(obj)
+    end
+  end
+
+  def create_attr_hash_body_objects(values)
+    return unless values
+
+    values.each do |name, options|
+      klass = options[:klass]
+      allow_reference = options[:reference] || false
+      allow_data_type = options[:allow_data_type]
+      reject_keys = options[:reject_keys]
+
+      create_hash_body_objects(name, raw_schema, klass, allow_reference, allow_data_type, reject_keys)
+    end
+  end
+
+  def create_attr_values(values)
+    return unless values
+
+    values.each do |variable_name, options|
+      key = options[:schema_key] ? options[:schema_key] : variable_name
+
+      create_variable(variable_name, raw_schema[key.to_s])
+    end
+  end
+
+
+  # for responses and paths object
+  def create_hash_body_objects(name, schema, klass, allow_reference, allow_data_type, reject_keys)
+    unless schema
+      create_variable(name, nil)
+      return
+    end
+
+    objects = schema.reject{|k, _| reject_keys.include?(k)}.map do |name, child_schema|
+      [
+          name.to_s, # support string key only in OpenAPI3
+          build_openapi_object(escape_reference(name), child_schema, klass, allow_reference, allow_data_type)
+      ]
+    end.to_h
+
+    create_variable(name, objects)
+    objects.values.each { |o| _add_child_object(o) }
+  end
+
+  # @return [OpenAPIParser::Schemas::Base]
+  def create_attr_object(variable_name, ref_name, schema, klass, allow_reference, allow_data_type)
+    data = build_openapi_object(ref_name, schema, klass, allow_reference, allow_data_type)
+    create_variable(variable_name, data)
+    data
+  end
+
+  def create_attr_hash_object(variable_name, hash_schema, ref_name_base, klass, allow_reference, allow_data_type)
+    data = if hash_schema
+             hash_schema.map { |key, s| [key, build_openapi_object([ref_name_base, key], s, klass, allow_reference, allow_data_type) ]}.to_h
+           else
+             nil
+           end
+
+    create_variable(variable_name, data)
+    data.values.each { |obj| _add_child_object(obj) } if data
+  end
+
+  def create_attr_list_object(variable_name, array_schema, ref_name_base, klass, allow_reference, allow_data_type)
+    data = if array_schema
+             array_schema.map.with_index { |s, idx| build_openapi_object([ref_name_base, idx], s, klass, allow_reference, allow_data_type) }
+           else
+             nil
+           end
+
+    create_variable(variable_name, data)
+    data.each { |obj| _add_child_object(obj) } if data
+  end
+
+
+  # create instance variable @variable_name using data
+  # @param [String] variable_name
+  # @param [Object] data
+  def create_variable(variable_name, data)
+    instance_variable_set("@#{variable_name}", data)
+  end
+
+  # return nil, klass, Reference
+  def build_openapi_object(ref_names, schema, klass, allow_reference, allow_data_type)
+    return nil unless schema
+
+    if allow_data_type && !check_object_schema?(schema)
+      schema
+    elsif allow_reference && check_reference_schema?(schema)
+      OpenAPIParser::Schemas::Reference.new(build_object_reference(ref_names), self, self.root, schema)
+    else
+      klass.new(build_object_reference(ref_names), self, self.root, schema)
+    end
+  end
+
+  # @return Boolean
+  def check_reference_schema?(check_schema)
+    check_object_schema?(check_schema) && !check_schema['$ref'].nil?
+  end
+
+  def check_object_schema?(check_schema)
+    check_schema.is_a?(Hash)
+  end
+
+  def escape_reference(str)
+    str.to_s.gsub('/', '~1')
+  end
+
+  # @return [String]
+  def build_object_reference(names)
+    names = [names] unless names.is_a?(Array)
+    ref = names.map{ |n| escape_reference(n)}.join('/')
+
+    "#{object_reference}/#{ref}"
+  end
+end

data/lib/openapi_parser/path_item_finder.rb

@@ -0,0 +1,93 @@
+class OpenAPIParser::PathItemFinder
+  # @param [OpenAPIParser::Schemas::Paths] paths
+  def initialize(paths)
+    @root = PathNode.new('/')
+    @paths = paths
+
+    @paths.path.each { |path, _path_item_object| @root.register_path_node(path.split("/"), path) }
+  end
+
+  # @param [String, Symbol] http_method like (get, post .... allow symbol)
+  # @param [String] request_path
+  # @return [OpenAPIParser::Schemas::Paths]
+  def operation_object(http_method, request_path)
+    if (path_item_object = @paths.path[request_path])
+      if (op = path_item_object.operation(http_method))
+        return op, {} # find no path_params path
+      end
+    end
+
+    # check with path_params
+    parse_request_path(http_method, request_path)
+  end
+
+  class PathNode
+    attr_accessor :full_path, :name
+
+    def initialize(name)
+      @name = name
+      @children = Hash.new {|h, k| h[k] = PathNode.new(k) }
+      @path_template_node = nil # we can't initialize because recursive initialize...
+      @full_path = nil
+    end
+
+    def register_path_node(splited_path, full_path)
+      if splited_path.empty?
+        @full_path = full_path
+        return
+      end
+
+      path_name = splited_path.shift
+
+      child = path_template?(path_name) ? path_template_node(path_name) : children[path_name]
+      child.register_path_node(splited_path, full_path)
+    end
+
+    # @return [String, nil] and Hash
+    def find_full_path(splited_path)
+      return [@full_path, {}] if splited_path.empty?
+
+      path_name = splited_path.shift
+
+      # when ambiguous matching like this
+      # /{entity}/me
+      # /books/{id}
+      # OpenAPI3 depend on the tooling so we use concrete one (using /books/)
+
+      path_params = {}
+      if children.key?(path_name)
+        child = children[path_name]
+      else
+        child = path_template_node(path_name)
+        path_params = {"#{child.name}" =>path_name}
+      end
+
+      ret, other_path_params = child.find_full_path(splited_path)
+      [ret, path_params.merge(other_path_params)]
+    end
+
+    private
+
+    attr_reader :children
+
+    def path_template_node(path_name)
+      @path_template_node ||= PathNode.new(path_name[1..(path_name.length-2)]) # delete {} from {name}
+    end
+
+    def path_template?(path_name)
+      path_name.start_with?('{') && path_name.end_with?('}')
+    end
+  end
+
+  private
+
+  def parse_request_path(http_method, request_path)
+    original_path, path_params = @root.find_full_path(request_path.split("/"))
+    return nil, path_params unless original_path
+
+    path_item_object = @paths.path[original_path]
+    obj = path_item_object.operation(http_method.to_s)
+
+    [obj, path_params]
+  end
+end

data/lib/openapi_parser/request_operation.rb

@@ -0,0 +1,30 @@
+# binding request data and operation object
+
+class OpenAPIParser::RequestOperation
+  class << self
+    # @param [OpenAPIParser::PathItemFinder] path_item_finder
+    def create(http_method, request_path, path_item_finder)
+      endpoint, path_params = path_item_finder.operation_object(http_method, request_path)
+
+      return nil unless endpoint
+
+      self.new(endpoint, path_params)
+    end
+  end
+
+  # @!attribute [r] operation_object
+  #   @return [OpenAPIParser::Schemas::Operation, nil]
+  # @!attribute [r] path_params
+  #   @return [Hash{String => String}]
+  attr_reader :operation_object, :path_params
+
+  def initialize(operation_object, path_params)
+    @operation_object = operation_object
+    @path_params = path_params || {}
+  end
+
+  # support application/json only :(
+  def validate_request_body(content_type, params)
+    operation_object&.validate_request_body(content_type, params)
+  end
+end

data/lib/openapi_parser/schema_validator.rb

@@ -0,0 +1,172 @@
+class OpenAPIParser::SchemaValidator
+  class ValidateError < StandardError
+    def initialize(data, type, reference)
+      @data = data
+      @type = type
+      @reference = reference
+    end
+
+    def message
+      "#{@data} class is #{@data.class} but it's not valid #{@type} in #{@reference}"
+    end
+  end
+
+  class NotNullError < StandardError
+    def initialize(reference)
+      @reference = reference
+    end
+
+    def message
+      "#{@reference} don't allow null"
+    end
+  end
+
+  class NotExistRequiredKey < StandardError
+    def initialize(keys, reference)
+      @keys = keys
+      @reference = reference
+    end
+
+    def message
+      "required parameters #{@keys.join(",")} not exist in #{@reference}"
+    end
+  end
+
+  class NotAnyOf < StandardError
+    def initialize(value, reference)
+      @value = value
+      @reference = reference
+    end
+
+    def message
+      "#{@value} isn't any of in #{@reference}"
+    end
+  end
+
+  class NotEnumInclude < StandardError
+    def initialize(value, reference)
+      @value = value
+      @reference = reference
+    end
+
+    def message
+      "#{@value} isn't include enum in #{@reference}"
+    end
+  end
+
+  class << self
+    # @param [Hash] value
+    # @param [OpenAPIParser::Schemas::Schema]
+    def validate(value, schema)
+      new(value, schema).validate_data
+    end
+  end
+
+  # @param [Hash] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def initialize(value, schema)
+    @value = value
+    @schema = schema
+  end
+
+  def validate_data
+    err = validate_schema(@value, @schema)
+    raise err if err
+    nil
+  end
+
+  private
+
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def validate_schema(value, schema)
+    return unless schema
+    return validate_any_of(value, schema) if schema.any_of
+
+    if value.nil?
+      return if schema.nullable
+      return NotNullError.new(schema.object_reference)
+    end
+
+    case schema.type
+    when "string"
+      return validate_string(value, schema) if value.is_a?(String)
+    when "integer"
+      return validate_integer(value, schema) if value.is_a?(Integer)
+    when "boolean"
+      return if value.is_a?(TrueClass)
+      return if value.is_a?(FalseClass)
+    when "number"
+      return validate_integer(value, schema) if value.is_a?(Integer)
+      return validate_number(value, schema) if value.is_a?(Numeric)
+    when "object"
+      return validate_object(value, schema) if value.is_a?(Hash)
+    when "array"
+      return validate_array(value, schema) if value.is_a?(Array)
+    else
+      # TODO: unknown type support
+    end
+
+    ValidateError.new(value, schema.type, schema.object_reference)
+  end
+
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def validate_any_of(value, schema)
+    # in all schema return error (=true) not any of data
+    schema.any_of.all? { |s| validate_schema(value, s) } ? NotAnyOf.new(value, schema.object_reference) : nil
+  end
+
+  def validate_string(value, schema)
+    check_enum_include(value, schema)
+  end
+
+  def validate_integer(value, schema)
+    check_enum_include(value, schema)
+  end
+
+  def validate_number(value, schema)
+    check_enum_include(value, schema)
+  end
+
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def check_enum_include(value, schema)
+    return unless schema.enum
+    return if schema.enum.include?(value)
+
+    NotEnumInclude.new(value, schema.object_reference)
+  end
+
+  # @param [Hash] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def validate_object(value, schema)
+    return unless schema.properties
+    required_set = schema.required ? schema.required.to_set : Set.new
+
+    value.each do |name, v|
+      s = schema.properties[name]
+      err = validate_schema(v, s)
+      return err if err
+
+      required_set.delete(name)
+    end
+
+    return NotExistRequiredKey.new(required_set.to_a, schema.object_reference) unless required_set.empty?
+    nil
+  end
+
+  # @param [Array] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def validate_array(value, schema)
+    # array type have an schema in items property
+    items_schema = schema.items
+
+    value.each do |v|
+      err = validate_schema(v, items_schema)
+      return err if err
+    end
+
+    nil
+  end
+end

data/lib/openapi_parser/schemas.rb

@@ -0,0 +1,15 @@
+require_relative 'schemas/classes'
+
+require_relative 'schemas/base'
+require_relative 'schemas/openapi'
+require_relative 'schemas/paths'
+require_relative 'schemas/path_item'
+require_relative 'schemas/operation'
+require_relative 'schemas/parameter'
+require_relative 'schemas/reference'
+require_relative 'schemas/request_body'
+require_relative 'schemas/response'
+require_relative 'schemas/responses'
+require_relative 'schemas/components'
+require_relative 'schemas/media_type'
+require_relative 'schemas/schema'

data/lib/openapi_parser/schemas/base.rb

@@ -0,0 +1,28 @@
+module OpenAPIParser::Schemas
+  class Base
+    include OpenAPIParser::Parseable
+    include OpenAPIParser::Findable
+
+    attr_reader :parent, :raw_schema, :object_reference, :root
+
+    # @param [OpenAPIParser::Schemas::Base]
+    def initialize(object_reference, parent, root, raw_schema)
+      @raw_schema = raw_schema
+      @parent = parent
+      @root = root
+      @object_reference = object_reference
+
+      load_data
+      after_init
+    end
+
+    # override
+    def after_init
+
+    end
+
+    def inspect
+      @object_reference
+    end
+  end
+end

data/lib/openapi_parser/schemas/classes.rb

@@ -0,0 +1,17 @@
+# We want to use class name for DSL in class definition so we should define first...
+
+module OpenAPIParser::Schemas
+  class Base; end
+  class OpenAPI < Base; end
+  class Operation < Base; end
+  class Parameter < Base; end
+  class PathItem < Base; end
+  class Paths < Base; end
+  class Reference < Base; end
+  class RequestBody < Base; end
+  class Responses < Base; end
+  class Response < Base; end
+  class MediaType < Base; end
+  class Schema < Base; end
+  class Components < Base; end
+end

data/lib/openapi_parser/schemas/components.rb

@@ -0,0 +1,25 @@
+# TODO: examples
+# TODO: headers
+# TODO: securitySchemes
+# TODO: links
+# TODO: callbacks
+
+module OpenAPIParser::Schemas
+  class Components < Base
+    # @!attribute [r] parameters
+    #   @return [Hash{String => Parameter}, nil]
+    openapi_attr_hash_object :parameters, Parameter, reference: true
+
+    # @!attribute [r] parameters
+    #   @return [Hash{String => Parameter}, nil]
+    openapi_attr_hash_object :schemas, Schema, reference: true
+
+    # @!attribute [r] responses
+    #   @return [Hash{String => Response}, nil]
+    openapi_attr_hash_object :responses, Response, reference: true
+
+    # @!attribute [r] request_bodies
+    #   @return [Hash{String => RequestBody}, nil]
+    openapi_attr_hash_object :request_bodies, RequestBody, reference: true, schema_key: :requestBodies
+  end
+end

data/lib/openapi_parser/schemas/media_type.rb

@@ -0,0 +1,16 @@
+# TODO: example
+# TODO: examples
+# TODO: encoding
+
+module OpenAPIParser::Schemas
+  class MediaType < Base
+    # @!attribute [r] schema
+    #   @return [Schema, nil]
+    openapi_attr_object :schema, Schema, reference: true
+
+    # @param [Hash] params
+    def validate_parameter(params)
+      OpenAPIParser::SchemaValidator.validate(params, schema)
+    end
+  end
+end

data/lib/openapi_parser/schemas/openapi.rb

@@ -0,0 +1,31 @@
+# TODO: info object
+# TODO: servers object
+# TODO: tags object
+# TODO: externalDocs object
+
+module OpenAPIParser::Schemas
+  class OpenAPI < Base
+    def initialize(raw_schema)
+      super('#', nil, self, raw_schema)
+      @find_object_cache = {}
+      @path_item_finder = OpenAPIParser::PathItemFinder.new(paths)
+    end
+
+    # @!attribute [r] openapi
+    #   @return [String, nil]
+    openapi_attr_values :openapi
+
+    # @!attribute [r] paths
+    #   @return [Paths, nil]
+    openapi_attr_object :paths, Paths, reference: false
+
+    # @!attribute [r] components
+    #   @return [Components, nil]
+    openapi_attr_object :components, Components, reference: false
+
+    # @return [OpenAPIParser::RequestOperation]
+    def request_operation(http_method, request_path)
+      OpenAPIParser::RequestOperation.create(http_method, request_path, @path_item_finder)
+    end
+  end
+end

data/lib/openapi_parser/schemas/operation.rb

@@ -0,0 +1,24 @@
+# TODO: externalDocs
+# TODO: callbacks
+# TODO: security
+# TODO: servers
+
+module OpenAPIParser::Schemas
+  class Operation < Base
+    openapi_attr_values :tags, :summary, :description, :deprecated
+
+    openapi_attr_value :operation_id, schema_key: :operationId
+
+    openapi_attr_list_object :parameters, Parameter, reference: true
+
+    # @!attribute [r] request_body
+    #   @return [OpenAPIParser::Schemas::RequestBody, nil]
+    openapi_attr_object :request_body, RequestBody, reference: true, schema_key: :requestBody
+
+    openapi_attr_object :responses, Responses, reference: false
+
+    def validate_request_body(content_type, params)
+      request_body&.validate_request_body(content_type, params)
+    end
+  end
+end

data/lib/openapi_parser/schemas/parameter.rb

@@ -0,0 +1,12 @@
+# TODO: support examples
+
+module OpenAPIParser::Schemas
+  class Parameter < Base
+    openapi_attr_values :name, :in, :description, :required, :deprecated, :style, :explode, :example
+
+    openapi_attr_value :allow_empty_value, schema_key: :allowEmptyValue
+    openapi_attr_value :allow_reserved, schema_key: :allowReserved
+
+    openapi_attr_object :schema, Schema, reference: true
+  end
+end

data/lib/openapi_parser/schemas/path_item.rb

@@ -0,0 +1,16 @@
+# TODO: support servers
+# TODO: support reference
+
+module OpenAPIParser::Schemas
+  class PathItem < Base
+    openapi_attr_values :summary, :description
+
+    openapi_attr_objects :get, :put, :post, :delete, :options, :head, :patch, :trace, Operation
+    openapi_attr_list_object :parameters, Parameter, reference: true
+
+    # @return [Operation]
+    def operation(method)
+      send(method)
+    end
+  end
+end

data/lib/openapi_parser/schemas/paths.rb

@@ -0,0 +1,7 @@
+module OpenAPIParser::Schemas
+  class Paths < Base
+    # @!attribute [r] path
+    #   @return [Hash{String => PathItem, Reference}, nil]
+    openapi_attr_hash_body_objects 'path', PathItem, allow_reference: false, allow_data_type: false
+  end
+end

data/lib/openapi_parser/schemas/reference.rb

@@ -0,0 +1,5 @@
+module OpenAPIParser::Schemas
+  class Reference < Base
+    openapi_attr_value :ref, schema_key: '$ref'
+  end
+end

data/lib/openapi_parser/schemas/request_body.rb

@@ -0,0 +1,20 @@
+# TODO: support extended property
+
+module OpenAPIParser::Schemas
+  class RequestBody < Base
+    openapi_attr_values :description, :required
+
+    # @!attribute [r] content
+    #   @return [Hash{String => MediaType}, nil]
+    openapi_attr_hash_object :content, MediaType, reference: false
+
+    def validate_request_body(_content_type, params)
+      # TODO: now support application/json only :(
+
+      media_type = content['application/json']
+      return nil unless media_type
+
+      media_type.validate_parameter(params)
+    end
+  end
+end

data/lib/openapi_parser/schemas/response.rb

@@ -0,0 +1,12 @@
+# TODO: headers
+# TODO: links
+
+module OpenAPIParser::Schemas
+  class Response < Base
+    openapi_attr_values :description
+
+    # @!attribute [r] content
+    #   @return [Hash{String => MediaType}, nil]
+    openapi_attr_hash_object :content, MediaType, reference: false
+  end
+end

data/lib/openapi_parser/schemas/responses.rb

@@ -0,0 +1,13 @@
+# TODO: support extended property
+
+module OpenAPIParser::Schemas
+  class Responses < Base
+    # @!attribute [r] default
+    #   @return [Response, Reference, nil]
+    openapi_attr_object :default, Response, reference: true
+
+    # @!attribute [r] response
+    #   @return [Hash{String => Response, Reference}, nil]
+    openapi_attr_hash_body_objects 'response', Response, reject_keys: [:default], allow_reference: true, allow_data_type: false
+  end
+end

data/lib/openapi_parser/schemas/schema.rb

@@ -0,0 +1,108 @@
+# TODO: support 'not' because I need check reference...
+# TODO: support 'discriminator', 'xml', 'externalDocs'
+# TODO: support extended property
+
+module OpenAPIParser::Schemas
+  class Schema < Base
+    # @!attribute [r] title
+    #   @return [String, nil]
+    # @!attribute [r] pattern
+    #   @return [String, nil] regexp
+    # @!attribute [r] pattern
+    #   @return [String, nil] regexp
+    # @!attribute [r] description
+    #   @return [String, nil]
+    # @!attribute [r] format
+    #   @return [String, nil]
+    # @!attribute [r] type
+    #   @return [String, nil] multiple types doesn't supported in OpenAPI3
+
+    # @!attribute [r] maximum
+    #   @return [Float, nil]
+    # @!attribute [r] multipleOf
+    #   @return [Float, nil]
+
+    # @!attribute [r] maxLength
+    #   @return [Integer, nil]
+    # @!attribute [r] minLength
+    #   @return [Integer, nil]
+    # @!attribute [r] maxItems
+    #   @return [Integer, nil]
+    # @!attribute [r] minItems
+    #   @return [Integer, nil]
+    # @!attribute [r] maxProperties
+    #   @return [Integer, nil]
+    # @!attribute [r] minProperties
+    #   @return [Integer, nil]
+
+    # @!attribute [r] exclusiveMaximum
+    #   @return [Boolean, nil]
+    # @!attribute [r] exclusiveMinimum
+    #   @return [Boolean, nil]
+    # @!attribute [r] uniqueItems
+    #   @return [Boolean, nil]
+    # @!attribute [r] nullable
+    #   @return [Boolean, nil]
+    # @!attribute [r] deprecated
+    #   @return [Boolean, nil]
+
+    # @!attribute [r] required
+    #   @return [Array<String>, nil] at least one item included
+
+    # @!attribute [r] enum
+    #   @return [Array, nil] any type array
+
+    # @!attribute [r] default
+    #   @return [Object, nil]
+
+    # @!attribute [r] example
+    #   @return [Object, nil]
+
+    openapi_attr_values :title, :multipleOf,
+                        :maximum, :exclusiveMaximum, :minimum, :exclusiveMinimum,
+                        :maxLength, :minLength,
+                        :pattern,
+                        :maxItems, :minItems, :uniqueItems,
+                        :maxProperties, :minProperties,
+                        :required, :enum,
+                        :description,
+                        :format,
+                        :default,
+                        :type,
+                        :nullable,
+                        :example,
+                        :deprecated
+
+    # @!attribute [r] read_only
+    #   @return [Boolean, nil]
+    openapi_attr_value :read_only, schema_key: :readOnly
+
+    # @!attribute [r] write_only
+    #   @return [Boolean, nil]
+    openapi_attr_value :write_only, schema_key: :writeOnly
+
+    # @!attribute [r] all_of
+    #   @return [Array<Schema, Reference>, nil]
+    openapi_attr_list_object :all_of, Schema, reference: true, schema_key: :allOf
+
+    # @!attribute [r] one_of
+    #   @return [Array<Schema, Reference>, nil]
+    openapi_attr_list_object :one_of, Schema, reference: true, schema_key: :oneOf
+
+    # @!attribute [r] any_of
+    #   @return [Array<Schema, Reference>, nil]
+    openapi_attr_list_object :any_of, Schema, reference: true, schema_key: :anyOf
+
+    # @!attribute [r] items
+    #   @return [Schema, nil]
+    openapi_attr_object :items, Schema, reference: true
+
+    # @!attribute [r] properties
+    #   @return [Hash{String => Schema}, nil]
+    openapi_attr_hash_object :properties, Schema, reference: true
+
+    # @!attribute [r] additional_properties
+    #   @return [Boolean, Schema, Reference, nil]
+    openapi_attr_object :additional_properties, Schema, reference: true, allow_data_type: true, schema_key: :additionalProperties
+  end
+end

data/lib/openapi_parser/version.rb

@@ -1,3 +1,3 @@
-module OpenapiParser
-  VERSION = "0.1.0"
+module OpenAPIParser
+  VERSION = '0.1.1'.freeze
 end

data/openapi_parser.gemspec

@@ -1,29 +1,31 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "openapi_parser/version"
+require 'openapi_parser/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "openapi_parser"
-  spec.version       = OpenapiParser::VERSION
-  spec.authors       = ["ota42y"]
-  spec.email         = ["ota42y@gmail.com"]
+  spec.name          = 'openapi_parser'
+  spec.version       = OpenAPIParser::VERSION
+  spec.authors       = ['ota42y']
+  spec.email         = ['ota42y@gmail.com']
 
-  spec.summary       = %q{OpenAPI3 parser}
-  spec.description   = %q{parser for OpenAPI 3.0 or later}
-  spec.homepage      = "https://ota42y.com"
-  spec.license       = "MIT"
+  spec.summary       = 'OpenAPI3 parser'
+  spec.description   = 'parser for OpenAPI 3.0 or later'
+  spec.homepage      = 'https://github.com/ota42y/openapi_parser'
+  spec.license       = 'MIT'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'fincop'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - ota42y
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-24 00:00:00.000000000 Z
+date: 2018-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: fincop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: parser for OpenAPI 3.0 or later
 email:
 - ota42y@gmail.com
@@ -61,19 +103,40 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - lib/openapi_parser.rb
+- lib/openapi_parser/concern.rb
+- lib/openapi_parser/concerns/findable.rb
+- lib/openapi_parser/concerns/parseable.rb
+- lib/openapi_parser/path_item_finder.rb
+- lib/openapi_parser/request_operation.rb
+- lib/openapi_parser/schema_validator.rb
+- lib/openapi_parser/schemas.rb
+- lib/openapi_parser/schemas/base.rb
+- lib/openapi_parser/schemas/classes.rb
+- lib/openapi_parser/schemas/components.rb
+- lib/openapi_parser/schemas/media_type.rb
+- lib/openapi_parser/schemas/openapi.rb
+- lib/openapi_parser/schemas/operation.rb
+- lib/openapi_parser/schemas/parameter.rb
+- lib/openapi_parser/schemas/path_item.rb
+- lib/openapi_parser/schemas/paths.rb
+- lib/openapi_parser/schemas/reference.rb
+- lib/openapi_parser/schemas/request_body.rb
+- lib/openapi_parser/schemas/response.rb
+- lib/openapi_parser/schemas/responses.rb
+- lib/openapi_parser/schemas/schema.rb
 - lib/openapi_parser/version.rb
 - openapi_parser.gemspec
-homepage: https://ota42y.com
+homepage: https://github.com/ota42y/openapi_parser
 licenses:
 - MIT
 metadata: {}

data/Gemfile.lock

@@ -1,35 +0,0 @@
-PATH
-  remote: .
-  specs:
-    openapi_parser (0.1.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.3)
-    rake (10.5.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.16)
-  openapi_parser!
-  rake (~> 10.0)
-  rspec (~> 3.0)
-
-BUNDLED WITH
-   1.16.6