washout_builder 0.15.8 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88b534c64a3563ba35ec771c7b97c2c63dd5b156
-  data.tar.gz: c721fb7c1109b795e493131bbba777d313f53272
+  metadata.gz: c1c2aab790ac673d734f1ee42eb6f963e28076f5
+  data.tar.gz: b36593c650e341398e4291a2c3a72910b83b61e1
 SHA512:
-  metadata.gz: b197f87137546b005140fcb642d2b4c24208119e5c38e0d49b09d1bc1a77a4039c7545ed1f746563423f750c2a99b31179a8794e69a99b92adc849dd70f6343e
-  data.tar.gz: a8f48288bf579a0104e4b1b754b38c0fca1822b90cc126047d2f6b3dc99f186f8ab38478b712229ad7d46cf0f5e7d6236dedac901c85c1ecb6d046f724832ee7
+  metadata.gz: 9441ed5ed24a575495ab3b7d81df35db6f38026f593cde6e2111fea264af5403bc8120949932f6643c1f84cd8549084104c2aa4ed9df0d30c47e04c8c61987df
+  data.tar.gz: c7d5b37ec709f09b289d656192d35825aabcb58ea6fe6ef9bc0d6beccec276282e52df75b545b334423864c1d0a76a4b3694a882e32ae4ee2aac55cdc0bf7bf3

data/app/controllers/washout_builder/washout_builder_controller.rb

@@ -1,12 +1,19 @@
 require_relative '../../../lib/washout_builder/document/generator'
 module WashoutBuilder
+  # controller that is used to prit all available services or print the documentation for a specific service
   class WashoutBuilderController < ActionController::Base
     protect_from_forgery
 
     # Will show all api services if no name parameter is receiverd
-    # If a name parameter is present wiill try to use that and find a controller
+    # If a name parameter is present will try to use that and find a controller
     # that was that name by camelcasing the name .
     # IF a name is provided will show the documentation page for that controller
+    # @see #all_services
+    # @see WashoutBuilder::Document::Generator#new
+    #
+    # @return [void]
+    #
+    # @api public
     def all
       route = params[:name].present? ? controller_is_a_service?(params[:name]) : nil
       if route.present?
@@ -14,7 +21,9 @@ module WashoutBuilder
         render template: 'wash_with_html/doc', layout: false,
                content_type: 'text/html'
       else
-        all_services
+        @services = all_services
+        render template: 'wash_with_html/all_services', layout: false,
+               content_type: 'text/html'
       end
     end
 
@@ -22,9 +31,20 @@ module WashoutBuilder
 
     # tries to find all services by searching through the rails controller
     # and returns their namespace, endpoint and a documentation url
+    # @see map_controllers
+    #
+    #
+    # @return [Hash] options The hash that contains all information about available services
+    # @option options [String] :service_name (@see #controller_naming)  The name of the controller that is a  soap servive
+    # @option options [String]:namespace (@see #service_namespace ) The namespace of the soap service for that controller
+    # @option options [String] :endpoint (@see #service_endpoint ) The endpoint of the service controller
+    # @option options [String] :documentation_url (@see #service_documentation_url ) The url where the documentation can be seen in HTML
+    # for that service controller
+    #
+    # @api private
     def all_services
       @map_controllers = map_controllers { |route| route.defaults[:controller] }
-      @services = @map_controllers.blank? ? [] : @map_controllers.map do |controller_name|
+      @map_controllers.blank? ? [] : @map_controllers.map do |controller_name|
         {
           'service_name' => controller_naming(controller_name),
           'namespace' => service_namespace(controller_name),
@@ -32,23 +52,39 @@ module WashoutBuilder
           'documentation_url' => service_documentation_url(controller_name)
         }
       end
-
-      render template: 'wash_with_html/all_services', layout: false,
-             content_type: 'text/html'
     end
 
     # the way of converting from controller string in downcase in camelcase
+    # @param [String] controller  The controller name in downcase letter
+    #
+    # @return [String] The controller name in camelcase letters
+    #
+    # @api private
     def controller_naming(controller)
       controller.camelize
     end
 
     # checking if a route has the action for generating WSDL
