r2-oas 0.3.1 → 0.4.1

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'hash/deep_merge'
+require_relative 'object/blank'
+require_relative 'string/filters'

data/lib/r2-oas/lib/core_ext/string/filters.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Copy from https://github.com/rails/rails/blob/45b609c9964242f5c169d913c612eedce2a47397/activesupport/lib/active_support/core_ext/string/filters.rb#L11
+
+class String
+  # Returns the string, first removing all whitespace on both ends of
+  # the string, and then changing remaining consecutive whitespace
+  # groups into one space each.
+  #
+  # Note that it handles both ASCII and Unicode whitespace.
+  #
+  #   %{ Multi-line
+  #      string }.squish                   # => "Multi-line string"
+  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
+  def squish
+    dup.squish!
+  end
+
+  # Performs a destructive squish. See String#squish.
+  #   str = " foo   bar    \n   \t   boo"
+  #   str.squish!                         # => "foo bar boo"
+  #   str                                 # => "foo bar boo"
+  def squish!
+    gsub!(/\A[[:space:]]+/, '')
+    gsub!(/[[:space:]]+\z/, '')
+    gsub!(/[[:space:]]+/, ' ')
+    self
+  end
+end

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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'r2-oas/hooks/hook'
+
+module R2OAS
+  module Plugin
+    module Hookable
+      def hooks_map
+        hook_klass.repository[:plugin]
+      end
+
+      def hooks
+        hooks_map[self].global_hooks_data
+      end
+
+      def hook_klass=(klass)
+        @@hook_klass = klass
+      end
+
+      def hook_klass
+        @@hook_klass
+      end
+
+      def on(on, callback, once = false)
+        hook_klass.on(on, callback, self, once)
+      end
+
+      # MEMO: Do not Use
+      def off(on, callback, once = false)
+        hook_klass.off(on, callback, self, once)
+      end
+
+      def execute_hook(on, *data)
+        hook_klass.execute_hook(on, *data, self)
+      end
+
+      def has_hook?(name)
+        hook_klass.has_hook?(name, self)
+      end
+    end
+  end
+end