r2-oas 0.3.0 → 0.4.0

data/lib/r2-oas/deploy/client.rb

@@ -6,22 +6,33 @@ require 'fileutils'
 module R2OAS
   module Deploy
     class Client < Schema::Base
+      SWAGGER_UI_DIST_URL = 'https://github.com/swagger-api/swagger-ui/trunk/dist'
+
+      def initialize(options = {})
+        super(options)
+        @download_dir = "#{SecureRandom.uuid[0..7]}/dist"
+        @dist_path = File.expand_path(Rails.root.join(@download_dir), __FILE__)
+      end
+
+      def download_swagger_ui_dist
+        system("svn export #{SWAGGER_UI_DIST_URL} #{@dist_path}")
+      end
+
       def deploy
         copy_swagger_ui_dist
         copy_swagger_ui_index
         copy_oas_doc_file
+      ensure
+        remove_download_dist
       end
 
       private
 
       def copy_swagger_ui_dist
         docs_path = File.expand_path(Rails.root.join(deploy_dir_path), __FILE__)
-        return if FileTest.exists?(docs_path)
-
         FileUtils.mkdir_p(docs_path) unless FileTest.exists?(docs_path)
-
-        dist_path = File.expand_path('swagger-ui/dist', __dir__)
-        FileUtils.cp_r(dist_path, docs_path)
+        FileUtils.mkdir_p(@dist_path) unless FileTest.exists?(@dist_path)
+        FileUtils.cp_r(@dist_path, docs_path)
       end
 
       def copy_swagger_ui_index
@@ -35,10 +46,14 @@ module R2OAS
 
       def copy_oas_doc_file
         swagger_file_path = File.expand_path(Rails.root.join(deploy_dir_path, doc_save_file_name), __FILE__)
-        oas_doc_file_path = File.expand_path("#{root_dir_path}/#{doc_save_file_name}")
+        oas_doc_file_path = File.expand_path(output_path)
         FileUtils.cp_r(oas_doc_file_path, swagger_file_path)
       end
 
+      def remove_download_dist
+        FileUtils.rm_rf(File.expand_path('..', @dist_path))
+      end
+
       # [ref]
       # https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/ErbNewArguments
       def make_index(template)

data/lib/r2-oas/{plugins/schema/v3/object → dynamic/schema/v3/object/from_routes}/hookable_base_object.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'r2-oas/schema/v3/object/base_object'
+require 'r2-oas/schema/v3/object/from_routes/base_object'
 require 'r2-oas/hooks/hook'
 
 module R2OAS
-  module Plugins
+  module Dynamic
     module Schema
       module V3
         class HookableBaseObject < R2OAS::Schema::V3::BaseObject
@@ -22,11 +22,11 @@ module R2OAS
 
           def self.inherited(base)
             base.extend ClassMethods
-            self.hook = Hooks::Hook.register(base)
+            self.hook = Hooks::Hook.register(:dynamic, base)
           end
 
           def self.hooks
-            superclass.hook.repository[self].global_hooks_data
+            superclass.hook.repository[:dynamic][self].global_hooks_data
           end
 
           def self.hook=(value)
@@ -58,8 +58,8 @@ module R2OAS
 
           attr_accessor :doc
 
-          def initialize
-            super
+          def initialize(opts = {})
+            super(opts)
             self.doc = {}
           end
 
@@ -72,7 +72,7 @@ module R2OAS
           end
 
           def use_superclass_hook
-            self.class.hook.repository[self.class] = self.class.hook.repository[self.class.superclass]
+            self.class.hook.repository[:dynamic][self.class] = self.class.hook.repository[:dynamic][self.class.superclass]
           end
 
           private

data/lib/r2-oas/errors.rb

@@ -5,4 +5,9 @@ module R2OAS
   class NoFileExistsError < StandardError; end
   class NoSupportError < StandardError; end
   class ChecksumError < StandardError; end