+    # @param [ActionDispatch::Journey::Route] route The route that is used to check if can respond to _generate_wsdl action
+    #
+    # @return [Boolean] Returns true if the route can respond to _generate_wsdl action
+    #
+    # @api private
     def route_can_generate_wsdl?(route)
       route.defaults[:action] == '_generate_wsdl'
     end
 
     # method for getting all controllers that have the generate wsdl action or finding out
     # if a single controller is a soap service
+    # @see #route_can_generate_wsdl?
+    #
+    # @param [String] action The action is used to collect or find a particular route . Can only be *map* or *detect*
+    #
+    # @yield [ActionDispatch::Journey::Route] yield each route to the block while iterating through the routes
+    #
+    # @return [ActionDispatch::Journey::Route, Array<ActionDispatch::Journey::Route>] Can return either a collection of routes or a single route depending on the action
+    #
+    # @api private
     def map_controllers(action = 'map')
       res = Rails.application.routes.routes.send(action) do |route|
         if route_can_generate_wsdl?(route)
@@ -60,6 +96,14 @@ module WashoutBuilder
     end
 
     # checking if a controller is a soap service
+    # @see #map_controllers
+    # @see #controller_naming
+    #
+    # @param [String] controller The controller that is used to check if it is soap service
+    #
+    # @return [Boolean] Returns true if we find a route that can generate wsdl and the name of the route matches the name of the controller
+    #
+    # @api private
     def controller_is_a_service?(controller)
       map_controllers('detect') do |route|
         controller_naming(route.defaults[:controller]) == controller_naming(controller)
@@ -67,21 +111,45 @@ module WashoutBuilder
     end
 
     # getting the controller class from the controller string
+    # @see #controller_naming
+    #
+    # @param [String] controller The name of the controller
+    # @return [Class] the original controller class name
+    # @api private
     def controller_class(controller)
       controller_naming("#{controller}_controller").constantize
     end
 
     # retrieves the service namespace
+    # @see #controller_class
+    #
+    # the method receives the controlle name than will try to find the class  name
+    # of the controller and use the soap configuration of the class to
+    # retrive the namespace of the soap service
+    #
+    # @param [String] controller_name The name of the controller
+    # @return [String] The namespace of the soap service that is used in that controller
+    #
+    # @api private
     def service_namespace(controller_name)
       controller_class(controller_name).soap_config.namespace
     end
 
     # the endpoint is based on the namespace followed by /action suffix
+    # @see #service_namespace
+    #
+    # @param [String] controller_name The name of the controller
+    # @return [String] The endpoint of the web service
+    # @api private
     def service_endpoint(controller_name)
       service_namespace(controller_name).gsub('/wsdl', '/action')
     end
 
     # constructs the documentation url for a specific web service
+    #
+    # @param [String] controller_name The name of the controller
+    # @return [String] The documentation url for the web service ( relative to base url)
+    # @api private
     def service_documentation_url(controller_name)
       "#{washout_builder.root_url}#{controller_naming(controller_name)}"
     end

data/app/helpers/washout_builder_complex_type_helper.rb

@@ -1,7 +1,17 @@
+# module that is used for constructing complex types in HTML-Documentation
 module WashoutBuilderComplexTypeHelper
   # 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
+  # @see WashoutBuilder::Type::BASIC_TYPES
+  # @see #create_complex_element_type_html
+  #
+  # @param [Array] pre Array that contains the content that will be appended to the xml element li
+  # @param [WashOut::Param] element  the element that needs to be printed
+  #
+  # @return [void]
+  #
+  # @api public
   def create_element_type_html(pre, element)
     element.type = 'string' if element.type == 'text'
     element.type = 'integer' if element.type == 'int'
@@ -14,6 +24,15 @@ module WashoutBuilderComplexTypeHelper
 
   # checks if a complex attribute of a complex type is a array or not
   # and retrieves the complex class name of the attribute and prints it
