swgr2rb 1.0.0

data/lib/endpoint_class_generator/ruby_file_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'ruby_file_generator_constants'
+
+module Swgr2rb
+  # RubyFileGenerator is meant to be used as an abstract class
+  # to be inherited from. It contains methods that create a Ruby file
+  # and write to it the return value of generate_lines method.
+  # The method is implemented in its child classes, EndpointClassGenerator
+  # and SchemaModuleGenerator.
+  class RubyFileGenerator
+    include RubyFileGeneratorConstants
+
+    # opts can include:
+    #   name: class/module name
+    #   rewrite: if set to true, rewrite the existing file if it already exists
+    #   target_dir: directory where the class/module will be created
+    #   update_only: if set to true, do not create new file,
+    #                only update existing
+    def initialize(class_config, opts)
+      @config = class_config
+      @opts = opts
+    end
+
+    def generate_file
+      if (File.exist?(filename) && !@opts[:rewrite]) ||
+         (!File.exist?(filename) && @opts[:update_only])
+        return
+      end
+
+      File.open(filename, 'w') do |file|
+        file.write(generate_lines.join("\n"))
+      end
+    end
+
+    private
+
+    def filename
+      unless @filename
+        create_target_dir(@opts[:target_dir])
+        @filename = File.join(@opts[:target_dir],
+                              "#{RubyFileGeneratorConstants::CAMEL_CASE_TO_SNAKE_CASE.call(@opts[:name])}.rb")
+      end
+      @filename
+    end
+
+    def create_target_dir(dir_str)
+      FileUtils.mkdir_p(dir_str) unless Dir.exist?(dir_str)
+    end
+  end
+end

