washout_builder 1.7.4 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c096f4d12d0323f4e903fc0b9a062a9994d0d8378aa8d596ddc9e485a63d66f8
-  data.tar.gz: cc4083f364a1b75ebdf184967a07c8529f26fb3958200d3aa3b2c9f26c2a285b
+  metadata.gz: 31e9ca2912acbfe0b0abde89e74ae2f2c5b7f89bcdf9a9a92054e6e7ed3d7017
+  data.tar.gz: 0f9eb779de5e243f47d6464f9d6e0c45790c64053b3f4b75f94431ef328ee8dd
 SHA512:
-  metadata.gz: 0230faa4b0fc98e3ad5390ec0e5b42320cda08c3c76751136cc76c85d14f02d430b5d63d11d836257bf8e4d047415ce034c8bf5c47f17fdf2b05bded1cbe7aca
-  data.tar.gz: 384c3ae8f533fe710a7470905827a4d4f292b772dddd4049c261b9c6973d0c39e67df9cccc4813a2d3954a86094a907b748ff27f84a7d36732365ef14b748839
+  metadata.gz: 6c95a39a250f9fa4bb7d4e0d276f69b8bbf3a02441698f93214d56d32110cb26366897198c7b1da78665a34148ef9062fa07872add72222bc6203cd6d2ca11b3
+  data.tar.gz: 2e40ae1202131d8bdec1f30a91107be0477c7636d53be584f6bf4a6eec46ec996aa2f637d090b259126050e6d589ad83274dc6b5bf2121f334fda01dc1c3919d

data/.travis.yml

@@ -1,30 +1,29 @@
 language: ruby
-sudo: false
 
 cache: bundler
 
 bundler_args: --no-deployment --binstubs=./bin
 
 before_install:
-  -"echo 'gem: --no-ri --no-rdoc' > ~/.gemrc"
-  - gem update --system
+  - "echo 'gem: --no-ri --no-rdoc' > ~/.gemrc"
+  - rvm rubygems current
+  - gem update --system || true
   - gem --version
-  - bash ./install-travis-bundler.sh
-  - bundle --version
+  - source ./install-travis-bundler.sh
+  - bundle ${MY_BUNDLER_VERSION} --version
 
 install:
-  - bundle config --local path vendor/bundle
-  - bundle config --local jobs 3
-  - bundle config --local retry 3
-  - bundle config --local binstubs ./bin
-  - bundle config --local bin ./bin
-  - bundle install
+  - bundle ${MY_BUNDLER_VERSION} config --local jobs 3
+  - bundle ${MY_BUNDLER_VERSION} config --local retry 3
+  - bundle ${MY_BUNDLER_VERSION} config --local binstubs ./bin
+  - bundle ${MY_BUNDLER_VERSION} config --local bin ./bin
+  - bundle ${MY_BUNDLER_VERSION} install
   - gem env
-  - bundle env
+  - bundle ${MY_BUNDLER_VERSION} env
 
 script:
    - echo $BUNDLE_GEMFILE
-   - bundle exec rake
+   - bundle ${MY_BUNDLER_VERSION} exec rake
 
 gemfile:
   - gemfiles/rails_4.0.0.gemfile
@@ -59,7 +58,7 @@ matrix:
   - rvm: 2.6.5
     gemfile: gemfiles/rails_4.1.1.gemfile
   - rvm: 2.6.5
-   gemfile: gemfiles/rails_4.2.0.gemfile
+    gemfile: gemfiles/rails_4.2.0.gemfile
 rvm:
   - 2.2.5
   - 2.3.1
@@ -68,5 +67,7 @@ rvm:
   - 2.4.7
   - 2.5.6
   - 2.6.5
+  - 2.7.1
+  - 3.0.0
 notifications:
   email: false

data/Appraisals

@@ -17,7 +17,7 @@ if RUBY_VERSION <= "2.4.0"
     gem 'actionpack' , '4.2.7.1'
   end
 end
