r2-oas 0.4.0

data/lib/r2-oas/hooks/repository.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Hooks
+    class Repository
+      attr_accessor :global_hooks_data, :last_hook_id, :target
+
+      def initialize(target)
+        @global_hooks_data = {}
+        @last_hook_id = 0
+        @target = target
+      end
+    end
+  end
+end

data/lib/r2-oas/lib/core_ext/hash/deep_merge.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Copy From https://github.com/rails/rails/blob/v4.2.5/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+
+# rubocop:disable all
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = { a: true, b: { c: [1, 2, 3] } }
+  #   h2 = { a: false, b: { x: [3, 4, 5] } }
+  #
+  #   h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+  #   h2 = { b: 250, c: { c1: 200 } }
+  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  #   # => { a: 100, b: 450, c: { c1: 300 } }
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash, &block)
+    other_hash.each_pair do |current_key, other_value|
+      this_value = self[current_key]
+
+      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+        this_value.deep_merge(other_value, &block)
+      else
+        if block_given? && key?(current_key)
+          block.call(current_key, this_value, other_value)
+        else
+          other_value
+        end
+      end
+    end
+
+    self
+  end
+end
+# rubocop:enable all

data/lib/r2-oas/lib/core_ext/object/blank.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# Copy From https://github.com/rails/rails/blob/v4.2.5/activesupport/lib/active_support/core_ext/object/blank.rb
+
+# rubocop:disable all
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies
+  #
+  #   !address || address.empty?
+  #
+  # to
+  #
+  #   address.blank?
+  #
+  # @return [true, false]
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  #
+  # @return [true, false]
+  def present?
+    !blank?
+  end
+
+  # Returns the receiver if it's present otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to
+  #
+  #    object.present? ? object : nil
+  #
+  # For example, something like
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # becomes
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  #
+  # @return [Object]
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class String
+  BLANK_REGEXP = /\A[[:space:]]*\z/
+
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?       # => true
+  #   '   '.blank?    # => true
+  #   "\t\n\r".blank? # => true
+  #   ' blah '.blank? # => false
+  #
+  # Unicode whitespace is supported:
+  #
+  #   "\u00a0".blank? # => true
+  #
+  # @return [true, false]
+  def blank?
+    BLANK_REGEXP === self
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+# rubocop:enable all

data/lib/r2-oas/lib/three-way-merge/twm.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'key_flatten'
+
+# rubocop:disable all
+module Twm
+  class << self
+    #
+    # orig: local docs
+    # left: generate docs
+    # right: local src files
+    #
+    # condition: merge right into left
+    def yaml_merge(left, orig, right)
+      flat_orig = KeyFlatten.key_flatten(orig || {}).to_h
+      flat_left = KeyFlatten.key_flatten(left || {}).to_h
+      flat_right = KeyFlatten.key_flatten(right || {}).to_h
+
+      all_keys = (flat_left.keys + flat_orig.keys + flat_right.keys).uniq
+
+      twm = all_keys.each_with_object({}) do |key, result|
+        r = three_equal?(flat_left[key], flat_orig[key], flat_right[key])
+
+        if r[:left_orig] && r[:orig_right] && r[:left_right]
+          # no change
+          result[key] = flat_orig[key]
+        elsif r[:left_orig] && !r[:orig_right] && !r[:left_right]
+          # edited
+          result[key] = flat_right[key]
+        elsif !r[:left_orig] && r[:orig_right] && !r[:left_right]
+          # generate
+          result[key] = flat_left[key]
+        elsif !r[:left_orig] && !r[:orig_right] && r[:left_right]
+          # edited
+          result[key] = flat_right[key]
+        elsif !r[:left_orig] && !r[:orig_right] && !r[:left_right]
+          # conflict => prioritize edited
+          result[key] = flat_right[key]
+        end
+      end
+
+      twm = twm.delete_if { |_k, v| v.nil? }
+      KeyFlatten.key_unflatten(twm)
+    end
+
+    private
+
+    def three_equal?(left, orig, right)
+      if left == orig && orig == right
+        {
+          left_orig: true,
+          orig_right: true,
+          left_right: true
+        }
+      elsif left == orig && orig != right
+        {
+          left_orig: true,
+          orig_right: false,
+          left_right: false
+        }
+      elsif left != orig && orig == right
+        {
+          left_orig: false,
+          orig_right: true,
+          left_right: false
+        }
+      elsif left != orig && orig != right && left == right
+        {
+          left_orig: false,
+          orig_right: false,
+          left_right: true
+        }
+      elsif left != orig && orig != right && left != right
+        {
+          left_orig: false,
+          orig_right: false,
+          left_right: false
+        }
+      end
+    end
+  end
+end
+# rubocop:enable all

