r2-oas 0.1.0

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

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_relative '../base'
+
+# Scope Rails
+module R2OAS
+  module Schema
+    class Base < ::R2OAS::Base
+    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,120 @@
+# frozen_string_literal:true
+
+require 'docker'
+require 'eventmachine'
+require 'watir'
+require 'tempfile'
+require 'fileutils'
+require 'shell'
+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'
+
+      attr_accessor :edited_schema
+
+      def initialize(before_schema_data, options)
+        super(options)
+        @editor = swagger.editor
+        @before_schema_data = before_schema_data
+      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
+
+      def ensure_save_tmp_schema_file
+        EM.add_periodic_timer(interval_to_save_edited_tmp_schema) do
+          if @browser.exists?
+            @after_schema_data = @browser.driver.local_storage[storage_key] || @after_schema_data
+            save_edited_schema
+            puts "\nwait for signal trap ..."
+          end
+        end
+      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
+          schema_doc_from_local = YAML.load_file(doc_save_file_path)
+          @browser.driver.local_storage[storage_key] = schema_doc_from_local.to_yaml
+          @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