washout_builder 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f24387c3759bd5136368bba80e629f8e86c916fd42c0b97f8108cf3adc89a33
-  data.tar.gz: 0f63bda842effeb14e2fae1847734c9ec62533589d71e58b1b8bb01761a052b3
+  metadata.gz: 13eb15f962ae4e1c5ee71fe3eee2acdbcbf1db246169441bea159ee0f88c9407
+  data.tar.gz: 4541c0c078cf08f78e31d739735e49b861a511e513d51b3457a66fe2b1668813
 SHA512:
-  metadata.gz: 2a08d8be0d183473151a22f78d9eca0779f827d69cd6d049cb354070c1012a46015f147cf6b5dc5738e22de99c61e1fe791d5e05ba4021b38a16e01ce6c63587
-  data.tar.gz: fe79fedbef7cafc76fdd0e11e9838c22df2f64470654e65ee367d8f4c34dbb226106ddc05dd366a07de55d68d754d41094c4d73cd37e2d84c7c42fe9a6c24635
+  metadata.gz: a98832565f48093348b2664bec25aa9252a4215b976e28be23f781614e66e26c6e9f4a1c4f5ba5b9324366977d80fc314956d823ae82ced695f4d7ded18dd509
+  data.tar.gz: 7384869be3901fe1fb340e78522aa4d86c27a1e7141212f1946d074b1f52b7928714c679be1206661d728f2344427b555ea4d300841033b8cb69d37374f462be

data/README.md

@@ -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
 ---------------------------------
 
@@ -37,21 +58,6 @@ 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/lib/washout_builder/document/complex_type.rb

@@ -30,7 +30,7 @@ module WashoutBuilder
       # @raise [RuntimeError] Raises a runtime error if is detected a duplicate use of the complex type
       # @api public
       def check_duplicate_complex_class(classes_defined, complex_class)
-        complex_obj_found = classes_defined.find { |hash| hash[:class] == 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
 
@@ -197,7 +197,7 @@ module WashoutBuilder
       # @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, classes_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

data/lib/washout_builder/version.rb

@@ -12,7 +12,7 @@ module WashoutBuilder
     # the minor version of the gem
     MINOR = 0
     # the tiny version of the gem
-    TINY = 0
+    TINY = 2
     # if the version should be a prerelease
     PRE = nil
 

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

@@ -14,29 +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 with namespace' do
-    expect(namespaced_object.find_complex_class_name).to eq('Api::TestType')
+    expect(namespaced_object.find_complex_class_name).to eq('Project')
   end
 
-  it 'returns error if classname already detected (only used for hashes)' do
+  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')
-    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(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 the param structure' do
-    expect(subject.find_param_structure).to eq("project"=>"struct")
+  it 'returns error if classname already detected (only used for hashes)' do
+    subject.stubs(:classified?).returns(false)
+    subject.stubs(:basic_type).returns('ProjectType')
+    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 '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)
+  it 'returns the param structure' do
+    expect(subject.find_param_structure).to eq("description"=>"string", "name"=>"string", "users"=>"struct")
   end
 
   it 'same as ancestor' do
@@ -75,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
 
@@ -97,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
 
@@ -135,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) {}
@@ -143,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
@@ -153,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/spec_helper.rb

@@ -102,7 +102,7 @@ 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_or_struct)[0]
+  WashOut::Param.parse_def(soap_config, class_or_struct)[0]
 end
 
 class Hash

data/spec/support/complex_types/test_type.rb

@@ -2,9 +2,8 @@ module Api
   class TestType < WashOut::Type
     map project: {
       name: :string,
-      description: :string,
+      title: :string,
       users: [{ mail: :string }],
-      #  'dada'                                    => [Project]
     }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: washout_builder
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - bogdanRada