+  # @see WashoutBuilder::Document::ComplexType#find_complex_class_name
+  # @see WashOutParam#multiplied
+  #
+  # @param [Array] pre Array that contains the content that will be appended to the xml element li
+  # @param [WashOut::Param] element  the element that needs to be printed
+  #
+  # @return [void]
+  #
+  # @api public
   def create_complex_element_type_html(pre, element)
     complex_class = element.find_complex_class_name
     return if complex_class.nil?

data/app/helpers/washout_builder_fault_type_helper.rb

@@ -2,27 +2,71 @@ module WashoutBuilderFaultTypeHelper
   # checks if a complex attribute of a complex type SoapFault is array or not
   # if the attribute is an array will print also the type of the elements contained in the array
   # otherwise will show the complex class of the attribute
+  #
+  # @param [Array] pre Array that contains the content that will be appended to the xml element li
+  # @param [Class] attr_primitive  xml li element to which the html will be appended to
+  # @param [Boolean] array  boolean that is used to know if ia primitive is a array of elements
+  #
+  # @return [void]
+  #
+  # @api public
   def create_fault_model_complex_element_type(pre, attr_primitive, attribute, array)
     attribute_primitive = array == true ? "Array of #{attr_primitive}" : "#{attr_primitive}"
     pre << "<a href='##{attr_primitive}'><span class='lightBlue'> #{attribute_primitive}</span></a>&nbsp;<span class='bold'>#{attribute}</span>"
   end
 
   # if the attribute is an array  this method is used to identify the type of the elements inside the array
+  # @see WashoutBuilder::Type::BASIC_TYPES
+  #
+  # @param [Hash] attr_details hash that contains the member type and determines if the member typs is complex or not
+  # @option attr_details [String] :member_type The member type of the element ( basic or complex type)
+  # @option attr_details [String]:primitive  the primitive determines if is an array or not
+  #
+  # @return [string] if the member tyoe is basic will return the type in downcase letter else will return the member type exactly as it is
+  #
+  # @api public
   def member_type_is_basic?(attr_details)
     WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:member_type].to_s.downcase) ? attr_details[:member_type].to_s.downcase : attr_details[:member_type]
   end
+
   # checks is the attribute has a primitive value or a complex value
+  # @see WashoutBuilder::Type::BASIC_TYPES
+  #
+  # @param [Hash] attr_details hash that contains the member type and determines if the member typs is complex or not
+  # @option attr_details [String] :member_type The member type of the element ( basic or complex type)
+  # @option attr_details [String]:primitive  the primitive determines if is an array or not
+  #
+  # @return [boolean]
+  #
+  # @api public
   def primitive_type_is_basic?(attr_details)
     WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:primitive].to_s.downcase)
   end
 
   # if the attribute value is of type nil the documentation will show string
   # otherwise the primitive value
+  # @param [Hash] attr_details hash that contains the member type and determines if the member typs is complex or not
+  # @option attr_details [String] :member_type The member type of the element ( basic or complex type)
+  # @option attr_details [String]:primitive  the primitive determines if is an array or not
+  #
+  # @return [String] if the primitive is nilclass will return string , otherwise will return the primitive
+  #
+  # @api public
   def get_primitive_type_string(attr_details)
     attr_details[:primitive].to_s.downcase == 'nilclass' ? 'string' : attr_details[:primitive].to_s.downcase
   end
 
   # if the attribute is of type array the method identifies the type of the elements inside the array
+  #
+  #  @see #member_type_is_basic?
+  #
+  # @param [Hash] attr_details hash that contains the member type and determines if the member typs is complex or not
+  # @option attr_details [String] :member_type The member type of the element ( basic or complex type)
+  # @option attr_details [String]:primitive  the primitive determines if is an array or not
+  #
+  # @return [String] if the primitive is array will call another methiod to check the member type otherwise will return the primitive
+  #
+  # @api public
   def get_member_type_string(attr_details)
     attr_details[:primitive].to_s.downcase == 'array' ? member_type_is_basic?(attr_details) : attr_details[:primitive]
   end