-if  RUBY_VERSION >= '2.2.0' && ENV['BUNDLER_VERSION'].to_s <= '2.0'
+if RUBY_VERSION >= '2.2.0' && RUBY_VERSION < '3.0.0' && ENV['BUNDLER_VERSION'].to_s <= '2.0'
   appraise "rails-5.0.0" do
     gem "rails", "5.0.0"
   end
@@ -40,7 +40,7 @@ if  RUBY_VERSION >= '2.2.0' && ENV['BUNDLER_VERSION'].to_s <= '2.0'
   end
 end
 
-if  RUBY_VERSION >= '2.2.0' && ENV['BUNDLER_VERSION'].to_s >= '2.0'
+if RUBY_VERSION >= '2.2.0' && RUBY_VERSION < '3.0.0' && ENV['BUNDLER_VERSION'].to_s >= '2.0'
   appraise "rails-5.2.0" do
     gem "rails", "5.2.0"
   end
@@ -57,3 +57,9 @@ if  RUBY_VERSION >= '2.2.0' && ENV['BUNDLER_VERSION'].to_s >= '2.0'
     gem "rails", "6.0.1"
   end
 end
+
+if RUBY_VERSION >= '3.0.0' && ENV['BUNDLER_VERSION'].to_s >= '2.0'
+  appraise "rails-6.1.3" do
+    gem "rails", "6.1.3"
+  end
+end

data/README.md

@@ -1,7 +1,7 @@
 washout_builder
 ===============
 
