washout_builder 1.7.4 → 2.0.4

data/lib/washout_builder/document/exception_model.rb

@@ -16,18 +16,18 @@ module WashoutBuilder
       # @see #find_fault_model_structure
       # @see #fault_without_inheritable_elements
       #
-      # @param [Array<Hash>] defined An array that contains all the information about all the exception classes found so far
+      # @param [Array<Hash>] classes_defined An array that contains all the information about all the exception classes found so far
       # @param [Boolean] _debug = false An optional parameter used for debugging purposes
       # @return [Array<Class>] Array with all the exception classes from which the current exception class inherits from
       # @api public
-      def get_fault_class_ancestors(defined, _debug = false)
+      def get_fault_class_ancestors(classes_defined, _debug = false)
         bool_the_same = false
         ancestors = fault_ancestors
         if ancestors.blank?
-          defined << fault_ancestor_hash(find_fault_model_structure, [])
+          classes_defined << fault_ancestor_hash(find_fault_model_structure, [])
         else
-          defined << fault_ancestor_hash(fault_without_inheritable_elements(ancestors), ancestors)
-          ancestors[0].get_fault_class_ancestors(defined)
+          classes_defined << fault_ancestor_hash(fault_without_inheritable_elements(ancestors), ancestors)
+          ancestors[0].get_fault_class_ancestors(classes_defined)
         end
         ancestors unless bool_the_same
       end
@@ -47,7 +47,7 @@ module WashoutBuilder
       # @return [Array<Class>] Returns an array with all the classes from which the current exception class inherits from
       # @api public
       def fault_ancestors
-        get_complex_type_ancestors(self, ['ActiveRecord::Base', 'Object', 'BasicObject', 'Exception'])
+        get_complex_type_ancestors(self, %w(ActiveRecord::Base Object BasicObject Exception))
       end
 
       # constructs the structure of the current exception class by holding the instance, the structure, and its ancestors
@@ -80,9 +80,9 @@ module WashoutBuilder
       # @api public
       def check_valid_fault_method?(method)
         method != :== && method != :! &&
-          (instance_methods.include?(:"#{method}=") ||
-            instance_methods.include?(:"#{method}")
-          )
+            (instance_methods.include?(:"#{method}=") ||
+                instance_methods.include?(:"#{method}")
+            )
       end
 
       # tries to fins all instance methods that have both a setter and a getter of the curent class
@@ -90,7 +90,6 @@ module WashoutBuilder
       # @return [Array<String>] An array with all the atrributes and instance methods that have both a setter and a getter
       # @api public
       def find_fault_attributes
-        attrs = []
         attrs = instance_methods(nil).map do |method|
           method.to_s if check_valid_fault_method?(method)
         end
@@ -105,12 +104,12 @@ module WashoutBuilder
       # @api public
       def get_fault_type_method(method_name)
         case method_name.to_s.downcase
-          when 'code'
-            'integer'
-          when 'message', 'backtrace'
-            'string'
-          else
-            'string'
+        when 'code'
+          'integer'
+        when 'message', 'backtrace'
+          'string'
+        else
+          'string'
         end
       end
 
@@ -126,8 +125,8 @@ module WashoutBuilder
           method_name = method_name.to_s.end_with?('=') ? method_name.to_s.delete('=') : method_name
           primitive_type = get_fault_type_method(method_name)
           h["#{method_name}"] = {
-            primitive: "#{primitive_type}",
-            member_type: nil
+              primitive: "#{primitive_type}",
+              member_type: nil
           }
         end
         h

data/lib/washout_builder/document/generator.rb

@@ -164,11 +164,11 @@ module WashoutBuilder
       # @return [Array<WashOut::Param>] Returns an array with all the complex types sorted alphabetically
       # @api public
       def complex_types
-        defined = []
+        classes_defined = []
         (input_types + output_types).each do |p|
-          defined.concat(p.get_nested_complex_types(config, defined))
+          classes_defined.concat(p.get_nested_complex_types(config, classes_defined))
         end