data/lib/r2-oas/logger/stdout_logger.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Referred to　lib/ruby/2.3.0/logger.rb
+module R2OAS
+  class StdoutLogger
+    DEBUG = 0
+    INFO = 1
+    WARN = 2
+    ERROR = 3
+    FATAL = 4
+    UNKNOWN = 5
+    NULL = 6
+    # Severity label for logging (max 5 chars).
+    SEV_LABEL = %w[DEBUG INFO WARN ERROR FATAL NULL ANY].each(&:freeze).freeze
+
+    # Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
+    attr_reader :level
+
+    def initialize
+      @progname = nil
+      @level = INFO
+      @default_formatter = Formatter.new
+      @formatter = nil
+    end
+
+    # Set logging severity threshold.
+    #
+    # +severity+:: The Severity of the log message.
+    def level=(severity)
+      if severity.is_a?(Integer)
+        @level = severity
+      else
+        _severity = severity.to_s.downcase
+        case _severity
+        when 'debug'
+          @level = DEBUG
+        when 'info'
+          @level = INFO
+        when 'warn'
+          @level = WARN
+        when 'error'
+          @level = ERROR
+        when 'fatal'
+          @level = FATAL
+        when 'unknown'
+          @level = UNKNOWN
+        when 'null'
+          @level = NULL
+        else
+          raise ArgumentError, "invalid log level: #{severity}"
+        end
+      end
+    end
+
+    def debug(progname = nil)
+      add(DEBUG, nil, progname)
+    end
+
+    def info(progname = nil)
+      add(INFO, nil, progname)
+    end
+
+    def warn(progname = nil)
+      add(WARN, nil, progname)
+    end
+
+    def error(progname = nil)
+      add(ERROR, nil, progname)
+    end
+
+    def fatal(progname = nil)
+      add(FATAL, nil, progname)
+    end
+
+    def unknown(progname = nil)
+      add(UNKNOWN, nil, progname)
+    end
+
+    private
+
+    def add(severity, _message = nil, progname = nil)
+      severity ||= UNKNOWN
+      return true if severity < @level
+
+      puts format_message(format_severity(severity), Time.now, nil, progname)
+    end
+
+    def format_message(severity, datetime, progname, msg)
+      (@formatter || @default_formatter).call(severity, datetime, progname, msg)
+    end
+
+    def format_severity(severity)
+      SEV_LABEL[severity] || 'ANY'
+    end
+
+    # Default formatter for log messages.
+    class Formatter
+      Format = "%s, [%s#%d] %5s -- %s: %s\n"
+
+      attr_accessor :datetime_format
+
+      def initialize
+        @datetime_format = nil
+      end
+
+      def call(severity, time, progname, msg)
+        format(Format, severity[0..0], format_datetime(time), $PROCESS_ID.to_i, severity, progname, msg2str(msg))
+      end
+
+      private
+
+      def format_datetime(time)
+        time.strftime(@datetime_format || '%Y-%m-%dT%H:%M:%S.%6N ')
+      end
+
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{msg.message} (#{msg.class})\n" <<
+            (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/pluggable_configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'r2-oas/schema/v3/object/from_routes/public'
+require_relative 'support/deprecation'
+
+module R2OAS
+  module PluggableConfiguration
+    # rubocop:disable Style/MutableConstant
+    DEFAULT_USE_OBJECT_CLASSES = {
+      info_object: R2OAS::Schema::V3::InfoObject,
+      paths_object: R2OAS::Schema::V3::PathsObject,
+      path_item_object: R2OAS::Schema::V3::PathItemObject,
+      external_document_object: R2OAS::Schema::V3::ExternalDocumentObject,
+      components_object: R2OAS::Schema::V3::ComponentsObject,
+      components_schema_object: R2OAS::Schema::V3::Components::SchemaObject,
+      components_request_body_object: R2OAS::Schema::V3::Components::RequestBodyObject
+    }
+    # rubocop:enable Style/MutableConstant
+
+    VALID_OPTIONS_KEYS = %i[
+      use_object_classes
+    ].freeze
+
+    attr_reader *VALID_OPTIONS_KEYS
+
+    private
+
+    module_function
+
+    def set_default(target)
+      Deprecation.silence do
+        target.use_object_classes = DEFAULT_USE_OBJECT_CLASSES
+      end
+    end
+  end
+end