r2-oas 0.4.0

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

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'transform/transform'

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'r2-oas/plugin/transform/v3/transform'
+
+R2OAS::Plugin::Transform = case ::R2OAS.version
+                           when :v3
+                             R2OAS::Plugin::V3::Transform
+                           else
+                             raise NoImplementError, "Do not support version: #{::R2OAS.version}"
+  end

data/lib/r2-oas/plugin/transform/v3/transform.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'visitable'
+require 'r2-oas/plugin/base'
+
+module R2OAS
+  module Plugin
+    module V3
+      class Transform < ::R2OAS::Plugin::Base
+        extend Visitable
+
+        def self.inherited(base)
+          super
+          self.hook_klass = ::R2OAS::Hooks::Hook.register(:plugin, base)
+          base.type = :transform
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/plugin/transform/v3/visitable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'r2-oas/plugin/hookable'
+
+module R2OAS
+  module Plugin
+    module V3
+      module Visitable
+        include R2OAS::Plugin::Hookable
+
+        SCHEMA_OBJECTS = %i[
+          info
+          path_item
+          external_document
+          components_schema
+          components_request_body
+          components_schema_name
+          components_schema_name_at_request_body
+          components_request_body_name
+        ].freeze
+
+        SCHEMA_OBJECTS.each do |schema_name|
+          define_method schema_name.to_s do |&block|
+            return if block.blank?
+
+            callback = proc { |*args| block.call(*args) }
+            on(schema_name, callback)
+          end
+
+          define_method "execute_#{schema_name}" do |*args|
+            execute_hook(schema_name, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/public.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'r2-oas/configuration'
+require 'r2-oas/errors'
+require 'r2-oas/schema/v3/object/from_routes/public'

data/lib/r2-oas/routing/adjustor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'components/all'
+
+module R2OAS
+  module Routing
+    class Adjustor < Base
+      VALID_KEYS = %i[route name verb path reqs].freeze
+
+      def initialize(route_data)
+        valid_route_data?(route_data)
+        @route_data = route_data
+        @route = route_data[:route]
+        @path_comp = PathComponent.new(route_data[:path])
+        @request_comp = RequestComponent.new(route_data[:reqs], @route.engine?)
+        @verb_comp = VerbComponent.new(route_data[:verb])
+        @verbs = @verb_comp.verbs
+      end
+
+      def routes_els
+        @verbs.each_with_object([]) do |verb, result|
+          route_el = {}
+          route_el[:path] = @path_comp.symbol_to_brace
+          route_el[:data] = {
+            verb: verb,
+            path: @path_comp.symbol_to_brace,
+            tag_name: @request_comp.to_tag_name,
+            schema_name: @request_comp.to_schema_name,
+            format_name: @request_comp.to_format_name,
+            required_parameters: @path_comp.path_parameters_data
+          }
+          result.push route_el
+        end
+      end
+
+      private
+
+      def valid_route_data?(route_data)
+        raise 'Invalid params' unless route_data.keys.eql?(VALID_KEYS)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# MEMO
+# load this file before autoload ::R2OAS::Base
+require 'r2-oas/base'
+
+module R2OAS
+  module Routing
+    class Base < ::R2OAS::Base
+    end
+  end
+end

data/lib/r2-oas/routing/components/all.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'path_component'
+require_relative 'request_component'
+require_relative 'verb_component'

data/lib/r2-oas/routing/components/base_component.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative '../base'
+
+module R2OAS
+  module Routing
+    class BaseComponent < Base
+    end
+  end
+end

data/lib/r2-oas/routing/components/path_component.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module R2OAS
+  module Routing
+    class PathComponent < BaseComponent
+      FORMAT_PATH_PARAMETER_REGEXP = /\(.+\)/.freeze
+      SYMBOL_PATH_PARAMETER_REGEXP = /:(.\w+)/.freeze
+      BRACE_PATH_PARAMETER_REGEXP  = /\{(.\w+)\}/.freeze
+
+      def initialize(path)
+        super()
+        @path = path
+      end
+
+      def to_s
+        without_format.to_s
+      end
+
+      def symbol_to_brace
+        return without_format unless exist_path_parameters?
+
+        path_parameters.each_with_object(without_format) do |path_parameter, result|
+          result.gsub!(":#{path_parameter}", "{#{path_parameter}}")
+        end
+      end
+
+      def path_parameters_data
+        return {} unless exist_path_parameters?
+
+        path_parameters.each_with_object({}) do |path_parameter, data|
+          type = (path_parameter =~ /id/ ? 'integer' : 'string')
+          data.merge!(
+            "#{path_parameter}": {
+              type: type
+            }
+          )
+        end
+      end
+
+      def path_excluded_path_parameters
+        excluded_path_parameters = path_parameters.each_with_object(symbol_to_brace) do |path_parameter, result|
+          result.gsub!("{#{path_parameter}}", '')
+        end
+        excluded_path_parameters.split('/').delete_if(&:empty?).join('/')
+      end
+
+      def exist_path_parameters?
+        path_parameters.present?
+      end
+
+      def path_parameters
+        result = without_format.scan(SYMBOL_PATH_PARAMETER_REGEXP) + without_format.scan(BRACE_PATH_PARAMETER_REGEXP)
+        result.flatten
+      end
+
+      private
+
+      # e.x.) "/tasks(.:format)" => "/tasks"
+      # e.x.) "/:model_name/:id/show_in_app(.:format)" => "/{model_name}/{id}/show_in_app"
+      def without_format
+        @path.gsub(FORMAT_PATH_PARAMETER_REGEXP, '')
+      end
+    end
+  end
+end