-        defined = sort_complex_types(defined, 'class')
+        sort_complex_types(classes_defined, 'class')
       end
 
       # Returns an array with all the operations that can raise an exception at least or more
@@ -205,9 +205,9 @@ module WashoutBuilder
       # @api public
       def get_complex_fault_types(base_fault_array)
         fault_types = []
-        defined = filter_exceptions_raised
-        defined = defined.blank? ? base_fault_array : defined.concat(base_fault_array)
-        defined.each { |exception_class| exception_class.get_fault_class_ancestors(fault_types, true) } unless defined.blank?
+        classes_defined = filter_exceptions_raised
+        classes_defined = classes_defined.blank? ? base_fault_array : classes_defined.concat(base_fault_array)
+        classes_defined.each { |exception_class| exception_class.get_fault_class_ancestors(fault_types, true) } unless classes_defined.blank?
         fault_types
       end
 

data/lib/washout_builder/engine.rb

@@ -4,6 +4,7 @@ module WashoutBuilder
   class Engine < ::Rails::Engine
     isolate_namespace WashoutBuilder
     config.washout_builder = ActiveSupport::OrderedOptions.new
+
     initializer 'washout_builder.configuration' do |app|
       mounted_path = app.config.washout_builder[:mounted_path]
       if WashoutBuilder::EnvChecker.new(app).available_for_env?(Rails.env)

data/lib/washout_builder/env_checker.rb

@@ -9,7 +9,7 @@ module WashoutBuilder
     end
 
     def available_for_env?(env_name)
-      if (whitelist.present? || blacklist.present?)
+      if whitelist.present? || blacklist.present?
         if whitelist.find{|a| blacklist.include?(a) }.blank?
           if whitelist.include?('*') || (!valid_for_env?(blacklist, env_name) && valid_for_env?(whitelist, env_name))
             return true
@@ -18,7 +18,7 @@ module WashoutBuilder
       else
         return true
       end
-      return false
+      false
     end
 
 

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,9 +8,9 @@ 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 = 4
     # if the version should be a prerelease

data/spec/app/controllers/washout_builder_controller_spec.rb

@@ -11,8 +11,8 @@ describe WashoutBuilder::WashoutBuilderController, type: :controller do
 
   let(:soap_config) do
     OpenStruct.new(
-    camelize_wsdl: false,
-    namespace: '/api/wsdl'
+        camelize_wsdl: false,
+        namespace: '/api/wsdl'
     )
   end
 
@@ -33,7 +33,7 @@ describe WashoutBuilder::WashoutBuilderController, type: :controller do
   it 'renders the template' do
     get :all
     expect(subject.instance_variable_get(:@file_to_serve)).to eq('wash_with_html/all_services')
-    expect(response.content_type).to eq("text/html")
+    expect(response.media_type).to eq("text/html")
     expect(response).to have_http_status(:ok)
   end
 
@@ -52,7 +52,7 @@ describe WashoutBuilder::WashoutBuilderController, type: :controller do
       get :all, params
     end
     expect(subject.instance_variable_get(:@file_to_serve)).to eq('wash_with_html/doc')
-    expect(response.content_type).to eq("text/html")
+    expect(response.media_type).to eq("text/html")
     expect(response).to have_http_status(:ok)
   end
 end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
   <title>Dummy</title>
   <%= stylesheet_link_tag :all %>

data/spec/dummy/public/404.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
   <title>The page you were looking for doesn't exist (404)</title>
   <style type="text/css">

data/spec/dummy/public/422.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
   <title>The change you wanted was rejected (422)</title>
   <style type="text/css">

data/spec/dummy/public/500.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
   <title>We're sorry, but something went wrong (500)</title>
   <style type="text/css">

data/spec/lib/washout_builder/document/complex_type_spec.rb

@@ -4,9 +4,9 @@ require 'spec_helper'
 describe WashoutBuilder::Document::ComplexType do
   let(:soap_config) do
     OpenStruct.new(
-      camelize_wsdl: false,
-      namespace: '/api/wsdl',
-      description: 'some description'
+        camelize_wsdl: false,
+        namespace: '/api/wsdl',
+        description: 'some description'
     )
   end
 
