clerk-http-client 0.0.1 → 2.0.0.beta1

data/resources/templates/api_client_faraday_partial.mustache

@@ -1,200 +0,0 @@
-    # Call an API with given options.
-    #
-    # @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
-    #   the data deserialized from response body (could be nil), response status code and response headers.
-    def call_api(http_method, path, opts = {})
-      stream = nil
-      begin
-        response = connection(opts).public_send(http_method.to_sym.downcase) do |req|
-          request = build_request(http_method, path, req, opts)
-          stream = download_file(request) if opts[:return_type] == 'File' || opts[:return_type] == 'Binary'
-        end
-
-        if config.debugging
-          config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
-        end
-
-        unless response.success?
-          if response.status == 0 && response.respond_to?(:return_message)
-            # Errors from libcurl will be made visible here
-            fail ApiError.new(code: 0,
-                              message: response.return_message)
-          else
-            fail ApiError.new(code: response.status,
-                              response_headers: response.headers,
-                              response_body: response.body),
-                 response.reason_phrase
-          end
-        end
-      rescue Faraday::TimeoutError
-        fail ApiError.new('Connection timed out')
-      rescue Faraday::ConnectionFailed
-        fail ApiError.new('Connection failed')
-      end
-
-      if opts[:return_type] == 'File' || opts[:return_type] == 'Binary'
-        data = deserialize_file(response, stream)
-      elsif opts[:return_type]
-        data = deserialize(response, opts[:return_type])
-      else
-        data = nil
-      end
-      return data, response.status, response.headers
-    end
-
-    # Builds the HTTP request
-    #
-    # @param [String] http_method HTTP method/verb (e.g. POST)
-    # @param [String] path URL path (e.g. /account/new)
-    # @option opts [Hash] :header_params Header parameters
-    # @option opts [Hash] :query_params Query parameters
-    # @option opts [Hash] :form_params Query parameters
-    # @option opts [Object] :body HTTP body (JSON/XML)
-    # @return [Faraday::Request] A Faraday Request
-    def build_request(http_method, path, request, opts = {})
-      url = build_request_url(path, opts)
-      http_method = http_method.to_sym.downcase
-
-      header_params = @default_headers.merge(opts[:header_params] || {})
-      query_params = opts[:query_params] || {}
-      form_params = opts[:form_params] || {}
-
-      update_params_for_auth! header_params, query_params, opts[:auth_names]
-
-      if [:post, :patch, :put, :delete].include?(http_method)
-        req_body = build_request_body(header_params, form_params, opts[:body])
-        if config.debugging
-          config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
-        end
-      end
-      request.headers = header_params
-      request.body = req_body
-
-      # Overload default options only if provided
-      request.options.params_encoder = config.params_encoder if config.params_encoder
-      request.options.timeout        = config.timeout        if config.timeout
-
-      request.url url
-      request.params = query_params
-      request
-    end
-
-    # Builds the HTTP request body
-    #
-    # @param [Hash] header_params Header parameters
-    # @param [Hash] form_params Query parameters
-    # @param [Object] body HTTP body (JSON/XML)
-    # @return [String] HTTP body data in the form of string
-    def build_request_body(header_params, form_params, body)
-      # http form
-      if header_params['Content-Type'] == 'application/x-www-form-urlencoded'
-        data = URI.encode_www_form(form_params)
-      elsif header_params['Content-Type'] == 'multipart/form-data'
-        data = {}
-        form_params.each do |key, value|
-          case value
-          when ::File, ::Tempfile
-            data[key] = Faraday::FilePart.new(value.path, Marcel::MimeType.for(Pathname.new(value.path)))
-          when ::Array, nil
-            # let Faraday handle Array and nil parameters
-            data[key] = value
-          else
-            data[key] = value.to_s
-          end
-        end
-      elsif body
-        data = body.is_a?(String) ? body : body.to_json
-      else
-        data = nil
-      end
-      data
-    end
-
-    def download_file(request)
-      stream = []
-
-      # handle streaming Responses
-      request.options.on_data = Proc.new do |chunk, overall_received_bytes|
-        stream << chunk
-      end
-
-      stream
-    end
-
-    def deserialize_file(response, stream)
-      body     = response.body
-      encoding = body.encoding
-
-      # reconstruct content
-      content = stream.join
-      content = content.unpack('m').join if response.headers['Content-Transfer-Encoding'] == 'binary'
-      content = content.force_encoding(encoding)
-
-      # return byte stream
-      return content if @config.return_binary_data == true
-
-      # return file instead of binary data
-      content_disposition = response.headers['Content-Disposition']
-      if content_disposition && content_disposition =~ /filename=/i
-        filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
-        prefix = sanitize_filename(filename)
-      else
-        prefix = 'download-'
-      end
-      prefix = prefix + '-' unless prefix.end_with?('-')
-
-      tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
-      tempfile.write(content)
-      tempfile.close
-
-      config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
-                          "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
-                          "will be deleted automatically with GC. It's also recommended to delete the temp file "\
-                          "explicitly with `tempfile.delete`"
-      tempfile
-    end
-
-    def connection(opts)
-      opts[:header_params]['Content-Type'] == 'multipart/form-data' ? connection_multipart : connection_regular
-    end
-
-    def connection_multipart
-      @connection_multipart ||= build_connection do |conn|
-        conn.request :multipart
-        conn.request :url_encoded
-      end
-    end
-
-    def connection_regular
-      @connection_regular ||= build_connection
-    end
-
-    def build_connection
-      Faraday.new(url: config.base_url, ssl: ssl_options, proxy: config.proxy) do |conn|
-        basic_auth(conn)
-        config.configure_middleware(conn)
-        yield(conn) if block_given?
-        conn.adapter(Faraday.default_adapter)
-        config.configure_connection(conn)
-      end
-    end
-
-    def ssl_options
-      {
-        ca_file: config.ssl_ca_file,
-        verify: config.ssl_verify,
-        verify_mode: config.ssl_verify_mode,
-        client_cert: config.ssl_client_cert,
-        client_key: config.ssl_client_key
-      }
-    end
-
-    def basic_auth(conn)
-      if config.username && config.password
-        if Gem::Version.new(Faraday::VERSION) >= Gem::Version.new('2.0')
-          conn.request(:authorization, :basic, config.username, config.password)
-        else
-          conn.request(:basic_auth, config.username, config.password)
-        end
-      end
-    end

