r2-oas 0.4.0

data/lib/r2-oas/configuration.rb

@@ -0,0 +1,121 @@
+# 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'
+
+module R2OAS
+  module Configuration
+    extend AppConfiguration
+    extend PluggableConfiguration
+
+    PUBLIC_VALID_OPTIONS_KEYS = AppConfiguration::VALID_OPTIONS_KEYS + PluggableConfiguration::VALID_OPTIONS_KEYS
+
+    UNPUBLIC_VALID_OPTIONS_KEYS = %i[
+      paths_config
+      logger
+    ].freeze
+
+    VALID_OPTIONS_KEYS = PUBLIC_VALID_OPTIONS_KEYS + UNPUBLIC_VALID_OPTIONS_KEYS
+
+    attr_accessor *PUBLIC_VALID_OPTIONS_KEYS
+
+    # MEMO: override because deprecated
+    def use_object_classes=(data)
+      ::R2OAS::Deprecation.will_remove(<<-MSG.squish)
+        Using a R2OAS.use_object_classes= in configuration is deprecated and
+        will be removed in r2-oas (v0.4.2).
+      MSG
+      @use_object_classes = data
+    end
+
+    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
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    def logger
+      @_stdout_logger ||= StdoutLogger.new
+    end
+
+    def paths_config
+      @_paths_config ||= PathsConfig.new(root_dir_path, schema_save_dir_name)
+    end
+
+    def app_configuration_options
+      AppConfiguration::VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    def pluggable_configuration_options
+      PluggableConfiguration::VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    def load_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 init
+      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"
+
+      FileUtils.mkdir_p(plugins_helpers_path) unless FileTest.exists?(plugins_helpers_path)
+      FileUtils.mkdir_p(tasks_helpers_path) unless FileTest.exists?(tasks_helpers_path)
+
+      File.write(gitkeep_plugins_path, '') unless FileTest.exists?(gitkeep_plugins_path)
+      File.write(gitkeep_plugins_helpers_path, '') unless FileTest.exists?(gitkeep_plugins_helpers_path)
+      File.write(gitkeep_tasks_path, '') unless FileTest.exists?(gitkeep_tasks_path)
+      File.write(gitkeep_tasks_helpers_path, '') unless FileTest.exists?(gitkeep_tasks_helpers_path)
+      paths_config.create_dot_paths
+    end
+
+    def output_dir_path
+      output_path.to_s.split('/').slice(0..-2).join('/')
+    end
+
+    private
+
+    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
+
+    def set_default_for_pluggable(target)
+      PluggableConfiguration.set_default(target)
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'r2-oas/schema/manager/file/path_item_file_manager'
+
+module R2OAS
+  module Configuration
+    class PathsConfig
+      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}"
+      end
+
+      def abs_paths_path
+        File.expand_path("#{@root_dir_path}/.paths")
+      end
+
+      def all_load_paths?
+        many_paths_file_paths.present?
+      end
+
+      def many_paths_file_paths
+        @many_paths_file_paths ||= File.read(abs_paths_path).split("\n").each_with_object([]) do |relative_path, result|
+          abs_path = File.expand_path("#{@schema_save_dir_path}/paths/#{relative_path}")
+          result.push(abs_path) if FileTest.exists?(abs_path) && FileTest.file?(abs_path)
+        end.uniq.compact.reject(&:empty?)
+      end
+
+      def create_dot_paths
+        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)
+      end
+
+      def many_components_file_paths
+        @many_components_file_paths ||= many_paths_file_paths.each_with_object([]) do |unit_paths_path, result|
+          file_manager = Schema::PathItemFileManager.new(unit_paths_path, :full)
+          components_file_paths_at_path = file_manager.descendants_ref_paths
+          result.push(*components_file_paths_at_path)
+        end.uniq
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal:true
+
+require 'fileutils'
+
+# Scope Rails
+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__)
+        FileUtils.mkdir_p(docs_path) unless FileTest.exists?(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
+        index_path = File.expand_path(Rails.root.join(deploy_dir_path, 'index.html'), __FILE__)
+        @schema_file_path = doc_save_file_name
+        template_path = File.expand_path('swagger-ui/index.html.erb', __dir__)
+        template = File.read(template_path)
+        index = make_index(template)
+        File.write(index_path, index)
+      end
+
+      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(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)
+        if RUBY_VERSION >= '2.6'
+          ERB.new(template, trim_mode: '%').result(binding)
+        else
+          # rubocop:disable Lint/ErbNewArguments
+          ERB.new(template, nil, trim_mode: '%').result(binding)
+          # rubocop:enable Lint/ErbNewArguments
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/deploy/swagger-ui/index.html.erb

@@ -0,0 +1,60 @@
+<!-- HTML for static distribution bundle build -->
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>Swagger UI</title>
+    <link rel="stylesheet" type="text/css" href="dist/swagger-ui.css" >
+    <link rel="icon" type="image/png" href="dist/favicon-32x32.png" sizes="32x32" />
+    <link rel="icon" type="image/png" href="dist/favicon-16x16.png" sizes="16x16" />
+    <style>
+      html
+      {
+        box-sizing: border-box;
+        overflow: -moz-scrollbars-vertical;
+        overflow-y: scroll;
+      }
+
+      *,
+      *:before,
+      *:after
+      {
+        box-sizing: inherit;
+      }
+
+      body
+      {
+        margin:0;
+        background: #fafafa;
+      }
+    </style>
+  </head>
+
+  <body>
+    <div id="swagger-ui"></div>
+
+    <script src="dist/swagger-ui-bundle.js"> </script>
+    <script src="dist/swagger-ui-standalone-preset.js"> </script>
+    <script>
+    window.onload = function() {
+      // Begin Swagger UI call region
+      const ui = SwaggerUIBundle({
+        url: "<%= @schema_file_path %>",
+        dom_id: '#swagger-ui',
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIStandalonePreset
+        ],
+        plugins: [
+          SwaggerUIBundle.plugins.DownloadUrl
+        ],
+        layout: "StandaloneLayout"
+      })
+      // End Swagger UI call region
+
+      window.ui = ui
+    }
+  </script>
+  </body>
+</html>