-[![Gem Version](https://badge.fury.io/rb/washout_builder.svg)](http://badge.fury.io/rb/washout_builder) [![Build Status](https://travis-ci.org/bogdanRada/washout_builder.png?branch=master,develop)](https://travis-ci.org/bogdanRada/washout_builder) [![Dependency Status](https://gemnasium.com/bogdanRada/washout_builder.svg)](https://gemnasium.com/bogdanRada/washout_builder) [![Documentation Status](http://inch-ci.org/github/bogdanRada/washout_builder.svg?branch=master)](http://inch-ci.org/github/bogdanRada/washout_builder) [![Coverage Status](https://coveralls.io/repos/bogdanRada/washout_builder/badge.svg?branch=master)](https://coveralls.io/r/bogdanRada/washout_builder?branch=master) [![Code Climate](https://codeclimate.com/github/bogdanRada/washout_builder/badges/gpa.svg)](https://codeclimate.com/github/bogdanRada/washout_builder) [![Repo Size](https://reposs.herokuapp.com/?path=bogdanRada/washout_builder)](https://github.com/bogdanRada/washout_builder) [![Gem Downloads](https://ruby-gem-downloads-badge.herokuapp.com/washout_builder?type=total)](https://github.com/bogdanRada/washout_builder) [![Analytics](https://ga-beacon.appspot.com/UA-72570203-1/bogdanRada/washout_builder)](https://github.com/bogdanRada/washout_builder)
+[![Gem Version](https://badge.fury.io/rb/washout_builder.svg)](http://badge.fury.io/rb/washout_builder) [![Build Status](https://travis-ci.org/bogdanRada/washout_builder.png?branch=master,develop)](https://travis-ci.org/bogdanRada/washout_builder)  [![Documentation Status](http://inch-ci.org/github/bogdanRada/washout_builder.svg?branch=master)](http://inch-ci.org/github/bogdanRada/washout_builder) [![Coverage Status](https://coveralls.io/repos/bogdanRada/washout_builder/badge.svg?branch=master)](https://coveralls.io/r/bogdanRada/washout_builder?branch=master) [![Code Climate](https://codeclimate.com/github/bogdanRada/washout_builder/badges/gpa.svg)](https://codeclimate.com/github/bogdanRada/washout_builder) [![Repo Size](https://reposs.herokuapp.com/?path=bogdanRada/washout_builder)](https://github.com/bogdanRada/washout_builder) [![Gem Downloads](https://ruby-gem-downloads-badge.herokuapp.com/washout_builder?type=total)](https://github.com/bogdanRada/washout_builder) 
 
 Overview
 --------
@@ -10,6 +10,27 @@ WashOutBuilder is a Soap Service Documentation generator (extends [WashOut](http
 
 The way [WashOut](https://github.com/inossidabile/wash_out) is used is not modified, it just extends its functionality by generating html documentation to your services that you write
 
+NEW Improvements in version 2.0.1
+---------------------------------
+ - Fix issue when trying to re-use same complex type (with same structure) multiple times inside same controller 
+
+NEW Improvements in version 2.0.0
+---------------------------------
+
+This release tries to fix some major bugs and introduces backward incompatible changes. 
+ - The complex type list will contain now exactly same types used when doing an actual SOAP request
+ - Same for when listing the soap actions ( the return type and parameters ).
+ 
+Initially the way the complex types were shown on the page was not correct, because it was not reflecting 
+the actual way the SOAP action receives its arguments when doing an actual SOAP request to that controller
+
+The main issue was not handling correctly the classes that are inheriting from WashOut::Type. 
+
+This release tries to fix those issues.
+
+Note: Only internal methods have been changed. The configuration has not changed.
+So in order to upgrade to this new version, just update the version in your Gemfile/gemspec file
+
 NEW Improvements in version 1.5.1
 ---------------------------------
 

data/Rakefile

@@ -21,7 +21,7 @@ task :all do |_t|
     # require 'json'
     # puts JSON.pretty_generate(ENV.to_hash)
     if ENV['BUNDLE_GEMFILE'] =~ /gemfiles/
-      appraisal_name = ENV['BUNDLE_GEMFILE'].scan(/rails\_(.*)\.gemfile/).flatten.first
+      appraisal_name = ENV['BUNDLE_GEMFILE'].scan(/rails_(.*)\.gemfile/).flatten.first
       command_prefix = "appraisal rails-#{appraisal_name}"
       exec ("#{command_prefix} bundle install && #{command_prefix} bundle exec rspec && bundle exec rake coveralls:push ")
     else
@@ -40,8 +40,8 @@ YARD::Config.load_plugins
 end
 
 YARD::Rake::YardocTask.new do |t|
-  t.files = ['lib/**/*.rb', 'spec/**/*_spec.rb'] # optional
-  t.options = ['--any', '--extra', '--opts', '--markup-provider=redcarpet', '--markup=markdown', '--debug'] # optional
+  t.files = %w(lib/**/*.rb spec/**/*_spec.rb) # optional
+  t.options = %w(--any --extra --opts --markup-provider=redcarpet --markup=markdown --debug) # optional
   t.stats_options = ['--list-undoc'] # optional
 end
 

data/app/controllers/washout_builder/washout_builder_controller.rb

@@ -23,7 +23,7 @@ module WashoutBuilder
         @document = WashoutBuilder::Document::Generator.new(route_details, controller_class(params[:name]).controller_path)
         @file_to_serve = 'wash_with_html/doc'
         render_html(@file_to_serve)
-      elsif
+      else
         @services = all_services
         @file_to_serve = 'wash_with_html/all_services'
         render_html(@file_to_serve)
@@ -71,10 +71,10 @@ module WashoutBuilder
         controller_name = hash[:route].present? && hash[:route].respond_to?(:defaults) ? hash[:route].defaults[:controller] : nil
         if controller_name.present?
           {
-            'service_name' => controller_naming(controller_name),
-            'namespace' => service_namespace(hash, controller_name),
-            'endpoint' => service_endpoint(hash, controller_name),
-            'documentation_url' => service_documentation_url(hash, controller_name)
+              'service_name' => controller_naming(controller_name),
+              'namespace' => service_namespace(hash, controller_name),
+              'endpoint' => service_endpoint(hash, controller_name),
+              'documentation_url' => service_documentation_url(hash, controller_name)
           }
         end
       end.uniq{|hash| hash['service_name'] }
@@ -113,10 +113,10 @@ module WashoutBuilder
         engine_route = Rails.application.routes.named_routes[engine.engine_name]
         routes_hash_array = engine.routes.routes.map { |route|
           {
-            engine: engine,
-            route_set: engine.routes,
-            route: route,
-            mounted_at: engine_route.blank? ? nil : engine_route.path.spec.to_s
+              engine: engine,
+              route_set: engine.routes,
+              route: route,
+              mounted_at: engine_route.blank? ? nil : engine_route.path.spec.to_s
           }
         }
 

data/app/helpers/washout_builder_complex_type_helper.rb

@@ -1,5 +1,6 @@
 # module that is used for constructing complex types in HTML-Documentation
 module WashoutBuilderComplexTypeHelper
+  include WashoutBuilderSharedHelper
   # this method is for printing the attributes of a complex type
   # if the attributes are primitives this will show the attributes with  blue color
   # otherwise will call another method for printing the complex attribute
@@ -49,8 +50,9 @@ module WashoutBuilderComplexTypeHelper
   def create_complex_element_type_html(pre, element, element_description)
     complex_class = element.find_complex_class_name
     return if complex_class.nil?
-    complex_class_content = element.multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
-    pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class_content}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
+    real_class = find_correct_complex_type(complex_class)
+    complex_class_content = element.multiplied ? "Array of #{real_class}" : "#{real_class}"
+    pre << "<a href='##{real_class}'><span class='lightBlue'>#{complex_class_content}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
     pre << "&#8194;<span>#{html_safe(element_description)}</span>" unless element_description.blank?
     pre
   end

data/app/helpers/washout_builder_method_arguments_helper.rb

@@ -1,5 +1,6 @@
 # helper that is used to show the arguments of a method with their types in HTML documentation
 module WashoutBuilderMethodArgumentsHelper
+  include WashoutBuilderSharedHelper
   # displays the parameter of a method as argument and determines if the parameter is basic type or complex type
   #
   # @see WashoutBuilder::Document::ComplexType#find_complex_class_name
@@ -37,8 +38,9 @@ module WashoutBuilderMethodArgumentsHelper
   # @api public
   def create_method_argument_complex_element(pre, param, use_spacer, spacer, complex_class)
     return if complex_class.nil?
-    argument_content = param.multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
-    pre << "#{use_spacer ? spacer : ''}<a href='##{complex_class}'><span class='lightBlue'>#{argument_content}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"
+    real_class = find_correct_complex_type(complex_class)
+    argument_content = param.multiplied ? "Array of #{real_class}" : "#{real_class}"
+    pre << "#{use_spacer ? spacer : ''}<a href='##{real_class}'><span class='lightBlue'>#{argument_content}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"
   end
 
   # this method will check if the current index of the argument is not last, will insert a comma  then a break if the argument is followed by other arguments,

data/app/helpers/washout_builder_method_list_helper.rb

@@ -1,5 +1,6 @@
 # helper that is used to list the method's return tyep as a LI element in HTML documentation
 module WashoutBuilderMethodListHelper
+  include WashoutBuilderSharedHelper
   # this method will create the return type of the method and check if the type is basic or complex type or array of types
   #
   # @param [Builder::XmlMarkup] xml the markup builder that is used to insert HTML line breaks or span elements
@@ -10,9 +11,10 @@ module WashoutBuilderMethodListHelper
   #
   # @api public
   def create_return_complex_type_list_html(xml, complex_class, builder_out)
-    return_content = builder_out[0].multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
+    real_class = find_correct_complex_type(complex_class)
+    return_content = builder_out[0].multiplied ?  "Array of #{real_class}" : "#{real_class}"
     xml.span('class' => 'pre') do
-      xml.a('href' => "##{complex_class}") do |inner_xml|
+      xml.a('href' => "##{real_class}") do |inner_xml|
         inner_xml.span('class' => 'lightBlue') do |y|
           y << "#{return_content}"
         end

data/app/helpers/washout_builder_method_return_type_helper.rb

@@ -1,5 +1,6 @@
 # helper that is used to create the return types of methods in HTML documentation
 module WashoutBuilderMethodReturnTypeHelper
+  include WashoutBuilderSharedHelper
   # this method will print the return type next to the method name
   # @see WashoutBuilder::Document::ComplexType#find_complex_class_name
   # @see WashoutBuilder::Type::BASIC_TYPES
@@ -37,11 +38,12 @@ module WashoutBuilderMethodReturnTypeHelper
   # @api public
   def html_public_method_complex_type(pre, output, complex_class)
     return if complex_class.nil?
-    if output[0].multiplied == false
-      complex_return_type = "#{complex_class}"
+    real_class = find_correct_complex_type(complex_class)
+    if output[0].multiplied
+      complex_return_type = "Array of #{real_class}"
     else
-      complex_return_type = "Array of #{complex_class}"
+      complex_return_type = "#{real_class}"
     end
-    pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_return_type}</span></a>"
+    pre << "<a href='##{real_class}'><span class='lightBlue'>#{complex_return_type}</span></a>"
   end
 end

data/app/helpers/washout_builder_shared_helper.rb

@@ -0,0 +1,29 @@
+module WashoutBuilderSharedHelper
+  # When displaying a complex type that inherits from WashOut::Type
+  # we must use its descendant name to properly show the correct Type
+  # that can we used to make the actual request to the action
+  #
+  # @param [Class, String] complex_class the name of the complex type either as a string or a class
+  # @return [Class, String]
+  # @api public
+  def find_correct_complex_type(complex_class)
+    real_class = find_class_from_string(complex_class)
+    if real_class.present? && real_class.ancestors.include?( WashoutBuilder::Type.base_type_class)
+      descendant = WashoutBuilder::Type.base_param_class.parse_def(config, real_class.wash_out_param_map)[0]
+      descendant.find_complex_class_name
+    else
+      complex_class
+    end
+  end
+
+  # Tries to constantize a string or a class to return the class
+  #
+  # @param [String] complex_class A string that contains the name of a class
+  # @return [Class, nil] returns the class if it is classes_defined otherwise nil
+  # @api public
+  def find_class_from_string(complex_class)
+    complex_class.is_a?(Class) ? complex_class : complex_class.constantize
+  rescue
+    nil
+  end
+end

data/app/views/wash_with_html/doc.builder

@@ -33,16 +33,16 @@ xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
 
     xml.h1 "#{ @document.service} Soap WebService interface description"
 
-    xml.p{ |y| y << "Endpoint URI:";
+    xml.p{ |y| y << "Endpoint URI:"
       xml.span( "class" => "pre") {
-        xml.a( "href" => "#{@document.endpoint}") { |y| y << "#{@document.endpoint}" }
-      };
+        xml.a( "href" => "#{@document.endpoint}") { |out| out << "#{@document.endpoint}" }
+      }
     }
 
-    xml.p{ |y| y << "WSDL URI:";
+    xml.p{ |y| y << "WSDL URI:"
       xml.span( "class" => "pre") {
-        xml.a( "href" => "#{@document.namespace}") { |y| y << "#{@document.namespace}" }
-      };
+        xml.a( "href" => "#{@document.namespace}") { |out| out << "#{@document.namespace}" }
+      }
     }
     xml.p ""
     unless @document.service_description.blank?

data/gemfiles/rails_6.1.3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "wash_out", git: "https://github.com/inossidabile/wash_out.git"
+gem "rails", "6.1.3"
+
+gemspec path: "../"

data/install-travis-bundler.sh

@@ -1,21 +1,23 @@
 #!/usr/bin/env bash
 
-set -o errexit
-set -o pipefail
-set -o nounset
+# set -o errexit
+# set -o pipefail
+# set -o nounset
 
-rails_version="$(echo "$(basename $BUNDLE_GEMFILE .gemfile)" | sed 's/[^0-9.]*\([0-9.]*\).*/\1/')"
+rails_version="$(basename "${BUNDLE_GEMFILE:="$(pwd)/Gemfile"}" .gemfile | sed 's/[^0-9.]*\([0-9.]*\).*/\1/')"
 
-echo "Trying to compare rails ${rails_version} with 5.1"
+echo "Trying to compare rails ${rails_version:="1"} with 5.2"
 
-if (( $(echo "${rails_version%.*} >= 5.1" |bc -l) )); then
+if (( $(echo "${rails_version%.*} >= 5.2" |bc -l) )); then
    echo "Installing Bundler v2"
-   gem uninstall -v '< 2.0' -i $(rvm gemdir)@global -ax bundler --force || true
-   gem install bundler -v '2.0.1'
+   gem uninstall -v '< 2.0' -i "$(rvm gemdir)"@global -ax bundler --force || true
+   gem install bundler -v '2.2.11'
+   export MY_BUNDLER_VERSION="_2.2.11_"
 else
    echo "Installing Bundler v1"
-   gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler --force  || true
+   gem uninstall -v '>= 2' -i "$(rvm gemdir)"@global -ax bundler --force  || true
    gem install bundler -v '1.17.3'
+   export MY_BUNDLER_VERSION="_1.17.3_"
 fi
 
-unset rails_version
+unset rails_version

data/lib/washout_builder.rb

@@ -52,7 +52,6 @@ end
 base_param_class = WashoutBuilder::Type.base_param_class
 if base_param_class.present?
   base_param_class.class_eval do
-    extend WashoutBuilder::Param
     include WashoutBuilder::Document::ComplexType
   end
 end

data/lib/washout_builder/document/complex_type.rb

@@ -10,27 +10,27 @@ module WashoutBuilder
       # finds the complex class name of the current Washout::Param object and checks if is a duplicate
       # @see #check_duplicate_complex_class
       #
-      # @param [Array] defined Array that is used for when iterating through descendants and ancestors
+      # @param [Array] classes_defined Array that is used for when iterating through descendants and ancestors
       #
       # @return [Class] the complex type name of the current object
       #
       # @api public
-      def find_complex_class_name(defined = [])
+      def find_complex_class_name(classes_defined = [])
         complex_class = struct? ? basic_type.tr('.', '/').camelize : nil
-        check_duplicate_complex_class(defined, complex_class) unless complex_class.nil? || defined.blank?
+        check_duplicate_complex_class(classes_defined, complex_class) unless complex_class.nil? || classes_defined.blank?
         complex_class
       end
 
       # checks if the complex class appears in the array of complex types
       #
-      # @param [Array<Hash>] defined Array that is used for checking if a complex type is already defined
+      # @param [Array<Hash>] classes_defined Array that is used for checking if a complex type is already classes_defined
       # @param [Class] complex_class the complex type name used for searching
       #
       # @return [Boolean] returns true or false if the complex type is found inside the array
       # @raise [RuntimeError] Raises a runtime error if is detected a duplicate use of the complex type
       # @api public
-      def check_duplicate_complex_class(defined, complex_class)
-        complex_obj_found = defined.find { |hash| hash[:class] == complex_class }
+      def check_duplicate_complex_class(classes_defined, complex_class)
+        complex_obj_found = classes_defined.find { |hash| hash if hash[:class] == complex_class && hash[:obj].find_param_structure.keys != self.find_param_structure.keys }
         raise "Duplicate use of `#{basic_type}` type name. Consider using classified types." if !complex_obj_found.nil? && struct? && !classified?
       end
 
@@ -40,13 +40,13 @@ module WashoutBuilder
       #
       # @param [WashOut::SoapConfig] config the configuration of the soap service
       # @param [Clas] complex_class  the complex type name of the object
-      # @param [Array<Hash>] defined An array that holds all the complex types found so far
+      # @param [Array<Hash>] classes_defined An array that holds all the complex types found so far
       #
       # @return [Array<Class>, nil] returns nil if object not classified othewise an array of classes that are ancestors to curent object
       #
       # @api public
-      def complex_type_ancestors(config, complex_class, defined)
-        classified? ? get_class_ancestors(config, complex_class, defined) : nil
+      def complex_type_ancestors(config, complex_class, classes_defined)
+        classified? ? get_class_ancestors(config, complex_class, classes_defined) : nil
       end
 
       # iterates through all the elements of the current object
@@ -71,30 +71,11 @@ module WashoutBuilder
         self.map = map.delete_if { |element| keys.include?(element.name) }
       end
 
-      # Dirty hack to fix the first washout param type.
-      # This only applies if the first complex type is inheriting WashOutType
-      # its name should be set to its descendant  and the map of the current object will be set to its descendant
-      # @see  WashOut::Param#parse_builder_def
-      #
-      # @param [WashOut::SoapConfig] config an object that holds the soap configuration
-      # @param [Class, String] complex_class the name of the complex type either as a string or a class
-      # @return [void]
-      # @api public
-      def fix_descendant_wash_out_type(config, complex_class)
-        param_class = find_class_from_string(complex_class)
-        base_param_class = WashoutBuilder::Type.base_param_class
-        base_type_class =  WashoutBuilder::Type.base_type_class
-        return if base_param_class.blank? || base_type_class.blank?
-        return unless param_class.present? && param_class.ancestors.include?(base_type_class) && map[0].present?
-        descendant = base_param_class.parse_builder_def(config, param_class.wash_out_param_map)[0]
-        self.name = descendant.name
-        self.map = descendant.map
-      end
 
       # Description of method
       #
       # @param [String] complex_class A string that contains the name of a class
-      # @return [Class, nil] returns the class if it is defined otherwise nil
+      # @return [Class, nil] returns the class if it is classes_defined otherwise nil
       # @api public
       def find_class_from_string(complex_class)
         complex_class.is_a?(Class) ? complex_class : complex_class.constantize
@@ -114,10 +95,10 @@ module WashoutBuilder
         param_structure = find_param_structure
         ancestor_structure = ancestor.find_param_structure
         if param_structure.keys == ancestor_structure.keys
-          return true
+          true
         else
           remove_type_inheritable_elements(ancestor_structure.keys)
-          return false
+          false
         end
       end
 
@@ -132,10 +113,10 @@ module WashoutBuilder
       def get_ancestors(class_name)
         param_class = find_class_from_string(class_name)
         if param_class.nil?
-          return nil
+          nil
         else
           base_type_class =  WashoutBuilder::Type.base_type_class
-          filtered_classes = ['ActiveRecord::Base', 'Object', 'BasicObject']
+          filtered_classes = %w(ActiveRecord::Base Object BasicObject)
           filtered_classes << base_type_class.to_s if base_type_class.present?
           get_complex_type_ancestors(param_class, filtered_classes)
         end
@@ -146,16 +127,16 @@ module WashoutBuilder
       # @see WashOutParam#struct?
       #
       # @param [WashOut::SoapConfig] config an object that holds the soap configuration
-      # @param [Array<Hash>] defined An Array with all the complex types that have been detected till now
+      # @param [Array<Hash>] classes_defined An Array with all the complex types that have been detected till now
       # @return [Array<Hash>] An array with all the complex types that
       # @api public
-      def complex_type_descendants(config, defined)
+      def complex_type_descendants(config, classes_defined)
         if struct?
           c_names = []
-          map.each { |obj| c_names.concat(obj.get_nested_complex_types(config, defined)) }
-          defined.concat(c_names)
+          map.each { |obj| c_names.concat(obj.get_nested_complex_types(config, classes_defined)) }
+          classes_defined.concat(c_names)
         end
-        defined
+        classes_defined
       end
 
       # Recursive method that tries to identify all the nested descendants of the current object
@@ -166,18 +147,18 @@ module WashoutBuilder
       # @see #complex_type_descendants
       #
       # @param [WashOut::SoapConfig] config holds the soap configuration
-      # @param [Array<Hash>] defined An array with all the complex type structures that have been detected so far
+      # @param [Array<Hash>] classes_defined An array with all the complex type structures that have been detected so far
       # @return [Array<Hash>] An array with all the complex type that have been detected while iterating to all the descendants of the current object and also contains the previous ones
       # @api public
-      def get_nested_complex_types(config, defined)
-        defined = [] if defined.blank?
-        complex_class = find_complex_class_name(defined)
-        fix_descendant_wash_out_type(config, complex_class)
-        unless complex_class.nil?
-          defined << complex_type_hash(complex_class, self, complex_type_ancestors(config, complex_class, defined))
+      def get_nested_complex_types(config, classes_defined)
+        classes_defined = [] if classes_defined.blank?
+        complex_class = find_complex_class_name(classes_defined)
+        real_class = find_class_from_string(complex_class)
+        if complex_class.present? && (real_class.blank? || (real_class.present? && !real_class.ancestors.include?( WashoutBuilder::Type.base_type_class)))
+          classes_defined << complex_type_hash(complex_class, self, complex_type_ancestors(config, complex_class, classes_defined))
         end
-        defined = complex_type_descendants(config, defined)
-        defined.blank? ? [] : defined.sort_by { |hash| hash[:class].to_s.downcase }.uniq
+        classes_defined = complex_type_descendants(config, classes_defined)
+        classes_defined.blank? ? [] : classes_defined.sort_by { |hash| hash[:class].to_s.downcase }.uniq
       end
 
       # method that constructs the a hash with the name of the ancestor ( the class name) and as value its elemen structure
@@ -199,9 +180,9 @@ module WashoutBuilder
       # @api public
       def complex_type_hash(class_name, object, ancestors)
         {
-          class: class_name,
-          obj: object,
-          ancestors: ancestors
+            class: class_name,
+            obj: object,
+            ancestors: ancestors
         }
       end
 
@@ -213,10 +194,10 @@ module WashoutBuilder
       #
       # @param [WashOut::SoapConfig] config holds the soap configuration
       # @param [Class] class_name  The name of the class that is used for fetching the ancestors
-      # @param [Array<Hash>] defined An Array with all the complex types that have been detected so far
+      # @param [Array<Hash>] classes_defined An Array with all the complex types that have been detected so far
       # @return [Array<Class>] An Array of classes from which the class that is sent as parameter inherits from
       # @api public
-      def get_class_ancestors(config, class_name, defined)
+      def  get_class_ancestors(config, class_name, classes_defined)
         ancestors = get_ancestors(class_name)
         return if ancestors.blank?
         base_param_class = WashoutBuilder::Type.base_param_class
@@ -224,8 +205,8 @@ module WashoutBuilder
         ancestor_object = base_param_class.parse_def(config, ancestor_structure(ancestors))[0]
         bool_the_same = same_structure_as_ancestor?(ancestor_object)
         unless bool_the_same
-          top_ancestors = get_class_ancestors(config, ancestors[0], defined)
-          defined << complex_type_hash(ancestors[0], ancestor_object, top_ancestors)
+          top_ancestors = get_class_ancestors(config, ancestors[0], classes_defined)
+          classes_defined << complex_type_hash(ancestors[0], ancestor_object, top_ancestors)
         end
         ancestors unless bool_the_same
       end