data/resources/templates/api_client_httpx_partial.mustache

@@ -1,134 +0,0 @@
-    # Call an API with given options.
-    #
-    # @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
-    #   the data deserialized from response body (could be nil), response status code and response headers.
-    def call_api(http_method, path, opts = {})
-      begin
-        response = build_request(http_method.to_s, path, opts)
-
-        if config.debugging
-          config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
-        end
-
-        response.raise_for_status
-
-      rescue HTTPX::HTTPError
-          fail ApiError.new(code: response.status,
-                response_headers: response.headers.to_h,
-                response_body: response.body.to_s),
-                Net::HTTP::STATUS_CODES.fetch(response.status, "HTTP Error (#{response.status})")
-      rescue HTTPX::TimeoutError
-        fail ApiError.new('Connection timed out')
-      rescue HTTPX::ConnectionError, HTTPX::ResolveError
-        fail ApiError.new('Connection failed')
-      end
-
-      if opts[:return_type] == 'File'
-        data = deserialize_file(response)
-      elsif opts[:return_type]
-        data = deserialize(response, opts[:return_type])
-      else
-        data = nil
-      end
-      return data, response.status, response.headers.to_h
-    end
-
-    # Builds the HTTP request
-    #
-    # @param [String] http_method HTTP method/verb (e.g. POST)
-    # @param [String] path URL path (e.g. /account/new)
-    # @option opts [Hash] :header_params Header parameters
-    # @option opts [Hash] :query_params Query parameters
-    # @option opts [Hash] :form_params Query parameters
-    # @option opts [Object] :body HTTP body (JSON/XML)
-    # @return [HTTPX::Request] A Request object
-    def build_request(http_method, path, opts = {})
-      url = build_request_url(path, opts)
-
-      header_params = @default_headers.merge(opts[:header_params] || {})
-      query_params = opts[:query_params] || {}
-      form_params = opts[:form_params] || {}
-
-      update_params_for_auth! header_params, query_params, opts[:auth_names]
-
-      if %w[POST PATCH PUT DELETE].include?(http_method)
-        body_params = build_request_body(header_params, form_params, opts[:body])
-        if config.debugging
-          config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
-        end
-      end
-      req_opts = {
-        :headers => HTTPX::Headers.new(header_params)
-      }
-      req_opts.merge!(body_params) if body_params
-      req_opts[:params] = query_params if query_params && !query_params.empty?
-      session.request(http_method, url, **req_opts)
-    end
-
-    # Builds the HTTP request body
-    #
-    # @param [Hash] header_params Header parameters
-    # @param [Hash] form_params Query parameters
-    # @param [Object] body HTTP body (JSON/XML)
-    # @return [Hash{Symbol => Object}] body options as HTTPX handles them
-    def build_request_body(header_params, form_params, body)
-      # http form
-      if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
-         header_params['Content-Type'] == 'multipart/form-data'
-        header_params.delete('Content-Type') # httpx takes care of this
-        { form: form_params }
-      elsif body
-        body.is_a?(String) ? { body: body } : { json: body }
-      end
-    end
-
-    def deserialize_file(response)
-      body = response.body
-      if @config.return_binary_data == true
-        # TODO: force response encoding
-        body.to_s
-      else
-        content_disposition = response.headers['content-disposition']
-        if content_disposition && content_disposition =~ /filename=/i
-          filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
-          prefix = sanitize_filename(filename)
-        else
-          prefix = 'download-'
-        end
-        prefix = prefix + '-' unless prefix.end_with?('-')
-        encoding = response.body.encoding
-        tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
-        response.copy_to(tempfile)
-        tempfile.close
-        @config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
-                            "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
-                            "will be deleted automatically with GC. It's also recommended to delete the temp file "\
-                            "explicitly with `tempfile.delete`"
-
-        tempfile
-      end
-    end
-
-    def session
-      return @session if defined?(@session)
-
-      session = HTTPX.with(
-        ssl: @config.ssl,
-        timeout: ({ request_timeout: @config.timeout } if @config.timeout && @config.timeout.positive?),
-        origin: "#{@config.scheme}://#{@config.host}",
-        base_path: (@config.base_path.sub(/\/+\z/, '') if @config.base_path)
-      )
-
-      if @config.proxy
-        session = session.plugin(:proxy, proxy: @config.proxy)
-      end
-
-      if @config.username && @config.password
-        session = session.plugin(:basic_auth).basic_auth(@config.username, @config.password)
-      end
-
-      session = @config.configure(session)
-
-      @session = session
-
-    end