+  class PluginNameError < StandardError; end
+  class PluginDuplicationError < StandardError; end
+  class PluginLoadError < StandardError; end
+  class DepulicateSchemaNameError < StandardError; end
+  class RefInvalidAssignment < StandardError; end
 end

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

@@ -12,19 +12,21 @@ module R2OAS
       class << self
         attr_accessor :repository
 
-        def register(target_class)
+        def register(type, target_class)
           @repository ||= {}
+          @repository[type] ||= {}
+          @type = type
           @hooks ||= {}
-          @repository[target_class] = Repository.new(target_class)
+          @repository[type][target_class] = Repository.new(target_class)
           self
         end
 
         def on(on, callback, target_class, once = false)
-          target_repository = @repository[target_class]
+          target_repository = @repository[@type][target_class]
           uid = target_repository.last_hook_id + 1
           target_repository.last_hook_id = uid
 
-          @repository[target_class].global_hooks_data[on] ||= []
+          target_repository.global_hooks_data[on] ||= []
           global_hook = GlobalHook.new(callback, once, uid, target_class)
 
           target_repository.global_hooks_data[on].push(global_hook)
@@ -34,7 +36,7 @@ module R2OAS
 
         #  MEMO: Do not Use
         def off(uid, target_class)
-          target_repository = @repository[target_class]
+          target_repository = @repository[@type][target_class]
           result = uid
 
           target_repository.global_hooks_data.each do |on|

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/pluggable_configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'schema/v3/object/public'
+require 'r2-oas/schema/v3/object/from_routes/public'
+require_relative 'support/deprecation'
 
 module R2OAS
   module PluggableConfiguration
@@ -16,18 +17,20 @@ module R2OAS
     }
     # rubocop:enable Style/MutableConstant
 