@@ -14,33 +14,29 @@ describe WashoutBuilder::Document::ComplexType do
   let(:namespaced_object) { get_wash_out_param(Api::TestType) }
 
   it 'returns the complex class name' do
-    expect(subject.find_complex_class_name).to eq('ProjectType')
+    expect(subject.find_complex_class_name).to eq('Project')
   end
 
-  it 'returns the complex class name' do
-    expect(subject.find_complex_class_name).to eq('ProjectType')
+  it 'returns the complex class with namespace' do
+    expect(namespaced_object.find_complex_class_name).to eq('Project')
   end
 
-  it 'returns the complex class with namespace' do
-    expect(namespaced_object.find_complex_class_name).to eq('Api::TestType')
+  it 'does not return error if classname already detected (only used for hashes) and same structure' do
+    subject.stubs(:classified?).returns(false)
+    subject.stubs(:basic_type).returns('ProjectType')
+    classes_defined = [{ class: 'ProjectType', obj: get_wash_out_param(ProjectType), ancestors: [] }]
+    expect { subject.find_complex_class_name(classes_defined) }.to_not raise_error(RuntimeError, 'Duplicate use of `ProjectType` type name. Consider using classified types.')
   end
 
   it 'returns error if classname already detected (only used for hashes)' do
     subject.stubs(:classified?).returns(false)
     subject.stubs(:basic_type).returns('ProjectType')
-    defined = [{ class: 'ProjectType' }]
-    expect { subject.find_complex_class_name(defined) }.to raise_error(RuntimeError, 'Duplicate use of `ProjectType` type name. Consider using classified types.')
+    classes_defined = [{ class: 'ProjectType', obj: get_wash_out_param(Api::TestType), ancestors: [] }]
+    expect { subject.find_complex_class_name(classes_defined) }.to raise_error(RuntimeError, 'Duplicate use of `ProjectType` type name. Consider using classified types.')
   end
 
   it 'returns the param structure' do
-    expect(subject.find_param_structure).to eq('project' => 'struct')
-  end
-
-  it 'fixes the first descendant ' do
-    descendant = get_wash_out_param(ProjectType.wash_out_param_map)
-    subject.fix_descendant_wash_out_type(soap_config, ProjectType)
-    expect(subject.name).to eq(descendant.name)
-    expect(subject.map[0].find_param_structure).to eq(descendant.map[0].find_param_structure)
+    expect(subject.find_param_structure).to eq("description"=>"string", "name"=>"string", "users"=>"struct")
   end
 
   it 'same as ancestor' do
@@ -79,18 +75,18 @@ describe WashoutBuilder::Document::ComplexType do
 
   describe '#complex_type_descendants' do
     it 'returns empty array if not struct?' do
-      defined = []
+      classes_defined = []
       subject.stubs(:struct?).returns(false)
-      expect(subject.complex_type_descendants(soap_config, defined)).to eq(defined)
+      expect(subject.complex_type_descendants(soap_config, classes_defined)).to eq(classes_defined)
     end
 
     it 'returns the descendants if  struct?' do
-      defined = []
+      classes_defined = []
       subject.map.each do |obj|
-        obj.expects(:get_nested_complex_types).with(soap_config, defined).returns([obj.name])
+        obj.expects(:get_nested_complex_types).with(soap_config, classes_defined).returns([obj.name])
       end
       subject.stubs(:struct?).returns(true)
-      expect(subject.complex_type_descendants(soap_config, defined)).to eq(subject.map.map(&:name))
+      expect(subject.complex_type_descendants(soap_config, classes_defined)).to eq(subject.map.map(&:name))
     end
   end
 
@@ -101,21 +97,20 @@ describe WashoutBuilder::Document::ComplexType do
     let(:expected) { [complex_type_hash] }
 
     it 'returns the complex class ancestors' do