@@ -30,6 +74,21 @@ module WashoutBuilderFaultTypeHelper
   # this method is used to print all attributes of a SoapFault element
   # if the attribute value is a primitve value it will be shown in blue and will also show the type of the primitive
   # if is a complex type will use another method for finding out the complex class
+  #
+  # @see #primitive_type_is_basic?
+  # @see #create_fault_model_complex_element_type
+  # @see #get_member_type_string
+  #
+  # @param [Array] pre Array that contains the content that will be appended to the xml element li
+  # @param [String] attribute  The name of the attribute that needs to be printed
+  #
+  # @param [Hash] attr_details hash that contains the member type and determines if the member typs is complex or not
+  # @option attr_details [String] :member_type The member type of the element ( basic or complex type)
+  # @option attr_details [String]:primitive  the primitive determines if is an array or not
+  #
+  # @return [String] if the primitive is basic or nil , will return the primitive type and the attribute with blue, otherwise will print the complex type and the attribute
+  #
+  # @api public
   def create_html_fault_model_element_type(pre, attribute, attr_details)
     if primitive_type_is_basic?(attr_details) || attr_details[:primitive] == 'nilclass'
       pre << "<span class='blue'>#{get_primitive_type_string(attr_details)}</span>&nbsp;<span class='bold'>#{attribute}</span>"

data/app/helpers/washout_builder_method_arguments_helper.rb

@@ -1,4 +1,17 @@
 module WashoutBuilderMethodArgumentsHelper
+  # 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
+  # @see #create_method_argument_complex_element
+  # @see WashoutBuilder::Type::BASIC_TYPES
+  #
+  # @param [Array] pre Array that contains the content that will be appended to the xml
+  # @param [WashOut::Param] param the parameter what needs to be displayed
+  # @param [Integer] mlen  Determines if we need a spacer when appending the html or not
+  #
+  # @return [void]
+  #
+  # @api public
   def create_method_argument_element(pre, param, mlen)
     spacer = '    '
     complex_class = param.find_complex_class_name
@@ -10,12 +23,33 @@ module WashoutBuilderMethodArgumentsHelper
     end
   end
 
+  # displayes an argument of a method as complex type and determines if is an array of types or not
+  #
+  # @param [Array] pre Array that contains the content that will be appended to the xml
+  # @param [WashOut::Param] param the parameter what needs to be displayed
+  # @param [Bololean] use_spacer  Determines if we need a spacer when appending the html or not
+  # @param [String] spacer  the spacer that needs to be prepended if use_spacer is true
+  # @param [Class] complex_class  The name of the complex type
+  #
+  # @return [void]
+  #
+  # @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>"
   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,
+  # and if  the current index is equal to the size of argyments, will display a ')' sign
+  #
+  # @param [Builder::XmlMarkup] xml the markup builder that is used to insert HTML line breaks or span elements
+  # @param [Integer] j the index of the previous argument that was displayed (
+  # @param [Integer] mlen  This determines how many arguments the method that is displayed has
+  #
+  # @return [String]
+  #
+  # @api public
   def create_argument_element_spacer(xml, j, mlen)
     if j < (mlen - 1)
       xml.span ', '
@@ -27,6 +61,18 @@ module WashoutBuilderMethodArgumentsHelper
     xml.span('class' => 'bold') { |y| y << ')' }
   end
 
+  # this method will go through each of the arguments print them and then check if we need a spacer after it
+  #
+  #  @see #create_method_argument_element
+  #  @see #create_argument_element_spacer
+  #
+  # @param [Builder::XmlMarkup] xml the markup builder that is used to insert HTML line breaks or span elements
+  # @param [Array] pre  The array that holds the html that will be appended to the xml
+  # @param [Array] input  An array with arguments
+  #
+  # @return [String]
+  #
+  # @api public
   def create_html_public_method_arguments(xml, pre, input)
     mlen = input.size
     xml.br if mlen > 1

data/app/helpers/washout_builder_method_list_helper.rb

@@ -1,4 +1,13 @@
 module WashoutBuilderMethodListHelper