-    VALID_OPTIONS_KEYS = [
-      :use_object_classes
+    VALID_OPTIONS_KEYS = %i[
+      use_object_classes
     ].freeze
 
-    attr_accessor *VALID_OPTIONS_KEYS
+    attr_reader *VALID_OPTIONS_KEYS
 
     private
 
     module_function
 
     def set_default(target)
-      target.use_object_classes = DEFAULT_USE_OBJECT_CLASSES
+      Deprecation.silence do
+        target.use_object_classes = DEFAULT_USE_OBJECT_CLASSES
+      end
     end
   end
 end

data/lib/r2-oas/plugin/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'r2-oas/base'
+require 'r2-oas/hooks/hook'
+require_relative 'hookable'
+
+module R2OAS
+  module Plugin
+    class Base < ::R2OAS::Base
+      extend ::R2OAS::Plugin::Hookable
+
+      class << self
+        attr_accessor :plugin_name, :type, :opts
+
+        def setup(&block)
+          return unless block_given?
+
+          callback = proc { |*args| block.call(*args) }
+          on(:setup, callback)
+        end
+
+        def teardown(&block)
+          return unless block_given?
+
+          callback = proc { |*args| block.call(*args) }
+          on(:teardown, callback)
+        end
+
+        def execute_setup(*args)
+          execute_hook(:setup, *args)
+        end
+
+        def execute_teardown(*args)
+          execute_hook(:teardown, *args)
+        end
+
+        def inherited(base)
+          super
+          base.opts = {}
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/plugin/executor.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative 'hookable'
+require 'r2-oas/errors'
+
+module R2OAS
+  module Plugin
+    class Executor
+      extend ::R2OAS::Plugin::Hookable
+
+      def initialize(plugins, opts)
+        @plugins = plugins
+        @use_plugin = !!opts[:use_plugin]
+      end
+
+      def execute_transform_plugins(hook_method, *args)
+        return unless @use_plugin
+        return unless @plugins.present?
+
+        @plugin_map ||= self.class.plugin_map(@plugins)
+
+        self.class.execute_transform_plugins(@plugin_map, hook_method, *args)
+      end
+
+      class << self
+        attr_accessor :plugin_map
+
+        def execute_transform_plugins(plugin_map, hook_method, *args)
+          execute_plugins(plugin_map, :transform, hook_method, *args)
+        end
+
+        def execute_plugins(plugin_map, type, hook_method, *args)
+          return unless plugin_map.present?
+
+          plugins_info = plugin_map[type.to_sym][hook_method.to_sym]
+
+          return if plugins_info.nil?
+
+          plugins_info.each do |info|
+            opts = info[:plugin_opts]
+            klass = info[:plugin_klass]
+            klass.send(:opts=, opts) if opts.present?
+            klass.send(info[:execute_hook_method], *args)
+          end
+        end
+
+        # e.g.)
+        # {
+        #   transform: {
+        #     setup: [
+        #       { plugin_name: 'r2oas-transform-plugin-sample1', plugin_klass: Sample1Plugin, hook_method: :setup },
+        #       { plugin_name: 'r2oas-transform-plugin-sample2', plugin_klass: Sample2Plugin, hook_method: :setup },
+        #     ],
+        #     info: [
+        #       { plugin_name: 'r2oas-transform-plugin-sample1', plugin_klass: Sample1Plugin, hook_method: :info },
+        #     ]
+        #   }
+        # }
+        #
+        def plugin_map(plugins)
+          @plugin_map ||= {}
+          return @plugin_map if @plugin_map.present?
+
+          @will_plugins = []
+
+          use_plugins_info = create_use_plugins_info(plugins)
+
+          loaded_plugins_hooks_map = hooks_map.each_with_object({}) do |(klass, repo), result|
+            # MEMO:
+            # klass may be DynamicSchema or Plugin or Other Class
+            next unless klass.respond_to?(:plugin_name)
+            # Plugins that are loaded but not used
+            next unless use_plugins_info.keys.include?(klass.plugin_name)
+
+            result[klass.plugin_name] = { klass: klass, repo: repo }
+          end
+
+          unknown_plugins = use_plugins_info.keys - loaded_plugins_hooks_map.keys
+
+          raise R2OAS::PluginLoadError, "The '#{unknown_plugins.join(', ')}' plugin doesn't exist or can't be loaded" if unknown_plugins.present?
+
+          loaded_plugins_hooks_map.each do |plugin_name, info|
+            plugin_klass = info[:klass]
+            repo = info[:repo]
+
+            repo.global_hooks_data.each do |hook_method, callbacks|
+              callbacks.each do
+                plugin_type = plugin_klass.type
+
+                data = {
+                  plugin_name: plugin_name,
+                  plugin_klass: plugin_klass,
+                  plugin_opts: use_plugins_info[plugin_name],
+                  execute_hook_method: "execute_#{hook_method}"
+                }
+
+                if @plugin_map[plugin_type].present?
+                  if @plugin_map[plugin_type][hook_method].present?
+                    @plugin_map[plugin_type][hook_method].push(data)
+                  else
+                    @plugin_map[plugin_type][hook_method] = [data]
+                  end
+                else
+                  @plugin_map[plugin_type] = {}
+                  @plugin_map[plugin_type][hook_method] = [data]
+                end
+              end
+            end
+          end
+
+          @plugin_map
+        end
+
+        def create_use_plugins_info(plugins)
+          will_use_plugins = []
+          result = {}
+
+          plugins.each do |plugin_info|
+            case plugin_info
+            when Array
+              plugin_name = plugin_info[0]
+              plugin_opts = plugin_info[1]
+
+              raise PluginNameError, 'Missing plugin name' if plugin_name.blank?
+
+              result[plugin_name] = plugin_opts
+            when String
+              plugin_name = plugin_info
+              plugin_opts = nil
+
+              result[plugin_name] = plugin_opts
+            else
+              raise NoSupportError, "The plugin loading format '#{plugin_info.class}' is incorrect"
+            end
+
+            if will_use_plugins.include?(plugin_name)
+              raise PluginDuplicationError, "Plugin: duplicate '#{plugin_name}'"
+            else
+              will_use_plugins.push(plugin_name)
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end