[ruby] Introduce ApiModelBase (#22052)

The Ruby code that is generated copies numerous methods into every model. This creates bloat both in file size and run-time memory usage. This commit introduces a base class for all models to store common methods. This commit's focus is only on static methods that do not change between models.

Author: Fryguy

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RubyClientCodegen.java

@@ -271,6 +271,7 @@ public void processOpts() {
  supportingFiles.add(new SupportingFile("gem.mustache", libFolder, gemName + ".rb"));
  String gemFolder = libFolder + File.separator + gemName;
  supportingFiles.add(new SupportingFile("api_error.mustache", gemFolder, "api_error.rb"));
+ supportingFiles.add(new SupportingFile("api_model_base.mustache", gemFolder, "api_model_base.rb"));
  supportingFiles.add(new SupportingFile("version.mustache", gemFolder, "version.rb"));
  supportingFiles.add(new SupportingFile("README.mustache", "", "README.md"));
  supportingFiles.add(new SupportingFile("git_push.sh.mustache", "", "git_push.sh"));

modules/openapi-generator/src/main/resources/ruby-client/api_model_base.mustache

@@ -0,0 +1,81 @@
+=begin
+{{> api_info}}
+
+=end
+
+module {{moduleName}}
+ class ApiModelBase
+ # Deserializes the data based on type
+ # @param string type Data type
+ # @param string value Value to be deserialized
+ # @return [Object] Deserialized data
+ def self._deserialize(type, value)
+ case type.to_sym
+ when :Time
+ Time.parse(value)
+ when :Date
+ Date.parse(value)
+ when :String
+ value.to_s
+ when :Integer
+ value.to_i
+ when :Float
+ value.to_f
+ when :Boolean
+ if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+ true
+ else
+ false
+ end
+ when :Object
+ # generic object (usually a Hash), return directly
+ value
+ when /\AArray<(?<inner_type>.+)>\z/
+ inner_type = Regexp.last_match[:inner_type]
+ value.map { |v| _deserialize(inner_type, v) }
+ when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+ k_type = Regexp.last_match[:k_type]
+ v_type = Regexp.last_match[:v_type]
+ {}.tap do |hash|
+ value.each do |k, v|
+ hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+ end
+ end
+ else # model
+ # models (e.g. Pet) or oneOf
+ klass = {{moduleName}}.const_get(type)
+ klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+ end
+ end
+
+ # Returns the string representation of the object
+ # @return [String] String presentation of the object
+ def to_s
+ to_hash.to_s
+ end
+
+ # to_body is an alias to to_hash (backward compatibility)
+ # @return [Hash] Returns the object in the form of hash
+ def to_body
+ to_hash
+ end
+
+ # Outputs non-array value in the form of hash
+ # For object, use to_hash. Otherwise, just return the value
+ # @param [Object] value Any valid value
+ # @return [Hash] Returns the value in the form of hash
+ def _to_hash(value)
+ if value.is_a?(Array)
+ value.compact.map { |v| _to_hash(v) }
+ elsif value.is_a?(Hash)
+ {}.tap do |hash|
+ value.each { |k, v| hash[k] = _to_hash(v) }
+ end
+ elsif value.respond_to? :to_hash
+ value.to_hash
+ else
+ value
+ end
+ end
+ end
+end

modules/openapi-generator/src/main/resources/ruby-client/base_object.mustache

@@ -24,61 +24,6 @@
  new(transformed_hash)
  end
 
- # Deserializes the data based on type
- # @param string type Data type
- # @param string value Value to be deserialized
- # @return [Object] Deserialized data
- def self._deserialize(type, value)
- case type.to_sym
- when :Time
- Time.parse(value)
- when :Date
- Date.parse(value)
- when :String
- value.to_s
- when :Integer
- value.to_i
- when :Float
- value.to_f
- when :Boolean
- if value.to_s =~ /\A(true|t|yes|y|1)\z/i
- true
- else
- false
- end
- when :Object
- # generic object (usually a Hash), return directly
- value
- when /\AArray<(?<inner_type>.+)>\z/
- inner_type = Regexp.last_match[:inner_type]
- value.map { |v| _deserialize(inner_type, v) }
- when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
- k_type = Regexp.last_match[:k_type]
- v_type = Regexp.last_match[:v_type]
- {}.tap do |hash|
- value.each do |k, v|
- hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
- end
- end
- else # model
- # models (e.g. Pet) or oneOf
- klass = {{moduleName}}.const_get(type)
- klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
- end
- end
-
- # Returns the string representation of the object
- # @return [String] String presentation of the object
- def to_s
- to_hash.to_s
- end
-
- # to_body is an alias to to_hash (backward compatibility)
- # @return [Hash] Returns the object in the form of hash
- def to_body
- to_hash
- end
-
  # Returns the object in the form of hash
  # @return [Hash] Returns the object in the form of hash
  def to_hash
@@ -94,21 +39,3 @@
  end
  hash
  end
-
- # Outputs non-array value in the form of hash
- # For object, use to_hash. Otherwise, just return the value
- # @param [Object] value Any valid value
- # @return [Hash] Returns the value in the form of hash
- def _to_hash(value)
- if value.is_a?(Array)
- value.compact.map { |v| _to_hash(v) }
- elsif value.is_a?(Hash)
- {}.tap do |hash|
- value.each { |k, v| hash[k] = _to_hash(v) }
- end
- elsif value.respond_to? :to_hash
- value.to_hash
- else
- value
- end
- end

modules/openapi-generator/src/main/resources/ruby-client/gem.mustache

@@ -6,6 +6,7 @@
 # Common files
 require '{{gemName}}/api_client'
 require '{{gemName}}/api_error'
+require '{{gemName}}/api_model_base'
 require '{{gemName}}/version'
 require '{{gemName}}/configuration'
 

modules/openapi-generator/src/main/resources/ruby-client/partial_model_generic.mustache

@@ -1,7 +1,7 @@
  {{#description}}
  # {{{.}}}
  {{/description}}
- class {{classname}}{{#parent}} < {{{.}}}{{/parent}}
+ class {{classname}}{{#parent}} < {{{.}}}{{/parent}}{{^parent}} < ApiModelBase{{/parent}}
  {{#vars}}
  {{#description}}
  # {{{.}}}

samples/client/echo_api/ruby-faraday/.openapi-generator/FILES

@@ -34,6 +34,7 @@ lib/openapi_client/api/path_api.rb
 lib/openapi_client/api/query_api.rb
 lib/openapi_client/api_client.rb
 lib/openapi_client/api_error.rb
+lib/openapi_client/api_model_base.rb
 lib/openapi_client/configuration.rb
 lib/openapi_client/models/bird.rb
 lib/openapi_client/models/category.rb

samples/client/echo_api/ruby-faraday/lib/openapi_client.rb

@@ -13,6 +13,7 @@
 # Common files
 require 'openapi_client/api_client'
 require 'openapi_client/api_error'
+require 'openapi_client/api_model_base'
 require 'openapi_client/version'
 require 'openapi_client/configuration'
 

samples/client/echo_api/ruby-faraday/lib/openapi_client/api_model_base.rb

@@ -0,0 +1,88 @@
+=begin
+#Echo Server API
+
+#Echo Server API
+
+The version of the OpenAPI document: 0.1.0
+Contact: team@openapitools.org
+Generated by: https://openapi-generator.tech
+Generator version: 7.17.0-SNAPSHOT
+
+=end
+
+module OpenapiClient
+ class ApiModelBase
+ # Deserializes the data based on type
+ # @param string type Data type
+ # @param string value Value to be deserialized
+ # @return [Object] Deserialized data
+ def self._deserialize(type, value)
+ case type.to_sym
+ when :Time
+ Time.parse(value)
+ when :Date
+ Date.parse(value)
+ when :String
+ value.to_s
+ when :Integer
+ value.to_i
+ when :Float
+ value.to_f
+ when :Boolean
+ if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+ true
+ else
+ false
+ end
+ when :Object
+ # generic object (usually a Hash), return directly
+ value
+ when /\AArray<(?<inner_type>.+)>\z/
+ inner_type = Regexp.last_match[:inner_type]
+ value.map { |v| _deserialize(inner_type, v) }
+ when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+ k_type = Regexp.last_match[:k_type]
+ v_type = Regexp.last_match[:v_type]
+ {}.tap do |hash|
+ value.each do |k, v|
+ hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+ end
+ end
+ else # model
+ # models (e.g. Pet) or oneOf
+ klass = OpenapiClient.const_get(type)
+ klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+ end
+ end
+
+ # Returns the string representation of the object
+ # @return [String] String presentation of the object
+ def to_s
+ to_hash.to_s
+ end
+
+ # to_body is an alias to to_hash (backward compatibility)
+ # @return [Hash] Returns the object in the form of hash
+ def to_body
+ to_hash
+ end
+
+ # Outputs non-array value in the form of hash
+ # For object, use to_hash. Otherwise, just return the value
+ # @param [Object] value Any valid value
+ # @return [Hash] Returns the value in the form of hash
+ def _to_hash(value)
+ if value.is_a?(Array)
+ value.compact.map { |v| _to_hash(v) }
+ elsif value.is_a?(Hash)
+ {}.tap do |hash|
+ value.each { |k, v| hash[k] = _to_hash(v) }
+ end
+ elsif value.respond_to? :to_hash
+ value.to_hash
+ else
+ value
+ end
+ end
+ end
+end

samples/client/echo_api/ruby-faraday/lib/openapi_client/models/bird.rb

@@ -14,7 +14,7 @@
 require 'time'
 
 module OpenapiClient
- class Bird
+ class Bird < ApiModelBase
  attr_accessor :size
 
  attr_accessor :color
@@ -135,61 +135,6 @@ def self.build_from_hash(attributes)
  new(transformed_hash)
  end
 
- # Deserializes the data based on type
- # @param string type Data type
- # @param string value Value to be deserialized
- # @return [Object] Deserialized data
- def self._deserialize(type, value)
- case type.to_sym
- when :Time
- Time.parse(value)
- when :Date
- Date.parse(value)
- when :String
- value.to_s
- when :Integer
- value.to_i
- when :Float
- value.to_f
- when :Boolean
- if value.to_s =~ /\A(true|t|yes|y|1)\z/i
- true
- else
- false
- end
- when :Object
- # generic object (usually a Hash), return directly
- value
- when /\AArray<(?<inner_type>.+)>\z/
- inner_type = Regexp.last_match[:inner_type]
- value.map { |v| _deserialize(inner_type, v) }
- when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
- k_type = Regexp.last_match[:k_type]
- v_type = Regexp.last_match[:v_type]
- {}.tap do |hash|
- value.each do |k, v|
- hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
- end
- end
- else # model
- # models (e.g. Pet) or oneOf
- klass = OpenapiClient.const_get(type)
- klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
- end
- end
-
- # Returns the string representation of the object
- # @return [String] String presentation of the object
- def to_s
- to_hash.to_s
- end
-
- # to_body is an alias to to_hash (backward compatibility)
- # @return [Hash] Returns the object in the form of hash
- def to_body
- to_hash
- end
-
  # Returns the object in the form of hash
  # @return [Hash] Returns the object in the form of hash
  def to_hash
@@ -206,24 +151,6 @@ def to_hash
  hash
  end
 
- # Outputs non-array value in the form of hash
- # For object, use to_hash. Otherwise, just return the value
- # @param [Object] value Any valid value
- # @return [Hash] Returns the value in the form of hash
- def _to_hash(value)
- if value.is_a?(Array)
- value.compact.map { |v| _to_hash(v) }
- elsif value.is_a?(Hash)
- {}.tap do |hash|
- value.each { |k, v| hash[k] = _to_hash(v) }
- end
- elsif value.respond_to? :to_hash
- value.to_hash
- else
- value
- end
- end
-
  end
 
 end