washout_builder 1.7.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 159e07561571b409357453527454de91fc1ed030b715b663467d5609fc171e90
-  data.tar.gz: 763e07ae420b1897eb031e33cb0b5073cd534c6f262eb358b6e7d9a1c2f0a95e
+  metadata.gz: 0f24387c3759bd5136368bba80e629f8e86c916fd42c0b97f8108cf3adc89a33
+  data.tar.gz: 0f63bda842effeb14e2fae1847734c9ec62533589d71e58b1b8bb01761a052b3
 SHA512:
-  metadata.gz: 7a7d90b7e0e07f2de6be67edeb1fa0957e966c26da4bb53b1c14a38d9e8e25fec19ef6da7fb043c9ff9d4ff4f3506351854766b1a2c3f1cd25b9d5e97e0ca7e9
-  data.tar.gz: bc06865bdb9a5f2411cb84434659fb3a5c948107c69e41aee60893a5dc456f28945c4b0662f1bcd08a3966e900574024f529ca5f2f117356965592297437e01a
+  metadata.gz: 2a08d8be0d183473151a22f78d9eca0779f827d69cd6d049cb354070c1012a46015f147cf6b5dc5738e22de99c61e1fe791d5e05ba4021b38a16e01ce6c63587
+  data.tar.gz: fe79fedbef7cafc76fdd0e11e9838c22df2f64470654e65ee367d8f4c34dbb226106ddc05dd366a07de55d68d754d41094c4d73cd37e2d84c7c42fe9a6c24635

data/README.md

@@ -37,6 +37,21 @@ end
 
 If you don't set them and they are left with default nil values, you will have to use the old way, by manually mount the engine in the Rails routes configuration file (**config/routes.rb**) by following examples below.
 
+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.
+
+ 
 NEW Improvements in version 1.4.0
 ---------------------------------
 

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 ? "Array of #{complex_class}" : "#{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 ? "Array of #{complex_class}" : "#{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 ?  "Array of #{complex_class}" : "#{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?
+    real_class = find_correct_complex_type(complex_class)
     if output[0].multiplied
-      complex_return_type = "Array of #{complex_class}"
+      complex_return_type = "Array of #{real_class}"
     else
-      complex_return_type = "#{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/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

@@ -71,25 +71,6 @@ 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
       #
@@ -172,8 +153,8 @@ module WashoutBuilder
       def get_nested_complex_types(config, classes_defined)
         classes_defined = [] if classes_defined.blank?
         complex_class = find_complex_class_name(classes_defined)
-        fix_descendant_wash_out_type(config, complex_class)
-        unless complex_class.nil?
+        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
         classes_defined = complex_type_descendants(config, classes_defined)

data/lib/washout_builder/soap.rb

@@ -37,8 +37,8 @@ module WashoutBuilder
         current_action = soap_actions[action]
         base_param_class = WashoutBuilder::Type.base_param_class
         return if base_param_class.blank?
-        current_action[:builder_in] = base_param_class.parse_builder_def(soap_config, options[:args])
-        current_action[:builder_out] = base_param_class.parse_builder_def(soap_config, options[:return])
+        current_action[:builder_in] = base_param_class.parse_def(soap_config, options[:args])
+        current_action[:builder_out] = base_param_class.parse_def(soap_config, options[:return])
         current_action[:args_description] = options[:args_description].present? && options[:args_description].is_a?(Hash) ? options[:args_description].stringify_keys : {}
         current_action
       end

data/lib/washout_builder/version.rb

@@ -8,11 +8,11 @@ module WashoutBuilder
   # the module that is used to generate the gem version
   module VERSION
     # the major version of the gem
-    MAJOR = 1
+    MAJOR = 2
     # the minor version of the gem
-    MINOR = 7
+    MINOR = 0
     # the tiny version of the gem
-    TINY = 5
+    TINY = 0
     # if the version should be a prerelease
     PRE = nil
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: washout_builder
 version: !ruby/object:Gem::Version
-  version: 1.7.5
+  version: 2.0.0
 platform: ruby
 authors:
 - bogdanRada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2020-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: wash_out
@@ -62,6 +62,7 @@ files:
 - app/helpers/washout_builder_method_arguments_helper.rb
 - app/helpers/washout_builder_method_list_helper.rb
 - app/helpers/washout_builder_method_return_type_helper.rb
+- app/helpers/washout_builder_shared_helper.rb
 - app/views/wash_with_html/_complex_type.builder
 - app/views/wash_with_html/_fault_type.builder
 - app/views/wash_with_html/_public_method.builder
@@ -92,7 +93,6 @@ files:
 - lib/washout_builder/document/shared_complex_type.rb
 - lib/washout_builder/engine.rb
 - lib/washout_builder/env_checker.rb
-- lib/washout_builder/param.rb
 - lib/washout_builder/router.rb
 - lib/washout_builder/soap.rb
 - lib/washout_builder/type.rb

data/lib/washout_builder/param.rb

@@ -1,50 +0,0 @@
-module WashoutBuilder
-  # module that extends the base WashoutParam to allow parsing of definitions for building documentation
-  module Param
-    extend ActiveSupport::Concern
-
-    # Method that receives the arguments for a soap action (input or output) and tries to parse the definition (@see WashOutParam#parse_def)
-    #
-    # the following lines was removed from original method because when generating the documentation
-    #  the "source_class" attrtibute of the object was not the name of the class of the complex tyoe
-    # but instead was the name given in the hash
-    #
-    # if definition.is_a?(Class) && definition.ancestors.include?(WashOut::Type)
-    #        definition = definition.wash_out_param_map
-    #    end
-    #
-    # @example Given the class ProjectType as a "definition" argument, the complex type name should be  ProjectType and not "project"
-    #  class ProjectType < WashOut::Type
-    #  map :project => {
-    # :name                                    => :string,
-    #  :description                           => :string,
-    #  :users                                    => [{:mail => :string }],
-    #  }
-    # end
-    #
-    #
-    # @see WashoutBuilder::SOAP#soap_action
-    # @see WashOutParam#initialize
-    #
-    # @param [WasOut::SoapConfig] soap_config Holds the soap configuration for the entire web service
-    # @param [Object] definition  Any type of object ( this is passed from the soap action)
-    #
-    # @return [Type] description of returned object
-    def parse_builder_def(soap_config, definition)
-      raise '[] should not be used in your params. Use nil if you want to mark empty set.' if definition == []
-      return [] if definition.blank?
-
-      definition = { value: definition } unless definition.is_a?(Hash) # for arrays and symbols
-
-      definition.map do |name, opt|
-        if opt.is_a? self
-          opt
-        elsif opt.is_a? Array
-          new(soap_config, name, opt[0], true)
-        else
-          new(soap_config, name, opt)
-        end
-      end
-    end
-  end
-end