+  # 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
+  # @param [Array] complex_class  The array that holds the html that will be appended to the xml
+  # @param [Array<WashOut::Param>] builder_out  An array of params ( will contain a single position in the array) this is used to determine if the class is an array or not
+  #
+  # @return [String]
+  #
+  # @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}"
     xml.span('class' => 'pre') do
@@ -10,6 +19,17 @@ module WashoutBuilderMethodListHelper
     end
   end
 
+  # this method will go through each of the arguments print them and then check if we need a spacer after it
+  # @see WashoutBuilder::Document::ComplexType#find_complex_class_name
+  # @see WashoutBuilder::Type::BASIC_TYPES
+  # @see #create_return_complex_type_list_html
+  #
+  # @param [Builder::XmlMarkup] xml the markup builder that is used to insert HTML line breaks or span elements
+  # @param [Array<WashOut::Param>] output t  An array of params that need to be displayed, will check the type of each and will display it accordingly if is complex type or not
+  #
+  # @return [String]
+  #
+  # @api public
   def create_return_type_list_html(xml, output)
     if output.nil?
       xml.span('class' => 'pre') { |sp| sp << 'void' }
@@ -22,7 +42,7 @@ module WashoutBuilderMethodListHelper
           end
         end
       else
-        create_return_complex_type_html(xml, complex_class, output) unless complex_class.nil?
+        create_return_complex_type_list_html(xml, complex_class, output) unless complex_class.nil?
       end
     end
   end

data/app/helpers/washout_builder_method_return_type_helper.rb

@@ -1,4 +1,16 @@
 module WashoutBuilderMethodReturnTypeHelper
+  # 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
+  # @see #html_public_method_complex_type
+  #
+  # @param [Builder::XmlMarkup] xml the markup builder that is used to insert HTML line breaks or span elements
+  # @param [Array] pre The array that contains the html that will be appended to xml
+  # @param [Array<WashOut::Param>] output   An array of params that need to be displayed, will check the type of each and will display it accordingly if is complex type or not
+  #
+  # @return [String]
+  #
+  # @api public
   def create_html_public_method_return_type(xml, pre, output)
     if !output.nil?
       complex_class = output[0].find_complex_class_name
@@ -12,6 +24,16 @@ module WashoutBuilderMethodReturnTypeHelper
     end
   end
 
+  # this method will go through each of the arguments print them and then check if we need a spacer after it
+  #
+  #
+  # @param [Array] pre The array that contains the html that will be appended to xml
+  # @param [Array<WashOut::Param>] output  An array of params that need to be displayed, will check the type of each and will display it accordingly if is complex type or not
+  # @param [Class] complex_class the name of the complex class
+
+  # @return [String]
+  #
+  # @api public
   def html_public_method_complex_type(pre, output, complex_class)
     return if complex_class.nil?
     if output[0].multiplied == false

data/app/views/wash_with_html/_complex_type.builder

@@ -1,9 +1,9 @@
 
 unless object.blank?
   xml.a( "name" => "#{class_name}")  { }