data/lib/endpoint_class_generator/ruby_file_generator_constants.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../prototypes/json_schema_data_types'
+
+module Swgr2rb
+  module RubyFileGeneratorConstants
+    REQUIRES = proc do |required|
+      required.map { |hsh| "require_relative '#{hsh[:path]}'" }.join("\n") + "\n"
+    end
+
+    CLASS_NAME = proc do |class_name, parent_class_name|
+      "class #{class_name}#{parent_class_name ? " < #{parent_class_name}" : ''}"
+    end
+    MODULE_NAME = proc { |module_name| "module #{module_name}" }
+
+    INCLUDES = proc do |modules|
+      modules.map { |hsh| "include #{hsh[:name]}" }.join("\n") + "\n"
+    end
+
+    INITIALIZE = proc do |endpoint_path, supported_requests|
+      ['def initialize',
+       "  @end_point_path = #{endpoint_path}",
+       "  @supportable_request_types = %w[#{supported_requests}]",
+       'end']
+    end
+
+    VALIDATE_RESPONSE_SCHEMA = proc do |schema_validation|
+      ['def validate_response_schema',
+       '  validate_response_code',
+       schema_validation,
+       'end'].compact.flatten
+    end
+
+    END_POINT_PATH = proc do |params, param_loading|
+      ['def end_point_path',
+       param_loading,
+       "  @end_point_path.call#{params.empty? ? '' : "(#{params.sort.join(', ')})"}",
+       'end'].compact.flatten
+    end
+
+    GENERATE_HEADERS = proc do |request_type|
+      if request_type == :multipart_post
+        ['def generate_headers',
+         "  { 'Content-Type': 'multipart/form-data' }",
+         'end']
+      end
+    end
+
+    GENERATE_BODY = proc do |body|
+      ['def generate_body',
+       (body || 'nil'),
+       'end'].flatten
+    end
+
+    GET_PARAM_FROM_REQUEST_OPTIONS = proc do |param|
+      "#{param} = request_options[:params]['#{param}'] if request_options[:params] && request_options[:params]['#{param}']"
+    end
+    COMMENT_ADD_SUB_RESULTS = '# TODO: Consider adding ability to load params from request_options[:sub_results]'
+    RAISE_UNLESS_PARAMS_PASSED = proc do |params, endpoint_path|
+      ["unless #{params.join(' && ')}",
+       '  raise "Harness error\n"\\',
+       "        'The #{endpoint_path} '\\",
+       "        'requires #{params.join(', ')} parameter#{params.size > 1 ? 's' : ''}'",
+       'end']
+    end
+
+    JSON_VALIDATOR_VALIDATE_SCHEMA = 'JsonValidator.validate(expected_schema, response.body)'
+
+    COMMENT_SET_VALID_VALUES = '# TODO: Set meaningful default values in tmp'
+    GET_PARAM_FROM_REQUEST_PARAMS = proc do |name, type|
+      name = CAMEL_CASE_TO_SNAKE_CASE.call(name)
+      "request_options[:params]['#{name}'] if request_options[:params]"\
+      "#{(type == Boolean ? "&.key?('#{name}')" : " && request_options[:params]['#{name}']")}"
+    end
+    MULTIPART_REQUEST_BODY = ['# TODO: Add valid default file path',
+                              "file_path = 'misc/default_file_path'",
+                              "file_path = request_options[:params]['file_path'] if request_options[:params] && request_options[:params]['file_path']",
+                              '{ filePath: file_path }'].freeze
+
+    EXPECTED_CODE = proc do |code|
+      ['def expected_code',
+       code.to_s,
+       'end']
+    end
+
+    EXPECTED_SCHEMA = proc do |schema|
+      ['def expected_schema',
+       schema,
+       'end'].flatten
+    end
+
+    # Helper constants
+
+    CAMEL_CASE_TO_SNAKE_CASE = proc do |str|
+      str.to_s.split(/([[:upper:]][[:lower:]]+)/)
+         .select(&:present?)
+         .map(&:downcase)
+         .join('_')
+         .gsub(/_+/, '_')
+    end
+
+    SNAKE_CASE_TO_CAMEL_CASE = proc do |str|
+      str.to_s.split('_').map(&:capitalize).join
+    end
+  end
+end

data/lib/endpoint_class_generator/schema_module_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'ruby_file_generator'
+require_relative '../prototypes/json_schema_data_types'
+
+module Swgr2rb
+  # SchemaModuleGenerator generates a Ruby module file
+  # for an endpoint object model schema from its config.
+  class SchemaModuleGenerator < RubyFileGenerator
+    def generate_lines
+      [generate_module_name,
+       generate_expected_code_method,
+       generate_expected_schema_method,
+       'end'].compact.flatten
+    end
+
+    private
+
+    def generate_module_name
+      RubyFileGeneratorConstants::MODULE_NAME.call(@opts[:name])
+    end
+
+    def generate_expected_code_method
+      RubyFileGeneratorConstants::EXPECTED_CODE.call(@config.expected_response.code)
+    end
+
+    def generate_expected_schema_method
+      return unless @config.expected_response.schema.present?
+
+      RubyFileGeneratorConstants::EXPECTED_SCHEMA.call(generate_expected_schema(@config.expected_response.schema))
+    end
+
+    def generate_expected_schema(response_schema)
+      if response_schema.instance_of?(Class) || response_schema == Boolean
+        response_schema.to_s.sub(/^.*::/, '')
+      elsif response_schema.is_a?(Array)
+        "[\n" + generate_expected_schema(response_schema.first) + "\n]"
+      elsif response_schema.is_a?(Hash)
+        "{\n" + generate_hash_schema(response_schema) + "\n}"
+      end
+    end
+
+    def generate_hash_schema(response_schema)
+      response_schema.map do |name, type|
+        "#{name}: #{generate_expected_schema(type)},"
+      end.join("\n").sub(/,\Z/, '')
+    end
+  end
+end

data/lib/json_fetcher/swagger_json_fetcher.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../request_sender/conductor_sender'
+require_relative '../request_sender/request'
+
+module Swgr2rb
+  # SwaggerJsonFetcher fetches a Swagger JSON given its path.
+  # Since the path can either be a URL of Swagger or a path
+  # to a .json file, SwaggerJsonFetcher either makes a GET request
+  # to the given URL and returns its response, or reads and parses
+  # a specified .json file.
+  class SwaggerJsonFetcher
+    class << self
+      def get_swagger_json(path)
+        if URI.extract(path).present?
+          send_request_to_swagger(path)
+        else
+          read_file(path)
+        end
+      end
+
+      private
+
+      def send_request_to_swagger(endpoint_path)
+        request = generate_request_to_swagger(endpoint_path)
+        response = ConductorSender.send_request(request)
+        response.body
+      end
+
+      def read_file(file_path)
+        JSON.parse(File.read(file_path))
+      rescue IOError, JSON::ParserError
+        raise Swgr2rbError,
+              "An error occurred while trying to read JSON file '#{file_path}'"
+      end
+
+      def generate_request_to_swagger(endpoint_path)
+        Request.new(endpoint_path,
+                    'get',
+                    nil,
+                    nil)
+      end
+    end
+  end
+end

data/lib/prototypes/json_schema_data_types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Swgr2rb
+  # Boolean module is included in TrueClass and FalseClass
+  # so that it can be used as a type when dealing with JSON schemas
+  module Boolean; end
+end
+# rubocop:disable Style/Documentation
+class TrueClass; include Swgr2rb::Boolean; end
+class FalseClass; include Swgr2rb::Boolean; end
+# rubocop:enable Style/Documentation

data/lib/prototypes/swgr2rb_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Swgr2rb
+  # Swgr2rbError is a custom error that is raised when
+  # an error occurs that requires a change in user input.
+  # It is intercepted in bin/swgr2rb so that its backtrace
+  # is not returned to the user.
+  class Swgr2rbError < RuntimeError
+    def initialize(msg = nil)
+      super("#{msg}\nTry 'swgr2rb --help' for more information")
+    end
+  end
+end

data/lib/request_sender/conductor_sender.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require_relative 'response'
+
+module Swgr2rb
+  # ConductorSender uses HTTParty to send API requests
+  # with given properties.
+  class ConductorSender
+    class << self
+      def send_request(request)
+        response = send("send_#{request.type}_request",
+                        request)
+
+        Response.new(response)
+      end
+
+      private
+
+      def send_get_request(request)
+        HTTParty.get(request.url,
+                     query: request.body,
+                     headers: request.headers,
+                     verify: false)
+      end
+    end
+  end
+end

data/lib/request_sender/request.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Swgr2rb
+  # Request contains all parameters necessary for making an API request.
+  # Its instances are being passed to ConductorSender.send_request.
+  class Request
+    attr_reader :type, :headers, :body, :subdomain, :endpoint_name
+
+    def initialize(endpoint_name, type, headers, body)
+      @endpoint_name = endpoint_name
+      @type = type
+      @headers = headers
+      @body = body
+      process_request_type
+    end
+
+    def url
+      generate_url
+    end
+
+    private
+
+    def process_request_type
+      @type = type.split(' ').join('_') if type.split(' ').length > 1
+    end
+
+    def generate_url
+      "https://#{endpoint_name}"
+    end
+  end
+end

data/lib/request_sender/response.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Swgr2rb
+  # Response parses API response.
+  class Response
+    attr_accessor :code, :headers, :body
+
+    def initialize(response)
+      @response = response
+      check_response
+    end
+
+    private
+
+    def check_response
+      if @response.is_a?(String)
+        return if try_to_parse_json_from_string
+      end
+
+      if @response.nil? || (@response.respond_to?(:body) &&
+          %w[null true false].include?(@response.body))
+        handle_nil_response
+      else
+        handle_response
+      end
+    end
+
+    def try_to_parse_json_from_string
+      resp_hash = JSON.parse(@response)
+      return unless resp_hash
+
+      @code = 200
+      @headers = ''
+      @body = convert_hash(resp_hash)
+    rescue StandardError
+      raise Swgr2rbError,
+            'An error occurred while trying to parse JSON from API response'
+    end
+
+    def convert_hash(base_hash)
+      return base_hash unless base_hash.is_a? Hash
+
+      temp_hash = base_hash.dup
+      base_hash.each do |k, v|
+        temp_hash = convert_key_value_pair(temp_hash, k, v)
+      end
+      temp_hash
+    end
+
+    def convert_key_value_pair(dest, key, value)
+      case value
+      when Hash
+        dest[key.to_sym] = convert_hash(value)
+      when Array
+        dest[key.to_sym] = value.map { |v| convert_hash(v) }
+      else
+        dest = dest.transform_keys(&:to_sym)
+      end
+      dest
+    end
+
+    def handle_nil_response
+      @code = @response.code
+      @headers = @response.headers
+
+      if @code == 204
+        unless @response.body.nil?
+          raise 'Received non-null body in 204 No Content response'
+        end
+
+        @body = nil
+      else
+        parse_body_for_nil_response
+      end
+    end
+
+    def parse_body_for_nil_response
+      case @response.body
+      when 'null', ''
+        @body = {}
+      when 'true'
+        @body = true
+      when 'false'
+        @body = false
+      else
+        raise 'Not implemented behavior for the empty response'
+      end
+    end
+
+    def handle_response
+      @code = @response.code
+      @headers = @response.headers
+      @body = parse_response_body
+    end
+
+    def parse_response_body
+      if @headers&.content_type == 'application/json'
+        parse_json_body
+      else
+        # parsed response is string
+        @response.parsed_response
+      end
+    end
+
+    def parse_json_body
+      if @response.parsed_response.is_a? Array
+        @response.parsed_response.map { |i| convert_hash(i) }
+      elsif @response.parsed_response.is_a? Integer
+        @response.parsed_response
+      else
+        convert_hash(@response.parsed_response)
+      end
+    end
+  end
+end