-      defined = []
-      subject.expects(:find_complex_class_name).with(defined).returns(complex_class)
-      subject.expects(:fix_descendant_wash_out_type).with(soap_config, complex_class).returns(true)
-      subject.expects(:complex_type_ancestors).with(soap_config, complex_class, defined).returns(ancestors)
+      classes_defined = []
+      subject.expects(:find_complex_class_name).with(classes_defined).returns(complex_class)
+      subject.expects(:find_class_from_string).with(complex_class).returns(nil)
+      subject.expects(:complex_type_ancestors).with(soap_config, complex_class, classes_defined).returns(ancestors)
       subject.expects(:complex_type_hash).with(complex_class, subject, ancestors).returns(complex_type_hash)
       subject.expects(:complex_type_descendants).with(soap_config, [complex_type_hash]).returns(expected)
-      expect(subject.get_nested_complex_types(soap_config, defined)).to eq(expected)
+      expect(subject.get_nested_complex_types(soap_config, classes_defined)).to eq(expected)
     end
 
     it 'returns the the descendants' do
-      defined = nil
+      classes_defined = nil
       subject.expects(:find_complex_class_name).with([]).returns(nil)
-      subject.expects(:fix_descendant_wash_out_type).with(soap_config, nil).returns(true)
       subject.expects(:complex_type_descendants).with(soap_config, []).returns(expected)
-      expect(subject.get_nested_complex_types(soap_config, defined)).to eq(expected)
+      expect(subject.get_nested_complex_types(soap_config, classes_defined)).to eq(expected)
     end
   end
 
@@ -139,7 +134,7 @@ describe WashoutBuilder::Document::ComplexType do
 
   describe '#get_class_ancestors' do
     let(:class_name) { 'ProjectType' }
-    let(:defined) { [] }
+    let(:classes_defined) { [] }
     let(:ancestors) { ['SomeInexistentClass'] }
     let(:ancestor_structure) { { ancestors[0].to_s.downcase => 'bla' } }
     let(:top_ancestors) {}
@@ -147,7 +142,7 @@ describe WashoutBuilder::Document::ComplexType do
 
     it 'returns nil if no ancestors' do
       subject.expects(:get_ancestors).with(class_name).returns(nil)
-      expect(subject.get_class_ancestors(soap_config, class_name, defined)).to eq(nil)
+      expect(subject.get_class_ancestors(soap_config, class_name, classes_defined)).to eq(nil)
     end
 
     it 'returns the ancestors and the top ones' do
@@ -157,15 +152,16 @@ describe WashoutBuilder::Document::ComplexType do
       WashOut::Param.stubs(:parse_def).returns([namespaced_object])
       subject.expects(:same_structure_as_ancestor?).with(namespaced_object).returns(false)
       subject.expects(:complex_type_hash).returns(complex_type_hash)
-      expect(subject.get_class_ancestors(soap_config, class_name, defined)).to eq([complex_type_hash])
+      expect(subject.get_class_ancestors(soap_config, class_name, classes_defined)).to eq([complex_type_hash])
     end
 
     it 'returns nil if same structure as ancestor' do
+      namespaced_object
       subject.expects(:get_ancestors).with(class_name).returns(ancestors)
       subject.expects(:ancestor_structure).with(ancestors).returns(ancestor_structure)
-      WashOut::Param.stubs(:parse_def).returns([namespaced_object])
+      WashOut::Param.stubs(:parse_def).with(soap_config, ancestor_structure).returns([namespaced_object])
       subject.expects(:same_structure_as_ancestor?).with(namespaced_object).returns(true)
-      expect(subject.get_class_ancestors(soap_config, class_name, defined)).to eq(nil)
+      expect(subject.get_class_ancestors(soap_config, class_name, classes_defined)).to eq(nil)
     end
   end
 end

data/spec/lib/washout_builder/document/exception_model_spec.rb

@@ -20,7 +20,7 @@ describe WashoutBuilder::Document::ExceptionModel do
 
   specify { expect(InheritedExceptionModel.included_modules).to include(WashoutBuilder::Document::SharedComplexType) }
 
