r2-oas 0.1.0

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'r2-oas/schema/v3/generator'
+
+module R2OAS
+  module Schema
+    class Generator
+      extend Forwardable
+
+      def_delegators :@generator, :generate_docs, :oas_doc
+
+      def initialize(options = {})
+        case ::R2OAS.version
+        when :v3
+          @generator = V3::Generator.new(options)
+        else
+          raise NoImplementError, "Do not support version: #{::R2OAS.version}"
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/manager/file/path_item_file_manager.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Schema
+    class PathItemFileManager
+      extend Forwardable
+
+      def_delegators :@manager, :skip_save?, :descendants_paths, :descendants_ref_paths
+
+      def initialize(path, path_type = :ref)
+        case ::R2OAS.version
+        when :v3
+          @manager = V3::PathItemFileManager.new(path, path_type)
+        else
+          raise "Do not support version: #{::R2OAS.version}"
+        end
+      end
+
+      class << self
+        alias build new
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/monitor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal:true
+
+require 'eventmachine'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    class Monitor < Base
+      def initialize(before_schema_data, options)
+        super(options)
+        @before_schema_data = before_schema_data
+      end
+
+      def start
+        EM.run do
+          ensure_save_tmp_schema_file
+          signal_trap('INT')
+          signal_trap('TERM')
+        end
+      end
+
+      private
+
+      attr_accessor :unit_paths_file_path
+
+      def signal_trap(command)
+        Signal.trap(command) do
+          process_after_close_monitor
+          EM.stop
+        end
+      end
+
+      def process_after_close_monitor
+        options = { type: :edited }
+        @after_schema_data = fetch_after_schema_data
+        analyzer = Analyzer.new(@before_schema_data, @after_schema_data, options)
+        analyzer.analyze_docs
+      end
+
+      def ensure_save_tmp_schema_file
+        EM.add_periodic_timer(interval_to_save_edited_tmp_schema) do
+          @after_schema_data = fetch_after_schema_data
+          puts "\nwait for signal trap ..."
+        end
+      end
+
+      def fetch_after_schema_data
+        YAML.load_file(doc_save_file_path) || @after_schema_data
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/squeezer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'r2-oas/schema/v3/squeezer'
+
+module R2OAS
+  module Schema
+    class Squeezer
+      extend Forwardable
+
+      def_delegators :@squeezer, :squeeze_docs
+
+      def initialize(schema_data, options = {})
+        case ::R2OAS.version
+        when :v3
+          @squeezer = V3::Squeezer.new(schema_data, options)
+        else
+          raise NoImplementError, "Do not support version: #{::R2OAS.version}"
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/ui.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal:true
+
+require 'docker'
+require 'eventmachine'
+require 'watir'
+require 'shell'
+require 'forwardable'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    class UI < Base
+      extend Forwardable
+
+      alias swagger_json doc_save_file_path
+
+      def initialize(options = {})
+        super
+        @ui = swagger.ui
+      end
+
+      def start
+        EM.run do
+          container.start
+          open_browser
+          puts "\nwait for single trap ..."
+          signal_trap('INT')
+          signal_trap('TERM')
+        end
+      end
+
+      private
+
+      attr_accessor :unit_paths_file_path
+      def_delegators :@ui, :image, :port, :url, :exposed_port, :volume
+
+      def signal_trap(command)
+        Signal.trap(command) do
+          container.stop
+          container.remove
+          logger.info "container id: #{container.id} removed"
+
+          EM.stop
+        end
+      end
+
+      def open_browser
+        @browser ||= Watir::Browser.new
+        @browser.goto(url)
+        wait_for_loaded
+      end
+
+      def wait_for_loaded
+        Watir::Wait.until { @browser.body.present? }
+      end
+
+      # [Reference]
+      # https://www.tomduffield.com/files/presentations/the-nitty-gritty-of-the-docker-api.pdf
+      def container
+        @container ||= Docker::Container.create(
+          'Image' => image,
+          'ExposedPorts' => { exposed_port => {} },
+          'HostConfig' => {
+            'PortBindings' => {
+              exposed_port => [{ 'HostPort' => port }]
+            },
+            'Binds' => ["#{swagger_json}:#{volume}"]
+          },
+          'Volumes' => { volume => {} }
+        )
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/analyzer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'analyzer/base_analyzer'
+require_relative 'analyzer/path_analyzer'
+require_relative 'analyzer/tag_analyzer'
+require_relative 'analyzer/components_analyzer'
+require 'r2-oas/schema/v3/manager/file_manager'
+
+module R2OAS
+  module Schema
+    module V3
+      class Analyzer < BaseAnalyzer
+        def initialize(before_schema_data, after_schema_data, options = {})
+          super
+          @path_analyzer       = PathAnalyzer.new(@before_schema_data, @after_schema_data, options)
+          @tag_analyzer        = TagAnalyzer.new(@after_schema_data, options)
+          @components_analyzer = ComponentsAnalyzer.new(@before_schema_data, @after_schema_data, options)
+        end
+
+        def analyze_docs
+          logger.info '[Analyze OAS file] start'
+          @after_schema_data.keys.each do |schema_name|
+            case schema_name
+            when 'paths'
+              logger.info '[Analyze OAS file (paths)] start'
+              @path_analyzer.analyze_docs
+              logger.info '[Analyze OAS file (paths)] end'
+            when 'tags'
+              logger.info '[Analyze OAS file (tags)] start'
+              @tag_analyzer.analyze_docs
+              logger.info '[Analyze OAS file (tags)] end'
+            when 'components'
+              logger.info '[Analyze OAS file (components)] start'
+              @components_analyzer.analyze_docs
+              logger.info '[Analyze OAS file (components)] end'
+            else
+              save_schema_when(schema_name)
+            end
+          end
+          logger.info '[Analyze OAS file] end'
+        end
+
+        private
+
+        def save_schema_when(schema_name)
+          file_manager = FileManager.new(schema_name, :relative)
+          data = @after_schema_data.slice(schema_name)
+          case @type
+          when :edited
+            file_manager.save_after_deep_merge(data)
+          when :existing
+            file_manager.save(data.to_yaml)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/analyzer/base_analyzer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'r2-oas/schema/v3/base'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    module V3
+      class BaseAnalyzer < Base
+        include Sortable
+
+        def initialize(before_schema_data, after_schema_data, options = {})
+          super(options)
+          @type = options[:type].presence
+          @before_schema_data = before_schema_data
+          @after_schema_data  = after_schema_data.presence || create_after_schema_data
+        end
+
+        def analyze_docs
+          raise NoImplementError, 'Please implement in inherited class.'
+        end
+
+        def generate_from_existing_schema
+          raise NoImplementError, 'Please implement in inherited class.'
+        end
+
+        private
+
+        attr_accessor :edited_schema_file_path
+        attr_accessor :existing_schema_file_path
+        attr_accessor :type
+
+        def create_after_schema_data
+          case @type
+          when :edited
+            create_after_schema_data_when_edited
+          when :existing
+            if existing_schema_file_path.present?
+              create_after_schema_data_when_specify_path
+            else
+              create_after_schema_data_when_not_specify_path
+            end
+          end
+        end
+
+        def create_after_schema_data_when_edited
+          YAML.load_file(edited_schema_file_path)
+        end
+
+        def create_after_schema_data_when_not_specify_path
+          if FileTest.exists?(doc_save_file_path)
+            YAML.load_file(doc_save_file_path)
+          else
+            raise NoFileExistsError, "Do not exists file: #{doc_save_file_path}"
+          end
+        end
+
+        def create_after_schema_data_when_specify_path
+          extname = File.extname(existing_schema_file_path)
+          case extname
+          when /json/
+            File.open(existing_schema_file_path) do |file|
+              JSON.parse(file.read)
+            end
+          when /yaml/
+            YAML.load_file(existing_schema_file_path)
+          when /yml/
+            YAML.load_file(existing_schema_file_path)
+          else
+            raise NoImplementError, "Do not support extension: #{extname}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/analyzer/components/object_analyzer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../base_analyzer'
+require 'r2-oas/schema/v3/manager/file/components_file_manager'
+require 'r2-oas/schema/v3/manager/diff/components_diff_manager'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    module V3
+      module Components
+        class ObjectAnalyzer < BaseAnalyzer
+          def initialize(before_schema_data, after_schema_data, options = {})
+            super(before_schema_data, after_schema_data, options.except(:middle_category))
+            @major_category = 'components'
+            @middle_category = options[:middle_category]
+          end
+
+          def analyze_docs
+            diff_manager = ComponentsDiffManager.new(@before_schema_data, @after_schema_data, middle_category: @middle_category)
+            diff_manager.process_by_using_diff_data do |schema_name, is_removed, is_added, is_leftovers, after_edited_data|
+              file_manager = ComponentsFileManager.build("#/#{@major_category}/#{@middle_category}/#{schema_name}", :ref)
+              save_file_path = file_manager.save_file_path
+
+              if is_removed && !is_added && !is_leftovers
+                file_manager.delete
+                logger.info "  Delete schema file: \t#{save_file_path}"
+              else
+                file_manager.save(after_edited_data.to_yaml)
+                logger.info "  Write schema file: \t#{save_file_path}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/analyzer/components_analyzer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'base_analyzer'
+require_relative 'components/object_analyzer'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    module V3
+      class ComponentsAnalyzer < BaseAnalyzer
+        def initialize(before_schema_data, after_schema_data, options = {})
+          super
+          @options = options
+        end
+
+        def analyze_docs
+          support_components_objects.each do |object_name|
+            logger.info "[Analyze OAS file (components/#{object_name})] start"
+            Components::ObjectAnalyzer.new(
+              @before_schema_data,
+              @after_schema_data,
+              @options.merge(middle_category: object_name)
+            ).analyze_docs
+            logger.info "[Analyze OAS file (components/#{object_name})] end"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/analyzer/path_analyzer.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative 'base_analyzer'
+require 'r2-oas/schema/v3/manager/file/path_item_file_manager'
+require 'r2-oas/schema/v3/manager/file_manager'
+require 'r2-oas/schema/v3/object/tag_object'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    module V3
+      class PathAnalyzer < BaseAnalyzer
+        VERB = %w[get put post delete options head patch trace].freeze
+        NOT_VERB = %w[$ref summary description servers parameters].freeze
+
+        def initialize(before_schema_data, after_schema_data, options = {})
+          super
+          @tags = []
+        end
+
+        def analyze_docs
+          sorted_schema = deep_sort(@after_schema_data, 'paths')
+          edited_paths_schema = sorted_schema['paths']
+
+          save_each_tags(edited_paths_schema) do |tag_name, result|
+            file_manager = PathItemFileManager.new("paths/#{tag_name}", :relative)
+            file_manager.save(result.to_yaml)
+            logger.info "  Write schema file: \t#{file_manager.save_file_path}"
+          end
+
+          # Automatically generated when there is no tag object in the read schema file
+          if generate_tag_file?
+            result = { 'tags' => V3::TagObject.new(@tags).to_doc }
+            file_manager = FileManager.new('tags', :relative)
+            file_manager.save(result.to_yaml)
+          end
+        end
+
+        private
+
+        def generate_tag_file?
+          !@after_schema_data.keys.include?('tags')
+        end
+
+        def push_tags(tag_name)
+          @tags.push(tag_name) unless @tags.include?(tag_name)
+        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_or_not, data_when_verb_or_not|
+              if VERB.include?(verb_or_not)
+                result = group_by_tags_when_verb(verb_or_not, data_when_verb_or_not, path, result)
+              elsif NOT_VERB.include?(verb_or_not)
+                result = group_by_tags_when_not_verb(verb_or_not, data_when_verb_or_not, path, result)
+              else
+                raise "Do not support path item object keys: #{verb_or_not}"
+              end
+            end
+          end
+        end
+
+        def group_by_tags_when_verb(verb, data_when_verb, path, result)
+          if !data_when_verb.is_a?(Array) && data_when_verb.key?('tags')
+            tag_name = data_when_verb['tags'].first
+          else
+            tag_name = 'unknown'
+            data_when_verb.deep_merge!(
+              'tags' => [tag_name]
+            )
+          end
+
+          push_tags(tag_name)
+
+          result[tag_name] ||= {}
+          result[tag_name].deep_merge!(
+            'paths' => {
+              path => {
+                verb => data_when_verb
+              }
+            }
+          )
+          result
+        end
+
+        # The following pseudo tag names are after reservation
+        # ・$ref
+        # ・summary
+        # ・description
+        # ・servers
+        # ・parameters
+        def group_by_tags_when_not_verb(not_verb, data_when_not_verb, path, result)
+          tag_name = not_verb
+
+          push_tags(tag_name)
+
+          result[tag_name] ||= {}
+          result[tag_name].deep_merge!(
+            'paths' => {
+              path => {
+                not_verb => data_when_not_verb
+              }
+            }
+          )
+          result
+        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