-  xml.h3  { |pre| pre << "#{class_name} #{ancestors.blank? ? "" : "<small>(extends <a href='##{ancestors[0].to_s.classify}'>#{ancestors[0].to_s.classify}</a>)</small>" } " }   
+  xml.h3  { |pre| pre << "#{class_name} #{ancestors.blank? ? "" : "<small>(extends <a href='##{ancestors[0].to_s.classify}'>#{ancestors[0].to_s.classify}</a>)</small>" } " }
+
 
-  
   if object.is_a?(WashOut::Param)
     xml.ul("class" => "pre") {
       object.map.each do |element|
@@ -13,4 +13,4 @@ unless object.blank?
       end
     }
   end
-end
+end

data/lib/washout_builder/document/complex_type.rb

@@ -1,21 +1,50 @@
 require_relative './shared_complex_type'
 module WashoutBuilder
+  # namespace of the class
   module Document
+    #  class that is used for current Washout::Param object to know his complex type name and structure and detect ancestors and descendants
     module ComplexType
       extend ActiveSupport::Concern
       include WashoutBuilder::Document::SharedComplexType
 
+      # 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
+      #
+      # @return [Class] the complex type name of the current object
+      #
+      # @api public
       def find_complex_class_name(defined = [])
         complex_class = struct? ? basic_type.tr('.', '/').camelize : nil
         check_duplicate_complex_class(defined, complex_class) unless complex_class.nil? || 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 [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
+      #
+      # @api public
       def check_duplicate_complex_class(defined, complex_class)
         complex_obj_found = defined.find { |hash| hash[:class] == complex_class }
         raise "Duplicate use of `#{basic_type}` type name. Consider using classified types." if !complex_obj_found.nil? && struct? && !classified?
       end
 
+      # finds the complex class ancestors if the current object is classified, otherwise returns nil
+      # @see WashOut::Param#classified?
+      # @see #get_class_ancestors
+      #
+      # @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
+      #
+      # @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
       end
@@ -31,10 +60,6 @@ module WashoutBuilder
         self.map = map.delete_if { |element| keys.include?(element.name) }
       end
 
-      #      def get_ancestor_structure
-      #        {self.class.to_s.downcase =>  self.class.columns_hash.inject({}) {|h, (k,v)|  h["#{k}"]="#{v.type}".to_sym; h } }
-      #      end
-
       def fix_descendant_wash_out_type(config, complex_class)
         param_class = begin
           complex_class.is_a?(Class) ? complex_class : complex_class.constantize
@@ -97,7 +122,7 @@ module WashoutBuilder
 
       def complex_type_hash(class_name, object, ancestors)
         {
-          'class' => class_name,
+          class: class_name,
           obj: object,
           ancestors: ancestors
         }

data/lib/washout_builder/soap.rb

@@ -7,13 +7,19 @@ module WashoutBuilder
     include WashOut::Rails::Controller if defined?(WashOut::Rails::Controller)
 
     module ClassMethods
-      attr_accessor :soap_actions
+      attr_accessor :soap_actions, :washout_builder_action
       # Define a SOAP action +action+. The function has two required +options+:
       # :args and :return. Each is a type +definition+ of format described in
       # WashOut::Param#parse_def.
       #
       # An optional option :to can be passed to allow for names of SOAP actions
       # which are not valid Ruby function names.
+      # @param  [Symbol, Class]  action the action that is requested
+      # @param [Hash] options  the options used for
+      #
+      # @return [void]
+      #
+      # @api public
       def soap_action(action, options = {})
         original_soap_action(action, options)
 

data/lib/washout_builder/version.rb

@@ -5,8 +5,8 @@ module WashoutBuilder # Returns the version of the currently loaded Rails as a <
 
   module VERSION
     MAJOR = 0
-    MINOR = 15
-    TINY = 8
+    MINOR = 16
+    TINY = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/spec/app/helpers/washout_builder_method_list_helper_spec.rb

@@ -45,7 +45,7 @@ describe WashoutBuilderMethodListHelper, type: :helper do
     it 'returns complex type' do
       expected = 'some expected string'
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(false)
-      helper.expects(:create_return_complex_type_html).with(instance_of(Builder::XmlMarkup), complex_class, output).returns(expected)
+      helper.expects(:create_return_complex_type_list_html).with(instance_of(Builder::XmlMarkup), complex_class, output).returns(expected)
       result = helper.create_return_type_list_html(xml, output)
       expect(result).to eq(expected)
     end

data/spec/spec_helper.rb

@@ -34,7 +34,6 @@ require 'ostruct'
 
 require File.expand_path('../dummy/config/environment.rb', __FILE__)
 require File.expand_path('../../config/routes.rb', __FILE__)
-require 'rails/test_help'
 require 'rspec/rails'
 require 'savon'
 require 'wash_out'
@@ -48,7 +47,6 @@ Rails.backtrace_cleaner.remove_silencers!
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
-FIxMinitest.disable_autorun
 # Test::Unit.run = true if defined?(Test::Unit) && Test::Unit.respond_to?(:run=)
 RSpec.configure do |config|
   require 'rspec/expectations'

data/washout_builder.gemspec

@@ -10,13 +10,13 @@ Gem::Specification.new do |s|
   s.description = "WashOut Soap Service HTML-Documentation generator (extends WashOut https://github.com/inossidabile/wash_out/) "
   s.authors     = ["bogdanRada"]
   s.date =  Date.today
-  
+
   s.licenses = ["MIT"]
   s.files = `git ls-files`.split("\n")
   s.test_files = s.files.grep(/^(spec)/)
   s.require_paths = ["lib"]
   s.add_runtime_dependency 'wash_out', '~> 0.9.1', '>= 0.9.1'
-  
+
   s.add_development_dependency 'wasabi', '~> 3.5', '>= 3.5'
   s.add_development_dependency 'savon', '~> 2.11', '>= 2.11'
   s.add_development_dependency 'httpi', '~> 2.4', '>= 2.4'
@@ -34,12 +34,12 @@ Gem::Specification.new do |s|
   #  s.add_development_dependency 'codeclimate-test-reporter','~> 0.3', '>= 0.3'
   #  s.add_development_dependency 'rubyntlm','~> 0.3.4', '>= 0.3'
   s.add_development_dependency 'rvm-tester','~> 1.1', '>= 1.1'
-  s.add_development_dependency 'wwtd','~> 0.9', '>= 0.9.1'
-  
+  s.add_development_dependency 'wwtd','~> 1.0', '>= 1.0'
+
   s.add_development_dependency 'capybara', '~> 2.4', '>= 2.4'
   s.add_development_dependency 'selenium-webdriver',  '~> 2.41', '>= 2.41.0'
   s.add_development_dependency 'headless','~> 2.2', '>= 2.2'
-  
+
   s.add_development_dependency 'rubocop',  '~> 0.3', '>= 0.33'
   s.add_development_dependency 'phare', '~> 0.7', '>= 0.7'
   s.add_development_dependency 'yard', '~> 0.8.7', '>= 0.8.7'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: washout_builder
 version: !ruby/object:Gem::Version
-  version: 0.15.8
+  version: 0.16.0
 platform: ruby
 authors:
 - bogdanRada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-12 00:00:00.000000000 Z
+date: 2015-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: wash_out
@@ -316,20 +316,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.1
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.1
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
@@ -651,7 +651,6 @@ files:
 - spec/support/complex_types/fluffy_container.rb
 - spec/support/complex_types/project_type.rb
 - spec/support/complex_types/test_type.rb
-- spec/support/fix_minitest.rb
 - washout_builder.gemspec
 homepage: http://github.com/bogdanRada/washout_builder/
 licenses:
@@ -719,5 +718,4 @@ test_files:
 - spec/support/complex_types/fluffy_container.rb
 - spec/support/complex_types/project_type.rb
 - spec/support/complex_types/test_type.rb
-- spec/support/fix_minitest.rb
 has_rdoc: 

data/spec/support/fix_minitest.rb

@@ -1,38 +0,0 @@
-
-module FIxMinitest
-  def self.disable_autorun
-    disable_auto_runner
-    override_minitest_run
-    override_minitest_unit_run
-  end
-
-  # rubocop:disable all
-  def self.override_minitest_run
-    Minitest.instance_eval do
-      def run(*)
-        FIxMinitest.run_mininitest
-      end    
-    end if defined?(Minitest)
-  end
- 
-  # rubocop:disable NestedMethodDefinition
-  def self.run_mininitest
-    case $ERROR_INFO
-      when SystemExit
-        $ERROR_INFO.status
-      else
-        true
-    end
-  end
-  # rubocop:disable NestedMethodDefinition
-  def self.override_minitest_unit_run
-    Minitest::Unit.class_eval do
-      def run(*)
-      end
-    end if defined?(Minitest) && defined?(Minitest::Unit)
-  end
-
-  def self.disable_auto_runner
-    Test::Unit::Runner.module_eval('@@stop_auto_run = true') if defined?(Test::Unit::Runner)
-  end
-end