r2-oas 0.4.0

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module R2OAS
+  module Routing
+    class RequestComponent < BaseComponent
+      def initialize(request, is_route_engine)
+        super()
+        @request = request
+        @is_route_engine = is_route_engine
+      end
+
+      # e.x.) "tasks#index" => "task"
+      # e.x.) "RailsAdmin::Engine" => "rails_amin/engine"
+      def to_tag_name
+        tag_name = if @is_route_engine
+                     @request.gsub('::', '/').underscore
+                   else
+                     @request.split('#').first.singularize
+                   end
+
+        tag_name = tag_name.split('/').last unless use_tag_namespace
+
+        tag_name
+      end
+
+      def to_schema_name
+        if @is_route_engine
+          schema_name = @request.split('::').map(&:camelcase).join(ns_div)
+        else
+          # e.x.) @request = "api/v2/posts#index {:format=>:json}"
+          # e.x.) path = "api/v2/post"
+          path = @request.split('#').first.singularize
+          schema_name = path.split('/').map(&:camelcase).join(ns_div)
+        end
+
+        if use_schema_namespace
+          schema_name_only = schema_name.split(ns_div).last
+          namespace = adjust_namespace(schema_name.split(ns_div)[0..-2].join(ns_div))
+
+          if namespace.present?
+            [namespace, schema_name_only].join(ns_div)
+          else
+            schema_name_only
+          end
+        else
+          schema_name.split(ns_div).last
+        end
+      end
+
+      # e.x.) "tasks#index { :format => ":json" }"
+      def to_format_name
+        result = ''
+        @request.match(/{\:format=>:(?<format_name>.*)}/) do |md|
+          result = md[:format_name] if md[:format_name]
+        end
+        result
+      end
+
+      private
+
+      def adjust_namespace(namespace)
+        case namespace_type
+        when :dot
+          namespace.downcase
+        when :underbar
+          namespace
+        else
+          raise "Do not support #{namespace_type}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_component'
+
+module R2OAS
+  module Routing
+    class VerbComponent < BaseComponent
+      def initialize(verb)
+        super()
+        @verb = verb
+      end
+
+      # e.x.) "" => ["get"]
+      # e.x.) "POST" => ["post"]
+      # e.x.) "GET|POST" => ["get","post"]
+      def verbs
+        (@verb.downcase.presence || 'get').split('|')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative 'adjustor'
+require_relative 'base'
+
+module R2OAS
+  module Routing
+    class Parser
+      # routes should be Rails.application.routes.routes
+      def initialize(routes)
+        @_routes = routes
+        @_engines = {}
+      end
+
+      def routes_data
+        data = []
+        normalized_routes do |route_els|
+          data.push *route_els
+        end
+        data
+      end
+
+      def tags_data
+        data = []
+        normalized_routes do |route_els|
+          route_els.each do |route_el|
+            tag_name = route_el[:data][:tag_name]
+            data.push tag_name unless data.include?(tag_name)
+          end
+        end
+        data
+      end
+
+      def schemas_data
+        data = []
+        normalized_routes do |route_els|
+          route_els.each do |route_el|
+            schema_name = route_el[:data][:schema_name]
+            data.push schema_name unless data.include?(schema_name)
+          end
+        end
+        data
+      end
+
+      private
+
+      attr_accessor :_routes, :_engines
+
+      def normalized_routes(&block)
+        collect_routes(_routes).each_with_object([]) do |route_data, _arr|
+          routes_els = Adjustor.new(route_data).routes_els
+          block.call(routes_els) if block_given?
+        end
+      end
+
+      # copy from:
+      # https://github.com/rails/rails/blob/v4.2.1/actionpack/lib/action_dispatch/routing/inspector.rb#L114-L140
+      # https://github.com/rails/rails/blob/v5.2.3/actionpack/lib/action_dispatch/routing/inspector.rb
+      def collect_routes(routes)
+        result = routes.collect do |route|
+          ActionDispatch::Routing::RouteWrapper.new(route)
+        end.reject(&:internal?).collect do |route|
+          collect_engine_routes(route)
+
+          # delete json_regexp after copy
+          { route: route,
+            name: route.name,
+            verb: route.verb,
+            path: route.path,
+            reqs: route.reqs }
+        end
+
+        # Push Rails Engine Routes Data
+        _engines.each do |_engine_name, engine_route_data|
+          result.push(*engine_route_data)
+        end
+
+        result
+      end
+
+      # copy from:
+      # https://github.com/rails/rails/blob/v4.2.1/actionpack/lib/action_dispatch/routing/inspector.rb#L114-L140
+      def collect_engine_routes(route)
+        name = route.endpoint
+        return unless route.engine?
+        return if _engines[name]
+
+        routes = route.rack_app.routes
+        _engines[name] = collect_routes(routes.routes) if routes.is_a?(ActionDispatch::Routing::RouteSet)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'r2-oas/base'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    class Base < ::R2OAS::Base
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,146 @@
+# frozen_string_literal:true
+
+require 'docker'
+require 'eventmachine'
+require 'watir'
+require 'tempfile'
+require 'fileutils'
+require 'forwardable'
+
+# Can't use ActiveSupport::Autroload
+# ThreadError: can't be called from trap context
+require 'r2-oas/schema/analyzer'
+require_relative 'base'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    class Editor < Base
+      extend Forwardable
+
+      TMP_FILE_NAME = 'edited_schema'
+      ALERT_TEXT = 'Would you like to convert your JSON into YAML?'
+
+      attr_accessor :edited_schema
+
+      def initialize(before_schema_data, options)
+        super(options)
+        @editor = swagger.editor
+        @before_schema_data = before_schema_data
+        @schema_doc_from_local = YAML.load_file(doc_save_file_path).to_yaml
+      end
+
+      def start
+        EM.run do
+          container.start
+          open_browser_and_set_schema
+          ensure_save_tmp_schema_file
+          signal_trap('INT')
+          signal_trap('TERM')
+        end
+      end
+
+      private
+
+      attr_accessor :unit_paths_file_path
+      def_delegators :@editor, :storage_key, :image, :port, :url, :exposed_port
+
+      def signal_trap(command)
+        Signal.trap(command) do
+          if @browser.exists?
+            process_after_close_browser
+            container.stop
+            container.remove
+            logger.info "container id: #{container.id} removed"
+          else
+            process_after_close_browser
+            container.remove
+            logger.info "container id: #{container.id} removed"
+          end
+
+          EM.stop
+        end
+      end
+
+      def process_after_close_browser
+        fetch_edited_schema_from_browser
+
+        options = { type: :edited }
+        save_edited_schema
+        conv_after_schema_data = YAML.load(@after_schema_data)
+        analyzer = Analyzer.new(@before_schema_data, conv_after_schema_data, options)
+        analyzer.analyze_docs
+      end
+
+      # MEMO
+      # TargetRubyVersion is 2.7 and there is a warning
+      # Because it is necessary to support from ruby2.3 series where begin cannot be omitted
+      # rubocop:disable Style/RedundantBegin
+      def ensure_save_tmp_schema_file
+        EM.add_periodic_timer(interval_to_save_edited_tmp_schema) do
+          m = Mutex.new
+          return nil unless @browser.exists?
+
+          m.synchronize do
+            begin
+              save_after_fetch_local_strage
+            rescue Selenium::WebDriver::Error::UnexpectedAlertOpenError
+              alert = @browser.driver.switch_to.alert
+              if alert.text.eql?(ALERT_TEXT)
+                alert.accept && save_after_fetch_local_strage
+              end
+            end
+          end
+        end
+      end
+      # rubocop:enable Style/RedundantBegin
+
+      def save_after_fetch_local_strage
+        @after_schema_data = @browser.driver.local_storage[storage_key] || @after_schema_data
+        save_edited_schema
+        puts "\nwait for signal trap ..."
+      end
+
+      def fetch_edited_schema_from_browser
+        @after_schema_data = @browser.driver.local_storage[storage_key] if @browser.exists?
+      end
+
+      def save_edited_schema
+        File.write(doc_save_file_path, @after_schema_data)
+      end
+
+      def open_browser_and_set_schema
+        capabilities = { 'chromeOptions' => { 'w3c' => false } }
+        @browser ||= Watir::Browser.new(:chrome, capabilities)
+        @browser.goto(url)
+        if wait_for_loaded
+          # MEMO:
+          # Because it may not be updated
+          # Make sure that the launched local storage is updated reliably
+          Watir::Wait.until do
+            old_storage = @browser.driver.local_storage[storage_key].dup
+            @browser.driver.local_storage[storage_key] = new_storage = @schema_doc_from_local
+            old_storage != new_storage
+          end
+          @browser.refresh
+        end
+      end
+
+      def wait_for_loaded
+        Watir::Wait.until { @browser.body.present? }
+      end
+
+      def container
+        @container ||= Docker::Container.create(
+          'Image' => image,
+          'ExposedPorts' => { exposed_port => {} },
+          'HostConfig' => {
+            'PortBindings' => {
+              exposed_port => [{ 'HostPort' => port }]
+            }
+          }
+        )
+      end
+    end
+  end
+end

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
+
+      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