Ruby: move request/response logic to api_client

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/RubyClientCodegen.java

@@ -109,8 +109,6 @@ public void processOpts() {
  supportingFiles.add(new SupportingFile("gem.mustache", libFolder, gemName + ".rb"));
  String gemFolder = libFolder + File.separator + gemName;
  supportingFiles.add(new SupportingFile("api_client.mustache", gemFolder, "api_client.rb"));
- supportingFiles.add(new SupportingFile("request.mustache", gemFolder, "request.rb"));
- supportingFiles.add(new SupportingFile("response.mustache", gemFolder, "response.rb"));
  supportingFiles.add(new SupportingFile("api_error.mustache", gemFolder, "api_error.rb"));
  supportingFiles.add(new SupportingFile("version.mustache", gemFolder, "version.rb"));
  String modelFolder = gemFolder + File.separator + modelPackage.replace("/", File.separator);

modules/swagger-codegen/src/main/resources/ruby/api.mustache

@@ -45,11 +45,11 @@ module {{moduleName}}
 
  # HTTP header 'Accept' (if needed)
  _header_accept = [{{#produces}}'{{mediaType}}'{{#hasMore}}, {{/hasMore}}{{/produces}}]
- _header_accept_result = Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+ _header_accept_result = @api_client.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
 
  # HTTP header 'Content-Type'
  _header_content_type = [{{#consumes}}'{{mediaType}}'{{#hasMore}}, {{/hasMore}}{{/consumes}}]
- header_params['Content-Type'] = Request.select_header_content_type(_header_content_type){{#headerParams}}{{#required}}
+ header_params['Content-Type'] = @api_client.select_header_content_type(_header_content_type){{#headerParams}}{{#required}}
  header_params[:'{{{baseName}}}'] = {{{paramName}}}{{/required}}{{/headerParams}}{{#headerParams}}{{^required}}
  header_params[:'{{{baseName}}}'] = opts[:'{{{paramName}}}'] if opts[:'{{{paramName}}}']{{/required}}{{/headerParams}}
 
@@ -60,20 +60,30 @@ module {{moduleName}}
 
  # http body (model)
  {{^bodyParam}}post_body = nil
- {{/bodyParam}}{{#bodyParam}}post_body = Request.object_to_http_body({{#required}}{{{paramName}}}{{/required}}{{^required}}opts[:'{{{paramName}}}']{{/required}})
+ {{/bodyParam}}{{#bodyParam}}post_body = @api_client.object_to_http_body({{#required}}{{{paramName}}}{{/required}}{{^required}}opts[:'{{{paramName}}}']{{/required}})
  {{/bodyParam}}
 
  auth_names = [{{#authMethods}}'{{name}}'{{#hasMore}}, {{/hasMore}}{{/authMethods}}]
- {{#returnType}}response = Request.new(@api_client, :{{httpMethod}}, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
- result = response.deserialize('{{{returnType}}}')
+ {{#returnType}}result = @api_client.call_api(:{{httpMethod}}, path,
+ :header_params => header_params,
+ :query_params => query_params,
+ :form_params => form_params,
+ :body => post_body,
+ :auth_names => auth_names,
+ :return_type => '{{{returnType}}}')
  if @api_client.debugging
  @api_client.logger.debug "API called: {{classname}}#{{nickname}}. Result: #{result.inspect}"
  end
- result{{/returnType}}{{^returnType}}Request.new(@api_client, :{{httpMethod}}, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+ return result{{/returnType}}{{^returnType}}@api_client.call_api(:{{httpMethod}}, path,
+ :header_params => header_params,
+ :query_params => query_params,
+ :form_params => form_params,
+ :body => post_body,
+ :auth_names => auth_names)
  if @api_client.debugging
  @api_client.logger.debug "API called: {{classname}}#{{nickname}}"
  end
- nil{{/returnType}}
+ return nil{{/returnType}}
  end
 {{/operation}}
  end

modules/swagger-codegen/src/main/resources/ruby/api_client.mustache

@@ -1,9 +1,13 @@
-require 'logger'
+require 'date'
 require 'json'
+require 'logger'
+require 'tempfile'
+require 'typhoeus'
+require 'uri'
 
 module {{moduleName}}
  class ApiClient
- attr_accessor :scheme, :host, :base_path, :user_agent, :format, :auth_token, :inject_format, :force_ending_format
+ attr_accessor :scheme, :host, :base_path, :user_agent
 
  # Defines the username used with HTTP basic authentication.
  #
@@ -82,7 +86,6 @@ module {{moduleName}}
  # client.api_key['api_key'] = 'your key' # api key authentication
  # client.username = 'your username' # username for http basic authentication
  # client.password = 'your password' # password for http basic authentication
- # client.format = 'json' # optional, defaults to 'json'
  # end
  def initialize(&block)
  @format = 'json'
@@ -131,9 +134,255 @@ module {{moduleName}}
  @base_path = "" if @base_path == "/"
  end
 
+ def call_api(http_method, path, opts = {})
+ request = build_request(http_method, path, opts)
+ response = request.run
+
+ # record as last response
+ @last_response = response
+
+ if debugging
+ logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
+ end
+
+ unless response.success?
+ fail ApiError.new(:code => response.code,
+ :response_headers => response.headers,
+ :response_body => response.body),
+ response.status_message
+ end
+
+ if opts[:return_type]
+ return deserialize(response, opts[:return_type])
+ else
+ return nil
+ end
+ end
+
+ def build_request(http_method, path, opts = {})
+ url = build_request_url(path)
+ 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] || {}
+
+ {{#hasAuthMethods}}
+ update_params_for_auth! header_params, query_params, opts[:auth_names]
+ {{/hasAuthMethods}}
+
+ req_opts = {
+ :method => http_method,
+ :headers => header_params,
+ :params => query_params,
+ :ssl_verifypeer => @verify_ssl,
+ :cainfo => @ssl_ca_cert,
+ :verbose => @debugging
+ }
+
+ 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 debugging
+ logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
+ end
+ end
+
+ Typhoeus::Request.new(url, req_opts)
+ end
+
+ # Deserialize the response to the given return type.
+ #
+ # @param [String] return_type some examples: "User", "Array[User]", "Hash[String,Integer]"
+ def deserialize(response, return_type)
+ body = response.body
+ return nil if body.nil? || body.empty?
+
+ # handle file downloading - save response body into a tmp file and return the File instance
+ return download_file(response) if return_type == 'File'
+
+ # ensuring a default content type
+ content_type = response.headers['Content-Type'] || 'application/json'
+
+ unless content_type.start_with?('application/json')
+ fail "Content-Type is not supported: #{content_type}"
+ end
+
+ begin
+ data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
+ rescue JSON::ParserError => e
+ if %w(String Date DateTime).include?(return_type)
+ data = body
+ else
+ raise e
+ end
+ end
+
+ convert_to_type data, return_type
+ end
+
+ # Convert data to the given return type.
+ def convert_to_type(data, return_type)
+ return nil if data.nil?
+ case return_type
+ when 'String'
+ data.to_s
+ when 'Integer'
+ data.to_i
+ when 'Float'
+ data.to_f
+ when 'BOOLEAN'
+ data == true
+ when 'DateTime'
+ # parse date time (expecting ISO 8601 format)
+ DateTime.parse data
+ when 'Date'
+ # parse date time (expecting ISO 8601 format)
+ Date.parse data
+ when 'Object'
+ # generic object, return directly
+ data
+ when /\AArray<(.+)>\z/
+ # e.g. Array<Pet>
+ sub_type = $1
+ data.map {|item| convert_to_type(item, sub_type) }
+ when /\AHash\<String, (.+)\>\z/
+ # e.g. Hash<String, Integer>
+ sub_type = $1
+ {}.tap do |hash|
+ data.each {|k, v| hash[k] = convert_to_type(v, sub_type) }
+ end
+ else
+ # models, e.g. Pet
+ {{moduleName}}.const_get(return_type).new.tap do |model|
+ model.build_from_hash data
+ end
+ end
+ 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.
+ #
+ # @see Configuration#temp_folder_path
+ # @return [File] the file downloaded
+ def download_file(response)
+ tmp_file = Tempfile.new '', @temp_folder_path
+ content_disposition = response.headers['Content-Disposition']
+ if content_disposition
+ filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
+ path = File.join File.dirname(tmp_file), filename
+ else
+ path = tmp_file.path
+ end
+ # close and delete temp file
+ tmp_file.close!
+
+ File.open(path, 'w') { |file| file.write(response.body) }
+ logger.info "File written to #{path}. Please move the file to a proper folder for further processing and delete the temp afterwards"
+ return File.new(path)
+ end
+
+ def build_request_url(path)
+ url = [host, base_path, path].join('/').gsub(/\/+/, '/')
+ url = "#{scheme}://#{url}"
+ URI.encode(url)
+ end
+
+ def build_request_body(header_params, form_params, body)
+ # http form
+ if header_params['Content-Type'] == 'application/x-www-form-urlencoded'
+ data = form_params.dup
+ data.each do |key, value|
+ data[key] = value.to_s if value && !value.is_a?(File)
+ end
+ elsif body
+ data = body.is_a?(String) ? body : body.to_json
+ else
+ data = nil
+ end
+ return data
+ end
+
+ {{#hasAuthMethods}}
+ # Update hearder and query params based on authentication settings.
+ def update_params_for_auth!(header_params, query_params, auth_names)
+ return unless auth_names
+ auth_names.each do |auth_name|
+ case auth_name
+ {{#authMethods}}when '{{name}}'
+ {{#isApiKey}}{{#isKeyInHeader}}header_params ||= {}
+ header_params['{{keyParamName}}'] = get_api_key_with_prefix('{{keyParamName}}'){{/isKeyInHeader}}{{#isKeyInQuery}}query_params['{{keyParamName}}'] = get_api_key_with_prefix('{{keyParamName}}'){{/isKeyInQuery}}{{/isApiKey}}{{#isBasic}}http_auth_header = 'Basic ' + ["#{@username}:#{@password}"].pack('m').delete("\r\n")
+ header_params['Authorization'] = http_auth_header{{/isBasic}}{{#isOAuth}}# TODO: support oauth{{/isOAuth}}
+ {{/authMethods}}
+ end
+ end
+ end
+
+ # Get API key (with prefix if set).
+ # @param [String] param_name the parameter name of API key auth
+ def get_api_key_with_prefix(param_name)
+ if @api_key_prefix[param_name]
+ "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+ else
+ @api_key[param_name]
+ end
+ end
+ {{/hasAuthMethods}}
+
  def user_agent=(user_agent)
  @user_agent = user_agent
  @default_headers['User-Agent'] = @user_agent
  end
+
+ # Return Accept header based on an array of accepts provided.
+ # @param [Array] accepts array for Accept
+ # @return [String] the Accept header (e.g. application/json)
+ def select_header_accept(accepts)
+ if accepts.empty?
+ return
+ elsif accepts.any?{ |s| s.casecmp('application/json') == 0 }
+ 'application/json' # look for json data by default
+ else
+ accepts.join(',')
+ end
+ end
+
+ # Return Content-Type header based on an array of content types provided.
+ # @param [Array] content_types array for Content-Type
+ # @return [String] the Content-Type header (e.g. application/json)
+ def select_header_content_type(content_types)
+ if content_types.empty?
+ 'application/json' # use application/json by default
+ elsif content_types.any?{ |s| s.casecmp('application/json')==0 }
+ 'application/json' # use application/json if it's included
+ else
+ content_types[0] # otherwise, use the first one
+ end
+ end
+
+ # Convert object (array, hash, object, etc) to JSON string.
+ # @param [Object] model object to be converted into JSON string
+ # @return [String] JSON string representation of the object
+ def object_to_http_body(model)
+ return if model.nil?
+ _body = nil
+ if model.is_a?(Array)
+ _body = model.map{|m| object_to_hash(m) }
+ else
+ _body = object_to_hash(model)
+ end
+ _body.to_json
+ end
+
+ # Convert object(non-array) to hash.
+ # @param [Object] obj object to be converted into JSON string
+ # @return [String] JSON string representation of the object
+ def object_to_hash(obj)
+ if obj.respond_to?(:to_hash)
+ obj.to_hash
+ else
+ obj
+ end
+ end
  end
 end

modules/swagger-codegen/src/main/resources/ruby/gem.mustache

@@ -1,8 +1,6 @@
 # Common files
 require '{{gemName}}/api_client'
 require '{{gemName}}/api_error'
-require '{{gemName}}/request'
-require '{{gemName}}/response'
 require '{{gemName}}/version'
 
 # Models