-  def fault_ancestor_hash(subject, structure, ancestors)
+  def exception_ancestor_hash(subject, structure, ancestors)
     { fault: subject, structure: structure, ancestors: ancestors }
   end
 
@@ -48,11 +48,11 @@ describe WashoutBuilder::Document::ExceptionModel do
   end
 
   it 'fault_ancestor_hash' do
-    expect(subject.fault_ancestor_hash(structure, ancestors)).to eq(fault_ancestor_hash(subject, structure, ancestors))
+    expect(subject.fault_ancestor_hash(structure, ancestors)).to eq(exception_ancestor_hash(subject, structure, ancestors))
   end
 
   it 'gets the fault_ancestors' do
-    subject.expects(:get_complex_type_ancestors).with(subject, ['ActiveRecord::Base', 'Object', 'BasicObject', 'Exception']).returns(ancestors)
+    subject.expects(:get_complex_type_ancestors).with(subject, %w(ActiveRecord::Base Object BasicObject Exception)).returns(ancestors)
     expect(subject.fault_ancestors).to eq ancestors
   end
 
@@ -69,12 +69,12 @@ describe WashoutBuilder::Document::ExceptionModel do
   it 'gets the ancestors' do
     subject.expects(:fault_ancestors).returns(nil)
     subject.expects(:find_fault_model_structure).returns(structure)
-    subject.expects(:fault_ancestor_hash).with(structure, []).returns(fault_ancestor_hash(subject, structure, ancestors))
+    subject.expects(:fault_ancestor_hash).with(structure, []).returns(exception_ancestor_hash(subject, structure, ancestors))
     expect(subject.get_fault_class_ancestors([])).to eq(nil)
   end
 
   it 'gets the ancestors' do
-    expected_defined = fault_ancestor_hash(subject, structure, ancestors)
+    expected_defined = exception_ancestor_hash(subject, structure, ancestors)
     subject.expects(:fault_ancestors).returns(ancestors)
     subject.expects(:fault_without_inheritable_elements).with(ancestors).returns(structure)
     subject.expects(:fault_ancestor_hash).returns(expected_defined)

data/spec/spec_helper.rb

@@ -98,11 +98,11 @@ end
 class WashoutBuilderTestError < base_exception
 end
 
-def get_wash_out_param(class_name_or_structure, soap_config = OpenStruct.new(
+def get_wash_out_param(class_or_struct, soap_config = OpenStruct.new(
   camelize_wsdl: false,
   namespace: '/api/wsdl'
 ))
-  WashOut::Param.parse_builder_def(soap_config, class_name_or_structure)[0]
+  WashOut::Param.parse_def(soap_config, class_or_struct)[0]
 end
 
 class Hash
@@ -133,6 +133,16 @@ class Hash
   end
 end
 
+Builder::XmlBase.class_eval do
+
+  alias_method :old_method_missing, :method_missing
+
+  def method_missing(sym, *args, &block)
+    return if ['inspect'].include?(sym.to_s)
+    old_method_missing(sym, *args, &block)
+  end
+end
+
 unless defined?(silence_stream) # Rails 5
   def silence_stream(stream)
     old_stream = stream.dup
@@ -144,3 +154,28 @@ unless defined?(silence_stream) # Rails 5
     old_stream.close
   end
 end
+
+# TODO: remove this when wasabi will update their code
+require 'uri'
+if !defined?(::URI.unescape)
+  ::URI.class_eval do
+    # this was removed in this commit
+    # https://github.com/ruby/uri/commit/61c6a47ebf1f2726b60a2bbd70964d64e14b1f98
+    # so we are adding it back because we need to be compatible with wasabi on ruby 3.0.0
+    module UriEscapeBackport
+
+      def escape(*arg)
+        ::URI::DEFAULT_PARSER.escape(*arg)
+      end
+
+      alias encode escape
+
+      def unescape(*arg)
+        ::URI::DEFAULT_PARSER.unescape(*arg)
+      end
+
+      alias decode unescape
+    end
+    extend UriEscapeBackport
+  end
+end