r2-oas 0.1.0

data/lib/r2-oas/schema/v3/generator/doc_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+require_relative 'base_generator'
+require_relative 'schema_generator'
+
+module R2OAS
+  module Schema
+    module V3
+      class DocGenerator < BaseGenerator
+        attr_accessor :oas_doc
+
+        def initialize(options = {})
+          super
+          @schema_generator = SchemaGenerator.new(options)
+        end
+
+        def generate_docs
+          logger.info '[Generate OAS schema files] start'
+          @schema_generator.generate_docs unless skip_generate_docs
+          logger.info '[Generate OAS schema files] end'
+          logger.info '[Generate OAS docs from schema files] start'
+          generate_docs_from_schema_files
+          logger.info '[Generate OAS docs from schema files] end'
+        end
+
+        private
+
+        def generate_docs_from_schema_files
+          result_before_squeeze = schema_files_paths.each_with_object({}) do |path, data|
+            yaml = YAML.load_file(path)
+            data.deep_merge!(yaml)
+            logger.info " Use schema file: \t#{path}"
+          end
+
+          result = if many_paths_file_paths.present?
+                     Squeezer.new(result_before_squeeze, many_paths_file_paths: many_paths_file_paths).squeeze_docs
+                   else
+                     result_before_squeeze
+                  end
+
+          @oas_doc = result
+          File.write(doc_save_file_path, result.to_yaml)
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/generator/path_generator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'fileutils'
+require_relative 'base_generator'
+require 'r2-oas/schema/v3/manager/file/path_item_file_manager'
+
+module R2OAS
+  module Schema
+    module V3
+      class PathGenerator < BaseGenerator
+        def initialize(schema_data = {}, options = {})
+          super(options)
+          sorted_schema_data = deep_sort(schema_data, 'paths')
+          @paths = sorted_schema_data['paths']
+          @glob_schema_paths = create_glob_paths_paths
+        end
+
+        def generate_docs
+          if paths_file_do_not_exists?
+            logger.info ' <From routes data>'
+            generate_docs_from_routes_data
+          else
+            logger.info ' <From schema files>'
+            generate_docs_from_schema_fiels
+          end
+        end
+
+        private
+
+        alias paths_files_paths schema_files_paths
+        alias paths_file_do_not_exists? schema_file_do_not_exists?
+
+        def generate_docs_from_schema_fiels
+          process_when_generate_docs do |save_file_path|
+            logger.info "  Merge schema file: \t#{save_file_path}"
+          end
+        end
+
+        def generate_docs_from_routes_data
+          process_when_generate_docs do |save_file_path|
+            logger.info "  Write schema file: \t#{save_file_path}"
+          end
+        end
+
+        def process_when_generate_docs
+          logger.info ' <Update schema files (paths)>'
+          save_each_tags(@paths) do |tag_name, result|
+            relative_path = "paths/#{tag_name}"
+            path_item_file_manager = PathItemFileManager.new(relative_path, :relative)
+
+            path_item_file_manager.save(result.to_yaml) unless path_item_file_manager.skip_save?
+
+            yield path_item_file_manager.save_file_path if block_given?
+          end
+        end
+
+        def create_glob_paths_paths
+          if many_paths_file_paths.present? && !skip_load_dot_paths
+            many_paths_file_paths
+          else
+            ["#{schema_save_dir_path}/paths/**/**.yml"]
+          end
+        end
+
+        def unit_paths_data_group_by_tags(unit_paths_data)
+          unit_paths_data.each_with_object({}) do |(path, data_when_path), result|
+            data_when_path.each do |verb, data_when_verb|
+              tag_name = data_when_verb['tags'].first
+              result[tag_name] ||= {}
+              result[tag_name].deep_merge!(
+                'paths' => {
+                  path => {
+                    verb => data_when_verb
+                  }
+                }
+              )
+            end
+          end
+        end
+
+        def save_each_tags(unit_paths_data)
+          unit_paths_data_group_by_tags(unit_paths_data).each do |tag_name, result|
+            yield [tag_name, result] if block_given?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/generator/schema_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'base_generator'
+require_relative 'path_generator'
+require_relative 'components_generator'
+require 'r2-oas/schema/v3/manager/file_manager'
+
+module R2OAS
+  module Schema
+    module V3
+      class SchemaGenerator < BaseGenerator
+        def initialize(options = {})
+          super(options)
+          @docs = create_docs
+          @options = options
+        end
+
+        def generate_docs
+          if force_update_schema || schema_file_do_not_exists?
+            logger.info '<From routes data>'
+            generate_docs_from_routes_data
+          else
+            logger.info '<From schema files>'
+            generate_docs_from_schema_fiels
+          end
+        end
+
+        def create_docs
+          if !skip_generate_docs
+            super
+          elsif skip_generate_docs && FileTest.exists?(doc_save_file_path)
+            YAML.load_file(doc_save_file_path)
+          else
+            {}
+          end
+        end
+
+        private
+
+        def generate_docs_from_schema_fiels
+          process_when_generate_docs do |save_file_path|
+            logger.info " Merge schema file: \t#{save_file_path}"
+          end
+        end
+
+        def generate_docs_from_routes_data
+          process_when_generate_docs do |save_file_path|
+            logger.info " Write schema file: \t#{save_file_path}"
+          end
+        end
+
+        def process_when_generate_docs
+          logger.info '<Update schema files>'
+          @docs.each do |field_name, data|
+            result = { field_name.to_s => data }
+
+            case field_name
+            when 'paths'
+              logger.info ' [Generate OAS schema files (paths)] start'
+              PathGenerator.new(result, @options).generate_docs
+              logger.info ' [Generate OAS schema files (paths)] end'
+            when 'components'
+              logger.info ' [Generate OAS schema files (components)] start'
+              ComponentsGenerator.new(result, @options).generate_docs
+              logger.info ' [Generate OAS schema files (components)] end'
+            else
+              file_manager = FileManager.new(field_name, :relative)
+              file_manager.save(result.to_yaml)
+
+              yield file_manager.save_file_path if block_given?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/manager/diff/base_array_diff_manager.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base_diff_manager'
+
+module R2OAS
+  module Schema
+    module V3
+      class BaseArrayDiffManager < BaseDiffManager
+        def initialize(before_schema_data, after_schema_data)
+          super
+          @major_category = 'base'
+          @judge_key      = ''
+        end
+
+        def process_by_using_diff_data
+          before_data_at_major         = @before_schema_data[@major_category]
+          after_data_at_major          = @after_schema_data[@major_category]
+          after_schema_data_grouped_by = schema_data_grouped_by_judge_key(after_data_at_major)
+
+          result = before_data_at_major.map do |data|
+            judge_name = data[@judge_key]
+            if judge_name.in? after_schema_data_grouped_by.keys
+              after_schema_data_grouped_by[judge_name]
+            else
+              data
+            end
+          end
+
+          yield schema_data_at(result) if block_given?
+        end
+
+        def after_target_data
+          schema_data_at(@after_schema_data[@major_category])
+        end
+
+        private
+
+        def schema_data_grouped_by_judge_key(arr)
+          arr.each_with_object({}) do |data, result|
+            result.deep_merge!(data[@judge_key] => data)
+          end
+        end
+
+        def schema_data_at(data)
+          {
+            @major_category => data
+          }
+        end
+
+        def to_boolean(diff)
+          if diff.present?
+            diff[@major_category].present?
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/manager/diff/base_diff_manager.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'easy_diff'
+require 'r2-oas/schema/v3/base'
+
+module R2OAS
+  module Schema
+    module V3
+      class BaseDiffManager < Base
+        include Sortable
+
+        def initialize(before_schema_data, after_schema_data)
+          @before_schema_data = before_schema_data
+          @after_schema_data  = after_schema_data
+        end
+
+        def process_by_using_diff_data
+          raise NoImplementError, 'Please implement in inherited class.'
+        end
+
+        private
+
+        def ensure_presence_or_blank(data)
+          data.present? ? data : {}
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/manager/diff/base_hash_diff_manager.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'base_diff_manager'
+
+module R2OAS
+  module Schema
+    module V3
+      class BaseHashDiffManager < BaseDiffManager
+        include Sortable
+
+        def initialize(before_schema_data, after_schema_data)
+          super
+          @major_category     = 'base'
+          @middle_category    = 'middle'
+        end
+
+        def process_by_using_diff_data
+          before_target_data       = sorted_target_data(@before_schema_data)
+          before_target_data_names = before_target_data.keys.uniq
+          after_target_data        = sorted_target_data(@after_schema_data)
+          after_target_data_names  = after_target_data.keys.uniq
+          target_names             = (before_target_data_names + after_target_data_names).uniq
+
+          target_names.each do |target_name|
+            before_schema_data = schema_data_at(before_target_data, target_name)
+            after_schema_data = schema_data_at(after_target_data, target_name)
+
+            removed, added = before_schema_data.easy_diff(after_schema_data)
+            leftovers, = before_schema_data.easy_diff(removed)
+
+            is_removed   = to_boolean(removed, target_name)
+            is_added     = to_boolean(added, target_name)
+            is_leftovers = to_boolean(leftovers, target_name)
+
+            yield(target_name, is_removed, is_added, is_leftovers, after_schema_data) if block_given?
+          end
+
+          nil
+        end
+
+        private
+
+        def normalized(data)
+          if data.present?
+            data
+          elsif @middle_category.present?
+            { @major_category => { @middle_category => {} } }
+          else
+            { @major_category => {} }
+          end
+        end
+
+        def schema_data_at(data, key)
+          if @middle_category.present?
+            {
+              @major_category => {
+                @middle_category => {
+                  key => data.fetch(key, nil)
+                }
+              }
+            }
+          else
+            {
+              @major_category => {
+                key => data.fetch(key, nil)
+              }
+            }
+          end
+        end
+
+        def sorted_target_data(data)
+          data = ensure_presence_or_blank(data)
+
+          if @middle_category.present?
+            sorted_data = deep_sort(data[@major_category], @middle_category)
+            result = ensure_presence_or_blank(sorted_data[@middle_category])
+          else
+            sorted_data = deep_sort(data, @major_category)
+            result = ensure_presence_or_blank(sorted_data[@major_category])
+          end
+
+          result
+        end
+
+        def to_boolean(diff, target_name)
+          if diff.present?
+            diff.fetch(@major_category, nil)&.fetch(@middle_category, nil)&.fetch(target_name, nil).present?
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/manager/diff/components_diff_manager.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'base_hash_diff_manager'
+
+module R2OAS
+  module Schema
+    module V3
+      class ComponentsDiffManager < BaseHashDiffManager
+        def initialize(before_schema_data, after_schema_data, options = {})
+          super(before_schema_data, after_schema_data)
+          @major_category = 'components'
+          @middle_category = options[:middle_category]
+          @before_schema_data = normalized(before_schema_data)
+          @after_schema_data  = normalized(after_schema_data)
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/manager/diff/tag_diff_manager.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'base_array_diff_manager'
+
+module R2OAS
+  module Schema
+    module V3
+      class TagDiffManager < BaseArrayDiffManager
+        def initialize(before_schema_data, after_schema_data)
+          super
+          @major_category  = 'tags'
+          @judge_key       = 'name'
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/manager/file/base_file_manager.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../pathname_manager'
+require 'r2-oas/schema/v3/base'
+
+module R2OAS
+  module Schema
+    module V3
+      class BaseFileManager < Base
+        attr_accessor :original_path
+
+        # e.x.) openapi_path = "#/components/schemas/Account"
+        def initialize(path, path_type = :full)
+          super()
+          @ext_name = :yml
+          @path_type = path_type
+          @original_path = path
+          @relative_save_file_path = PathnameManager.new(path, path_type).relative_save_file_path
+        end
+
+        def delete
+          File.delete(save_file_path) if FileTest.exists?(save_file_path)
+        end
+
+        def save(data)
+          File.write(save_file_path, data)
+        end
+
+        def save_after_deep_merge(data)
+          result = load_data.deep_merge(data)
+          save(result.to_yaml)
+        end
+
+        def save_file_path
+          File.expand_path(@relative_save_file_path).tap do |abs_path|
+            abs_dir = File.dirname(abs_path)
+            FileUtils.mkdir_p(abs_dir) unless FileTest.exists?(abs_dir)
+          end
+        end
+
+        def load_data
+          case @ext_name
+          when :yml
+            if FileTest.exists?(save_file_path)
+              YAML.load_file(save_file_path)
+            else
+              {}
+            end
+          else
+            raise NoSupportError, "Do not support @ext_name: #{@ext_name}"
+          end
+        end
+
+        def descendants_paths
+          []
+        end
+      end
+    end
+  end
+end