Include base_object model into module structure

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

@@ -1,83 +1,83 @@
-# base class containing fundamental method such as to_hash, build_from_hash and more
+module {{moduleName}}
-class BaseObject
+  # base class containing fundamental method such as to_hash, build_from_hash and more
+  class BaseObject
 
-  # return the object in the form of hash
+    # return the object in the form of hash
-  def to_body
+    def to_body
-    body = {}
+      body = {}
-    self.class.attribute_map.each_pair do |key, value|
+      self.class.attribute_map.each_pair do |key, value|
-      body[value] = self.send(key) unless self.send(key).nil?
+        body[value] = self.send(key) unless self.send(key).nil?
+      end
+      body
     end
-    body
-  end
 
-  # build the object from hash
+    # build the object from hash
-  def build_from_hash(attributes)
+    def build_from_hash(attributes)
-    return nil unless attributes.is_a?(Hash)
+      return nil unless attributes.is_a?(Hash)
-    self.class.swagger_types.each_pair do |key, type|
+      self.class.swagger_types.each_pair do |key, type|
-      if type =~ /^array\[(.*)\]/i
+        if type =~ /^array\[(.*)\]/i
-        if attributes[self.class.attribute_map[key]].is_a?(Array)
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
-          self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
         else
-          #TODO show warning in debug mode
+          # data not found in attributes(hash), not an issue as the data can be optional
-        end
-      elsif !attributes[self.class.attribute_map[key]].nil?
-        self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
-      else
-        # data not found in attributes(hash), not an issue as the data can be optional
-      end
-    end
-
-    self
-  end
-
-  def _deserialize(type, value)
-    case type.to_sym
-    when :DateTime
-      DateTime.parse(value)
-    when :string
-      value.to_s
-    when :int
-      value.to_i
-    when :double
-      value.to_f
-    when :boolean
-      if value =~ /^(true|t|yes|y|1)$/i
-        true
-      else
-        false
-      end
-    else # model
-      _model = Object.const_get(type).new
-      _model.build_from_hash(value)
-    end
-  end
-
-
-
-  # to_body is an alias to to_body (backward compatibility)
-  def to_hash
-    hash = {}
-    self.class.attribute_map.each_pair do |key, value|
-      if self.send(key).is_a?(Array)
-        next if self.send(key).empty?
-        hash[value] = self.send(key).select{|v| !v.nil?}.map{ |v| _to_hash v} unless self.send(key).nil?
-      else
-        unless (_tmp_value = _to_hash self.send(key)).nil?
-          hash[value] = _tmp_value
         end
       end
-    end
-    hash
-  end
 
-  # Method to output non-array value in the form of hash
+      self
-  # For object, use to_hash. Otherwise, just return the value
-  def _to_hash(value)
-    if value.respond_to? :to_hash
-      value.to_hash
-    else
-      value
     end
-  end
 
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :string
+        value.to_s
+      when :int
+        value.to_i
+      when :double
+        value.to_f
+      when :boolean
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      else # model
+        _model = {{moduleName}}.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    # to_body is an alias to to_body (backward compatibility)
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |key, value|
+        if self.send(key).is_a?(Array)
+          next if self.send(key).empty?
+          hash[value] = self.send(key).select{|v| !v.nil?}.map{ |v| _to_hash v} unless self.send(key).nil?
+        else
+          unless (_tmp_value = _to_hash self.send(key)).nil?
+            hash[value] = _tmp_value
+          end
+        end
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
 end

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

@@ -1,5 +1,3 @@
-require_relative 'base_object'
-
 module {{moduleName}}
 {{#models}}  # {{description}}
 {{#model}}  class {{classname}} < BaseObject

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

@@ -7,6 +7,7 @@ require '{{gemName}}/swagger/response'
 require '{{gemName}}/swagger/version'
 
 # Models
+require '{{modelPackage}}/base_object'
 {{#models}}
 {{#model}}
 require '{{importPath}}'