data/lib/r2-oas/dynamic/schema/v3/object/from_routes/hookable_base_object.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'r2-oas/schema/v3/object/from_routes/base_object'
+require 'r2-oas/hooks/hook'
+
+module R2OAS
+  module Dynamic
+    module Schema
+      module V3
+        class HookableBaseObject < R2OAS::Schema::V3::BaseObject
+          module ClassMethods
+            def before_create(&block)
+              proc = (block_given? ? block : proc {})
+              on(:before_create, proc)
+            end
+
+            def after_create(&block)
+              proc = (block_given? ? block : proc {})
+              on(:after_create, proc)
+            end
+          end
+
+          def self.inherited(base)
+            base.extend ClassMethods
+            self.hook = Hooks::Hook.register(:dynamic, base)
+          end
+
+          def self.hooks
+            superclass.hook.repository[:dynamic][self].global_hooks_data
+          end
+
+          def self.hook=(value)
+            @@hook = value
+          end
+
+          def self.hook
+            @@hook
+          end
+
+          class << self
+            def on(on, callback, once = false)
+              hook.on(on, callback, self, once)
+            end
+
+            # MEMO: Do not Use
+            def off(on, callback, once = false)
+              hook.off(on, callback, self, once)
+            end
+
+            def execute_hook(on, *data)
+              hook.execute_hook(on, *data, self)
+            end
+
+            def has_hook?(name)
+              hook.has_hook?(name, self)
+            end
+          end
+
+          attr_accessor :doc
+
+          def initialize(opts = {})
+            super(opts)
+            self.doc = {}
+          end
+
+          # MEMO: Please overwrite when passing arguments other than `doc`
+          def to_doc
+            execute_before_create
+            create_doc
+            execute_after_create
+            doc
+          end
+
+          def use_superclass_hook
+            self.class.hook.repository[:dynamic][self.class] = self.class.hook.repository[:dynamic][self.class.superclass]
+          end
+
+          private
+
+          def create_doc
+            raise NoImplementError
+          end
+
+          def execute_before_create(*data)
+            execute_hook_method(:before_create, *data)
+          end
+
+          def execute_after_create(*data)
+            execute_hook_method(:after_create, *data)
+          end
+
+          def execute_hook_method(method_name, *data)
+            args = [doc].push(*data)
+            self.class.execute_hook(method_name.to_sym, *args) if self.class.has_hook?(method_name.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module R2OAS
+  class NoImplementError < StandardError; end
+  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/global_hook.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Hooks
+    class GlobalHook
+      attr_accessor :callback, :once, :uid, :target
+
+      def initialize(callback, once, uid, target)
+        self.callback = callback
+        self.once = once
+        self.uid = uid
+        self.target = target
+      end
+
+      def call(*data)
+        callback.call(*data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative './global_hook'
+require_relative './repository'
+
+module R2OAS
+  module Hooks
+    class Hook
+      include Singleton
+
+      class << self
+        attr_accessor :repository
+
+        def register(type, target_class)
+          @repository ||= {}
+          @repository[type] ||= {}
+          @type = type
+          @hooks ||= {}
+          @repository[type][target_class] = Repository.new(target_class)
+          self
+        end
+
+        def on(on, callback, target_class, once = false)
+          target_repository = @repository[@type][target_class]
+          uid = target_repository.last_hook_id + 1
+          target_repository.last_hook_id = uid
+
+          target_repository.global_hooks_data[on] ||= []
+          global_hook = GlobalHook.new(callback, once, uid, target_class)
+
+          target_repository.global_hooks_data[on].push(global_hook)
+
+          uid
+        end
+
+        #  MEMO: Do not Use
+        def off(uid, target_class)
+          target_repository = @repository[@type][target_class]
+          result = uid
+
+          target_repository.global_hooks_data.each do |on|
+            global_hooks = target_repository.global_hooks_data[on]
+            index = global_hooks.find_index { |hook| hook.uid == uid }
+
+            if index
+              global_hooks.delete_if { |hook| hook.uid == uid }
+            else
+              result = nil
+            end
+          end
+
+          result
+        end
+
+        def execute_hook(on, *data, target_class)
+          return data unless has_hook?(on, target_class)
+
+          execute_global_hook(on, *data, target_class)
+        end
+
+        def has_hook?(name, target_class)
+          !!get_hook(name, target_class)
+        end
+
+        private
+
+        def execute_global_hook(on, *data, target_class)
+          global_hook = get_hook(on, target_class)
+          global_hook.present? ? global_hook.call(*data) : data
+        end
+
+        def get_hook(name, target_class)
+          target_class.hooks[name]&.first
+        end
+      end
+    end
+  end
+end