openapi_first 1.0.0.beta5 → 1.0.0.beta6

data/benchmarks/post.lua

@@ -1,3 +0,0 @@
-wrk.method = "POST"
-wrk.body   = "{\"say\":\"hi!\"}"
-wrk.headers["Content-Type"] = "application/json"

data/bin/console

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'openapi_first'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/examples/README.md

@@ -1,13 +0,0 @@
-# Example
-
-How to run the example:
-
-```bash
-cd examples
-bundle install
-bundle exec rackup
-```
-
-open http://localhost:9292/
-
-🎉

data/examples/app.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'openapi_first'
-require 'rack'
-
-# This example is a bit contrived, but it shows what you could do with the middlewares
-
-App = Rack::Builder.new do
-  use OpenapiFirst::RequestValidation, raise_error: true, spec: File.expand_path('./openapi.yaml', __dir__)
-  use OpenapiFirst::ResponseValidation
-
-  handlers = {
-    'things#index' => ->(_env) { [200, { 'Content-Type' => 'application/json' }, ['{"hello": "world"}']] }
-  }
-  not_found = ->(_env) { [404, {}, []] }
-
-  run ->(env) { handlers.fetch(env[OpenapiFirst::OPERATION].operation_id, not_found).call(env) }
-end

data/examples/config.ru

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('../lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require_relative 'app'
-run App

data/examples/openapi.yaml

@@ -1,29 +0,0 @@
-openapi: 3.0.0
-info:
-  title: "API"
-  version: "1.0.0"
-  contact:
-    name: Contact Name
-    email: contact@example.com
-    url: https://example.com/
-tags:
-  - name: Metadata
-    description: Metadata related requests
-paths:
-  /:
-    get:
-      operationId: things#index
-      summary: Get metadata from the root of the API
-      tags: ["Metadata"]
-      responses:
-        "200":
-          description: OK
-          content:
-            application/json:
-              schema:
-                type: object
-                required: [hello]
-                properties:
-                  hello:
-                    type: string
-

data/lib/openapi_first/operation.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'set'
-require_relative 'json_schema'
-
-module OpenapiFirst
-  class Operation # rubocop:disable Metrics/ClassLength
-    extend Forwardable
-    def_delegators :operation_object,
-                   :[],
-                   :dig
-
-    WRITE_METHODS = Set.new(%w[post put patch delete]).freeze
-    private_constant :WRITE_METHODS
-
-    attr_reader :path, :method, :openapi_version
-
-    def initialize(path, request_method, path_item_object, openapi_version:)
-      @path = path
-      @method = request_method
-      @path_item_object = path_item_object
-      @openapi_version = openapi_version
-    end
-
-    def operation_id
-      operation_object['operationId']
-    end
-
-    def read?
-      !write?
-    end
-
-    def write?
-      WRITE_METHODS.include?(method)
-    end
-
-    def request_body
-      operation_object['requestBody']
-    end
-
-    def response_body_schema(status, content_type)
-      content = response_for(status)['content']
-      return if content.nil? || content.empty?
-
-      raise ResponseInvalid, "Response has no content-type for '#{name}'" unless content_type
-
-      media_type = find_content_for_content_type(content, content_type)
-
-      unless media_type
-        message = "Response content type not found '#{content_type}' for '#{name}'"
-        raise ResponseContentTypeNotFoundError, message
-      end
-      schema = media_type['schema']
-      return unless schema
-
-      JsonSchema.new(schema, write: false, openapi_version:)
-    end
-
-    def request_body_schema(request_content_type)
-      (@request_body_schema ||= {})[request_content_type] ||= begin
-        content = operation_object.dig('requestBody', 'content')
-        media_type = find_content_for_content_type(content, request_content_type)
-        schema = media_type&.fetch('schema', nil)
-        JsonSchema.new(schema, write: write?, openapi_version:) if schema
-      end
-    end
-
-    def response_for(status)
-      response_content = response_by_code(status)
-      return response_content if response_content
-
-      message = "Response status code or default not found: #{status} for '#{name}'"
-      raise OpenapiFirst::ResponseCodeNotFoundError, message
-    end
-
-    def name
-      @name ||= "#{method.upcase} #{path} (#{operation_id})"
-    end
-
-    def valid_request_content_type?(request_content_type)
-      content = operation_object.dig('requestBody', 'content')
-      return false unless content
-
-      !!find_content_for_content_type(content, request_content_type)
-    end
-
-    def query_parameters
-      @query_parameters ||= all_parameters.filter { |p| p['in'] == 'query' }
-    end
-
-    def path_parameters
-      @path_parameters ||= all_parameters.filter { |p| p['in'] == 'path' }
-    end
-
-    IGNORED_HEADERS = Set['Content-Type', 'Accept', 'Authorization'].freeze
-    private_constant :IGNORED_HEADERS
-
-    def header_parameters
-      @header_parameters ||= all_parameters.filter { |p| p['in'] == 'header' && !IGNORED_HEADERS.include?(p['name']) }
-    end
-
-    def cookie_parameters
-      @cookie_parameters ||= all_parameters.filter { |p| p['in'] == 'cookie' }
-    end
-
-    def all_parameters
-      @all_parameters ||= begin
-        parameters = @path_item_object['parameters']&.dup || []
-        parameters_on_operation = operation_object['parameters']
-        parameters.concat(parameters_on_operation) if parameters_on_operation
-        parameters
-      end
-    end
-
-    # Return JSON Schema of for all query parameters
-    def query_parameters_schema
-      @query_parameters_schema ||= build_json_schema(query_parameters)
-    end
-
-    # Return JSON Schema of for all path parameters
-    def path_parameters_schema
-      @path_parameters_schema ||= build_json_schema(path_parameters)
-    end
-
-    def header_parameters_schema
-      @header_parameters_schema ||= build_json_schema(header_parameters)
-    end
-
-    def cookie_parameters_schema
-      @cookie_parameters_schema ||= build_json_schema(cookie_parameters)
-    end
-
-    private
-
-    # Build JSON Schema for given parameter definitions
-    # @parameter_defs [Array<Hash>] Parameter definitions
-    def build_json_schema(parameter_defs)
-      init_schema = {
-        'type' => 'object',
-        'properties' => {},
-        'required' => []
-      }
-      schema = parameter_defs.each_with_object(init_schema) do |parameter_def, result|
-        parameter = OpenapiParameters::Parameter.new(parameter_def)
-        result['properties'][parameter.name] = parameter.schema if parameter.schema
-        result['required'] << parameter.name if parameter.required?
-      end
-      JsonSchema.new(schema, openapi_version:)
-    end
-
-    def response_by_code(status)
-      operation_object.dig('responses', status.to_s) ||
-        operation_object.dig('responses', "#{status / 100}XX") ||
-        operation_object.dig('responses', "#{status / 100}xx") ||
-        operation_object.dig('responses', 'default')
-    end
-
-    def operation_object
-      @path_item_object[method]
-    end
-
-    def find_content_for_content_type(content, request_content_type)
-      content.fetch(request_content_type) do |_|
-        type = request_content_type.split(';')[0]
-        content[type] || content["#{type.split('/')[0]}/*"] || content['*/*']
-      end
-    end
-  end
-end

data/lib/openapi_first/string_keyed_hash.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  class StringKeyedHash
-    extend Forwardable
-    def_delegators :@orig, :empty?
-
-    def initialize(original)
-      @orig = original
-    end
-
-    def key?(key)
-      @orig.key?(key.to_sym)
-    end
-
-    def [](key)
-      @orig[key.to_sym]
-    end
-  end
-end