r2-oas 0.3.2 → 0.5.0

data/lib/r2-oas/app_configuration.rb

@@ -2,7 +2,7 @@
 
 require_relative 'app_configuration/server'
 require_relative 'app_configuration/swagger'
-require_relative 'app_configuration/tool'
+require_relative 'app_configuration/deprecation'
 
 module R2OAS
   module AppConfiguration
@@ -42,10 +42,14 @@ module R2OAS
     DEFAULT_HTTP_METHODS_WHEN_GENERATE_REQUEST_BODY = %w[post patch put]
     DEFAULT_IGNORED_HTTP_STATUSES_WHEN_GENERATE_COMPONENT_SCHEMA = %w[204 404]
     # rubocop:enable Style/MutableConstant
-    DEFAULT_TOOL = Tool.new
     # :dot or :underbar
-    DEFAULT_NAMESPACE_TYPE = :underbar
+    DEFAULT_NAMESPACE_TYPE = :dot
     DEFAULT_DEPLOY_DIR_PATH = './deploy_docs'
+    EDFAULT_PLUGINS = [].freeze
+    DEFAULT_LOCAL_PLUGINS_DIR_NAME = 'plugins'
+    DEFAULT_LOCAL_TASKS_DIR_NAME = 'tasks'
+    DEFAULT_OUTPUT_PATH = './oas_docs/dist/oas_doc.yml'
+    DEFAULT_DEPRECATION = Deprecation.new
 
     PUBLIC_VALID_OPTIONS_KEYS = %i[
       version
@@ -61,9 +65,13 @@ module R2OAS
       http_statuses_when_http_method
       http_methods_when_generate_request_body
       ignored_http_statuses_when_generate_component_schema
-      tool
       namespace_type
       deploy_dir_path
+      plugins
+      local_plugins_dir_name
+      local_tasks_dir_name
+      output_path
+      deprecation
     ].freeze
 
     UNPUBLIC_VALID_OPTIONS_KEYS = %i[
@@ -95,11 +103,15 @@ module R2OAS
       target.interval_to_save_edited_tmp_schema                   = DEFAULT_INTERVAL_TO_SAVE_EDITED_TMP_SCHEMA
       target.swagger                                              = DEFAULT_SWAGGER
       target.http_statuses_when_http_method                       = DEFAULT_HTTP_STATUSES_WHEN_HTTP_METHOD
-      target.tool                                                 = DEFAULT_TOOL
       target.http_methods_when_generate_request_body              = DEFAULT_HTTP_METHODS_WHEN_GENERATE_REQUEST_BODY
       target.ignored_http_statuses_when_generate_component_schema = DEFAULT_IGNORED_HTTP_STATUSES_WHEN_GENERATE_COMPONENT_SCHEMA
       target.namespace_type                                       = DEFAULT_NAMESPACE_TYPE
       target.deploy_dir_path                                      = DEFAULT_DEPLOY_DIR_PATH
+      target.plugins                                              = EDFAULT_PLUGINS
+      target.local_plugins_dir_name                               = DEFAULT_LOCAL_PLUGINS_DIR_NAME
+      target.local_tasks_dir_name                                 = DEFAULT_LOCAL_TASKS_DIR_NAME
+      target.output_path                                          = DEFAULT_OUTPUT_PATH
+      target.deprecation                                          = DEFAULT_DEPRECATION
     end
   end
 end

data/lib/r2-oas/app_configuration/deprecation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'r2-oas/support/deprecation'
+
+module R2OAS
+  module AppConfiguration
+    class Deprecation
+      DEFAULT_SILENCED = ::R2OAS::Deprecation.silenced
+
+      attr_reader :silenced
+
+      def silenced=(value)
+        @silenced = !!value
+        ::R2OAS::Deprecation.silenced = !!value
+      end
+
+      def initialize
+        set_default
+      end
+
+      private
+
+      def set_default
+        self.silenced = DEFAULT_SILENCED
+      end
+    end
+  end
+end

data/lib/r2-oas/configuration.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+
 require_relative 'app_configuration'
-require_relative 'pluggable_configuration'
 require_relative 'configuration/paths_config'
 require_relative 'logger/stdout_logger'
+require_relative 'support/deprecation'
+require_relative 'helpers/file_helper'
 
 module R2OAS
   module Configuration
     extend AppConfiguration
-    extend PluggableConfiguration
+    include Helpers::FileHelper
 
-    PUBLIC_VALID_OPTIONS_KEYS = AppConfiguration::VALID_OPTIONS_KEYS + PluggableConfiguration::VALID_OPTIONS_KEYS
+    PUBLIC_VALID_OPTIONS_KEYS = AppConfiguration::VALID_OPTIONS_KEYS
 
     UNPUBLIC_VALID_OPTIONS_KEYS = %i[
       paths_config
@@ -23,11 +26,11 @@ module R2OAS
 
     def self.extended(base)
       base.send :set_default_for_configuration, base
-      base.send :set_default_for_pluggable, base
     end
 
     def configure
       yield self if block_given?
+      load_local_plugins
     end
 
     def options
@@ -50,20 +53,63 @@ module R2OAS
       end
     end
 
-    def pluggable_configuration_options
-      PluggableConfiguration::VALID_OPTIONS_KEYS.inject({}) do |option, key|
-        option.merge!(key => send(key))
+    def load_tasks
+      load_local_tasks
+    end
+
+    def init
+      old_stdout = $stdout
+      $stdout = StringIO.new
+
+      plugins_path = File.expand_path("#{root_dir_path}/#{local_plugins_dir_name}")
+      plugins_helpers_path = "#{plugins_path}/helpers"
+      tasks_path = File.expand_path("#{root_dir_path}/#{local_tasks_dir_name}")
+      tasks_helpers_path = "#{tasks_path}/helpers"
+
+      gitkeep_plugins_path = "#{plugins_path}/.gitkeep"
+      gitkeep_plugins_helpers_path = "#{plugins_helpers_path}/.gitkeep"
+      gitkeep_tasks_path = "#{tasks_path}/.gitkeep"
+      gitkeep_tasks_helpers_path = "#{tasks_helpers_path}/.gitkeep"
+
+      paths_config.create_dot_paths(false)
+      mkdir_p_dir_or_skip(plugins_helpers_path)
+      mkdir_p_dir_or_skip(tasks_helpers_path)
+      write_file_or_skip(gitkeep_plugins_path, '')
+      write_file_or_skip(gitkeep_plugins_helpers_path, '')
+      write_file_or_skip(gitkeep_tasks_path, '')
+      write_file_or_skip(gitkeep_tasks_helpers_path, '')
+
+      if $stdout.string.present?
+        STDOUT.puts $stdout.string
+      else
+        STDOUT.puts "Already Initialized existing oas_docs in #{root_dir_path}"
       end
+
+      $stdout = old_stdout
+    end
+
+    def output_dir_path
+      output_path.to_s.split('/').slice(0..-2).join('/')
     end
 
     private
 
-    def set_default_for_configuration(target)
-      AppConfiguration.set_default(target)
+    def load_local_tasks
+      tasks_path = File.expand_path("#{root_dir_path}/#{local_tasks_dir_name}")
+      Dir.glob("#{tasks_path}/**/*.rake").sort.each do |file|
+        load file if FileTest.exists?(file)
+      end
     end
 
-    def set_default_for_pluggable(target)
-      PluggableConfiguration.set_default(target)
+    def load_local_plugins
+      plugins_path = File.expand_path("#{root_dir_path}/#{local_plugins_dir_name}")
+      Dir.glob("#{plugins_path}/**/*.rb").sort.each do |file|
+        require file if FileTest.exists?(file)
+      end
+    end
+
+    def set_default_for_configuration(target)
+      AppConfiguration.set_default(target)
     end
   end
 end

data/lib/r2-oas/configuration/paths_config.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 require 'r2-oas/schema/manager/file/path_item_file_manager'
+require 'r2-oas/helpers/file_helper'
 
 module R2OAS
   module Configuration
     class PathsConfig
+      include Helpers::FileHelper
+
       def initialize(root_dir_path, schema_save_dir_name)
         @root_dir_path = root_dir_path
         @schema_save_dir_path = "#{root_dir_path}/#{schema_save_dir_name}"
@@ -25,11 +28,11 @@ module R2OAS
         end.uniq.compact.reject(&:empty?)
       end
 
-      def create_dot_paths
+      def create_dot_paths(silent = true)
         abs_root_path = File.expand_path(@root_dir_path)
 
-        FileUtils.mkdir_p(abs_root_path) unless FileTest.exists?(abs_root_path)
-        File.write(abs_paths_path, '') unless FileTest.exists?(abs_paths_path)
+        mkdir_p_dir_or_skip(abs_root_path, silent)
+        write_file_or_skip(abs_paths_path, '', silent)
       end
 
       def many_components_file_paths

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

@@ -46,7 +46,7 @@ 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
 

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/helpers/file_helper.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+# https :/ / keyesberry.hatenadiary.org / entry / 20101107 / p1
+#
+# Text attributes
+# 0	All attributes off
+# 1	Bold on
+# 4	Underscore (on monochrome display adapter only)
+# 5	Blink on
+# 7	Reverse video on
+# 8	Concealed on
+
+# Foreground colors
+# 30	Black
+# 31	Red
+# 32	Green
+# 33	Yellow
+# 34	Blue
+# 35	Magenta
+# 36	Cyan
+# 37	White
+
+# Background colors
+# 40	Black
+# 41	Red
+# 42	Green
+# 43	Yellow
+# 44	Blue
+# 45	Magenta
+# 46	Cyan
+# 47	White
+module R2OAS
+  module Helpers
+    module FileHelper
+      def write_file_or_skip(file_path, data, silent = false)
+        unless FileTest.exists?(file_path)
+          File.write(file_path, data)
+          puts "#{space}#{bold('create')}\t#{relative(file_path)}" unless silent
+        end
+      end
+
+      def mkdir_p_dir_or_skip(dir_path, silent = false)
+        unless FileTest.exists?(dir_path)
+          FileUtils.mkdir_p(dir_path)
+          puts "#{space}#{bold('create')}\t#{relative(dir_path)}" unless silent
+        end
+      end
+
+      private
+
+      def relative(path)
+        current_dir_pathname = Pathname.new(Dir.pwd)
+        target_path = Pathname.new(path)
+        target_path.relative_path_from(current_dir_pathname)
+      end
+
+      def bold(str)
+        "\e[1m#{str}\e[0m"
+      end
+
+      def space
+        '      '
+      end
+    end
+  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/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