data/resources/templates/api_client_typhoeus_partial.mustache

@@ -1,161 +0,0 @@
-    # Call an API with given options.
-    #
-    # @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
-    #   the data deserialized from response body (may be a Tempfile or nil), response status code and response headers.
-    def call_api(http_method, path, opts = {})
-      request = build_request(http_method, path, opts)
-      tempfile = download_file(request) if opts[:return_type] == 'File'
-      response = request.run
-
-      if @config.debugging
-        @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
-      end
-
-      unless response.success?
-        if response.timed_out?
-          fail ApiError.new('Connection timed out')
-        elsif response.code == 0
-          # Errors from libcurl will be made visible here
-          fail ApiError.new(:code => 0,
-                            :message => response.return_message)
-        else
-          fail ApiError.new(:code => response.code,
-                            :response_headers => response.headers,
-                            :response_body => response.body),
-               response.status_message
-        end
-      end
-
-      if opts[:return_type] == 'File'
-        data = tempfile
-      elsif opts[:return_type]
-        data = deserialize(response, opts[:return_type])
-      else
-        data = nil
-      end
-      return data, response.code, response.headers
-    end
-
-    # Builds the HTTP request
-    #
-    # @param [String] http_method HTTP method/verb (e.g. POST)
-    # @param [String] path URL path (e.g. /account/new)
-    # @option opts [Hash] :header_params Header parameters
-    # @option opts [Hash] :query_params Query parameters
-    # @option opts [Hash] :form_params Query parameters
-    # @option opts [Object] :body HTTP body (JSON/XML)
-    # @return [Typhoeus::Request] A Typhoeus Request
-    def build_request(http_method, path, opts = {})
-      url = build_request_url(path, opts)
-      http_method = http_method.to_sym.downcase
-
-      header_params = @default_headers.merge(opts[:header_params] || {})
-      query_params = opts[:query_params] || {}
-      form_params = opts[:form_params] || {}
-      follow_location = opts[:follow_location] || true
-
-      {{#hasAuthMethods}}
-      update_params_for_auth! header_params, query_params, opts[:auth_names]
-      {{/hasAuthMethods}}
-
-      # set ssl_verifyhosts option based on @config.verify_ssl_host (true/false)
-      _verify_ssl_host = @config.verify_ssl_host ? 2 : 0
-
-      req_opts = {
-        :method => http_method,
-        :headers => header_params,
-        :params => query_params,
-        :params_encoding => @config.params_encoding,
-        :timeout => @config.timeout,
-        :ssl_verifypeer => @config.verify_ssl,
-        :ssl_verifyhost => _verify_ssl_host,
-        :sslcert => @config.cert_file,
-        :sslkey => @config.key_file,
-        :verbose => @config.debugging,
-        :followlocation => follow_location
-      }
-
-      # set custom cert, if provided
-      req_opts[:cainfo] = @config.ssl_ca_cert if @config.ssl_ca_cert
-
-      if [:post, :patch, :put, :delete].include?(http_method)
-        req_body = build_request_body(header_params, form_params, opts[:body])
-        req_opts.update :body => req_body
-        if @config.debugging
-          @config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
-        end
-      end
-
-      Typhoeus::Request.new(url, req_opts)
-    end
-
-    # Builds the HTTP request body
-    #
-    # @param [Hash] header_params Header parameters
-    # @param [Hash] form_params Query parameters
-    # @param [Object] body HTTP body (JSON/XML)
-    # @return [String] HTTP body data in the form of string
-    def build_request_body(header_params, form_params, body)
-      # http form
-      if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
-          header_params['Content-Type'] == 'multipart/form-data'
-        data = {}
-        form_params.each do |key, value|
-          case value
-          when ::File, ::Array, nil
-            # let typhoeus handle File, Array and nil parameters
-            data[key] = value
-          else
-            data[key] = value.to_s
-          end
-        end
-      elsif body
-        data = body.is_a?(String) ? body : body.to_json
-      else
-        data = nil
-      end
-      data
-    end
-
-    # Save response body into a file in (the defined) temporary folder, using the filename
-    # from the "Content-Disposition" header if provided, otherwise a random filename.
-    # The response body is written to the file in chunks in order to handle files which
-    # size is larger than maximum Ruby String or even larger than the maximum memory a Ruby
-    # process can use.
-    #
-    # @see Configuration#temp_folder_path
-    #
-    # @return [Tempfile] the tempfile generated
-    def download_file(request)
-      tempfile = nil
-      encoding = nil
-      request.on_headers do |response|
-        content_disposition = response.headers['Content-Disposition']
-        if content_disposition && content_disposition =~ /filename=/i
-          filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
-          prefix = sanitize_filename(filename)
-        else
-          prefix = 'download-'
-        end
-        prefix = prefix + '-' unless prefix.end_with?('-')
-        encoding = response.body.encoding
-        tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
-      end
-      request.on_body do |chunk|
-        chunk.force_encoding(encoding)
-        tempfile.write(chunk)
-      end
-      # run the request to ensure the tempfile is created successfully before returning it
-      request.run
-      if tempfile
-        tempfile.close
-        @config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
-                            "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
-                            "will be deleted automatically with GC. It's also recommended to delete the temp file "\
-                            "explicitly with `tempfile.delete`"
-      else
-        fail ApiError.new("Failed to create the tempfile based on the HTTP response from the server: #{request.inspect}") 
-      end
-
-      tempfile
-    end

data/resources/templates/api_doc.mustache

@@ -1,132 +0,0 @@
-# {{moduleName}}::{{classname}}{{#description}}
-
-{{.}}{{/description}}
-
-All URIs are relative to *{{basePath}}*
-
-| Method | HTTP request | Description |
-| ------ | ------------ | ----------- |
-{{#operations}}
-{{#operation}}
-| [**{{operationId}}**]({{classname}}.md#{{operationId}}) | **{{httpMethod}}** {{path}} | {{summary}} |
-{{/operation}}
-{{/operations}}
-
-{{#operations}}
-{{#operation}}
-
-## {{operationId}}
-
-> {{#returnType}}{{#returnTypeIsPrimitive}}{{returnType}}{{/returnTypeIsPrimitive}}{{^returnTypeIsPrimitive}}<{{{returnType}}}>{{/returnTypeIsPrimitive}} {{/returnType}}{{operationId}}{{#hasParams}}({{^vendorExtensions.x-group-parameters}}{{#requiredParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/requiredParams}}{{#optionalParams}}{{#-last}}{{#hasRequiredParams}}, {{/hasRequiredParams}}opts{{/-last}}{{/optionalParams}}{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}opts{{/vendorExtensions.x-group-parameters}}){{/hasParams}}
-
-{{{summary}}}{{#notes}}
-
-{{{.}}}{{/notes}}
-
-### Examples
-
-```ruby
-require 'time'
-require '{{{gemName}}}'
-{{#hasAuthMethods}}
-# setup authorization
-{{{moduleName}}}.configure do |config|{{#authMethods}}{{#isBasic}}{{#isBasicBasic}}
-  # Configure HTTP basic authorization: {{{name}}}
-  config.username = 'YOUR USERNAME'
-  config.password = 'YOUR PASSWORD'{{/isBasicBasic}}{{#isBasicBearer}}
-  # Configure Bearer authorization{{#bearerFormat}} ({{{.}}}){{/bearerFormat}}: {{{name}}}
-  config.access_token = 'YOUR_BEARER_TOKEN'{{/isBasicBearer}}{{/isBasic}}{{#isApiKey}}
-  # Configure API key authorization: {{{name}}}
-  config.api_key['{{{keyParamName}}}'] = 'YOUR API KEY'
-  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
-  # config.api_key_prefix['{{{keyParamName}}}'] = 'Bearer'{{/isApiKey}}{{#isOAuth}}
-  # Configure OAuth2 access token for authorization: {{{name}}}
-  config.access_token = 'YOUR ACCESS TOKEN'{{/isOAuth}}
-{{/authMethods}}end
-{{/hasAuthMethods}}
-
-api_instance = {{{moduleName}}}::{{{classname}}}.new
-{{^vendorExtensions.x-group-parameters}}
-{{#requiredParams}}
-{{{paramName}}} = {{{vendorExtensions.x-ruby-example}}} # {{{dataType}}} | {{{description}}}
-{{/requiredParams}}
-{{#optionalParams}}
-{{#-first}}
-opts = {
-{{/-first}}
-  {{{paramName}}}: {{{vendorExtensions.x-ruby-example}}}{{^-last}},{{/-last}} # {{{dataType}}} | {{{description}}}
-{{#-last}}
-}
-{{/-last}}
-{{/optionalParams}}
-{{/vendorExtensions.x-group-parameters}}
-{{#vendorExtensions.x-group-parameters}}
-{{#hasParams}}
-opts = {
-{{#requiredParams}}
-    {{{paramName}}}: {{{vendorExtensions.x-ruby-example}}}, # {{{dataType}}} | {{{description}}} (required)
-{{/requiredParams}}
-{{#optionalParams}}
-    {{{paramName}}}: {{{vendorExtensions.x-ruby-example}}}, # {{{dataType}}} | {{{description}}}
-{{/optionalParams}}
-}
-{{/hasParams}}
-{{/vendorExtensions.x-group-parameters}}
-
-begin
-  {{#summary}}# {{{.}}}{{/summary}}
-  {{#returnType}}result = {{/returnType}}api_instance.{{{operationId}}}{{#hasParams}}({{^vendorExtensions.x-group-parameters}}{{#requiredParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/requiredParams}}{{#optionalParams}}{{#-last}}{{#hasRequiredParams}}, {{/hasRequiredParams}}opts{{/-last}}{{/optionalParams}}{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}opts{{/vendorExtensions.x-group-parameters}}){{/hasParams}}
-  {{#returnType}}
-  p result
-  {{/returnType}}
-rescue {{{moduleName}}}::ApiError => e
-  puts "Error when calling {{classname}}->{{{operationId}}}: #{e}"
-end
-```
-
-#### Using the {{operationId}}_with_http_info variant
-
-This returns an Array which contains the response data{{^returnType}} (`nil` in this case){{/returnType}}, status code and headers.
-
-> <Array({{#returnType}}{{#returnTypeIsPrimitive}}{{returnType}}{{/returnTypeIsPrimitive}}{{^returnTypeIsPrimitive}}<{{{returnType}}}>{{/returnTypeIsPrimitive}}{{/returnType}}{{^returnType}}nil{{/returnType}}, Integer, Hash)> {{operationId}}_with_http_info{{#hasParams}}({{^vendorExtensions.x-group-parameters}}{{#requiredParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/requiredParams}}{{#optionalParams}}{{#-last}}{{#hasRequiredParams}}, {{/hasRequiredParams}}opts{{/-last}}{{/optionalParams}}{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}opts{{/vendorExtensions.x-group-parameters}}){{/hasParams}}
-
-```ruby
-begin
-  {{#summary}}# {{{.}}}{{/summary}}
-  data, status_code, headers = api_instance.{{{operationId}}}_with_http_info{{#hasParams}}({{^vendorExtensions.x-group-parameters}}{{#requiredParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/requiredParams}}{{#optionalParams}}{{#-last}}{{#hasRequiredParams}}, {{/hasRequiredParams}}opts{{/-last}}{{/optionalParams}}{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}opts{{/vendorExtensions.x-group-parameters}}){{/hasParams}}
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => {{#returnType}}{{#returnTypeIsPrimitive}}{{returnType}}{{/returnTypeIsPrimitive}}{{^returnTypeIsPrimitive}}<{{{returnType}}}>{{/returnTypeIsPrimitive}}{{/returnType}}{{^returnType}}nil{{/returnType}}
-rescue {{{moduleName}}}::ApiError => e
-  puts "Error when calling {{classname}}->{{{operationId}}}_with_http_info: #{e}"
-end
-```
-
-### Parameters
-
-{{^allParams}}
-This endpoint does not need any parameter.
-{{/allParams}}
-{{#allParams}}
-{{#-first}}
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-{{/-first}}
-| **{{paramName}}** | {{#isPrimitiveType}}**{{dataType}}**{{/isPrimitiveType}}{{^isPrimitiveType}}{{#isFile}}**{{dataType}}**{{/isFile}}{{^isFile}}[**{{dataType}}**]({{baseType}}.md){{/isFile}}{{/isPrimitiveType}} | {{description}} | {{^required}}[optional]{{/required}}{{#defaultValue}}[default to {{.}}]{{/defaultValue}} |
-{{/allParams}}
-
-### Return type
-
-{{#returnType}}{{#returnTypeIsPrimitive}}**{{returnType}}**{{/returnTypeIsPrimitive}}{{^returnTypeIsPrimitive}}[**{{returnType}}**]({{returnBaseType}}.md){{/returnTypeIsPrimitive}}{{/returnType}}{{^returnType}}nil (empty response body){{/returnType}}
-
-### Authorization
-
-{{^authMethods}}No authorization required{{/authMethods}}{{#authMethods}}[{{name}}](../README.md#{{name}}){{^-last}}, {{/-last}}{{/authMethods}}
-
-### HTTP request headers
-
-- **Content-Type**: {{#consumes}}{{{mediaType}}}{{^-last}}, {{/-last}}{{/consumes}}{{^consumes}}Not defined{{/consumes}}
-- **Accept**: {{#produces}}{{{mediaType}}}{{^-last}}, {{/-last}}{{/produces}}{{^produces}}Not defined{{/produces}}
-
-{{/operation}}
-{{/operations}}

data/resources/templates/api_error.mustache

@@ -1,50 +0,0 @@
-=begin
-{{> api_info}}
-=end
-
-module {{moduleName}}
-  class ApiError < StandardError
-    attr_reader :code, :response_headers, :response_body
-
-    # Usage examples:
-    #   ApiError.new
-    #   ApiError.new("message")
-    #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
-    #   ApiError.new(:code => 404, :message => "Not Found")
-    def initialize(arg = nil)
-      if arg.is_a? Hash
-        if arg.key?(:message) || arg.key?('message')
-          super(arg[:message] || arg['message'])
-        else
-          super arg
-        end
-
-        arg.each do |k, v|
-          instance_variable_set "@#{k}", v
-        end
-      else
-        super arg
-        @message = arg
-      end
-    end
-
-    # Override to_s to display a friendly error message
-    def to_s
-      message
-    end
-
-    def message
-      if @message.nil?
-        msg = "Error message: the server returns an error"
-      else
-        msg = @message
-      end
-
-      msg += "\nHTTP status code: #{code}" if code
-      msg += "\nResponse headers: #{response_headers}" if response_headers
-      msg += "\nResponse body: #{response_body}" if response_body
-
-      msg
-    end
-  end
-end

data/resources/templates/api_info.mustache

@@ -1,12 +0,0 @@
-{{#appName}}
-#{{{.}}}
-
-{{/appName}}
-{{#appDescription}}
-#{{{.}}}
-
-{{/appDescription}}
-{{#version}}The version of the OpenAPI document: {{.}}{{/version}}
-{{#infoEmail}}Contact: {{{.}}}{{/infoEmail}}
-Generated by: https://openapi-generator.tech
-Generator version: {{{generatorVersion}}}