washout_builder 0.15.4 → 0.15.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff63c93c0fc2af1443358c1cf2cdd8ab21ec3893
-  data.tar.gz: 812e41e31b09855b0fa5d77dd6c106ff76f3c25a
+  metadata.gz: e3a7e076b8c2fd92d9d0a3460b6c0a32aa526137
+  data.tar.gz: de260d94e4fde3a2b85ee69b29e24d424c418d72
 SHA512:
-  metadata.gz: 9199d03265d5b1e0a618d2c11804e18cd22bd4d04d50bb786eb1b7fb5272bf00b6630f2864742e3ed36ac0df056052ace7b8bb8733e1c94a6b8bf44c42f55c36
-  data.tar.gz: 1374595940f370c03270c5f9ac5bf3785232478ee73bfcc5fd3b4353227c279289fa05199c4aac97171518db0cfcf3277ff51e8e643db3f76c17426d480b1dce
+  metadata.gz: c912a50fbdae3d27af8e038b6dba9b086c22d322443536f84a0dcfc74f7ee710c2b51835e4bc5ef3f0e4570586a5e094d156772175273ec3e256d404f4a99929
+  data.tar.gz: 5067c0aa90bd1dc0634b34a7e16c84cb428ba4dae9600df7d90d387e69d8d7f36489cddc0a43e79c3ea7dfc3cf9fd396183905516aca55faf00d81ef362d9da9

data/.travis.yml

@@ -6,6 +6,7 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.5
+  - 2.2.2
 env:
  - RAILS_ENV=test RACK_ENV=test
 notifications:

data/Appraisals

@@ -1,11 +1,3 @@
-appraise "rails-3.2.8" do
-  gem "rails", "3.2.8"
-end
-
-appraise "rails-3.2.12" do
-  gem "rails", "3.2.12"
-end
-
 appraise "rails-4.0.0" do
   gem "rails", "4.0.0"
 end
@@ -33,3 +25,11 @@ end
 appraise "rails-4.2.1" do
   gem "rails", "4.2.1"
 end
+
+appraise "rails-4.2.2" do
+  gem "rails", "4.2.2"
+end
+
+appraise "rails-4.2.3" do
+  gem "rails", "4.2.3"
+end

data/Rakefile

@@ -3,6 +3,8 @@ require 'bundler/gem_tasks'
 require 'appraisal'
 require 'rspec/core/rake_task'
 require 'coveralls/rake/task'
+require 'yard'
+require 'yard-rspec'
 Coveralls::RakeTask.new
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
@@ -21,7 +23,7 @@ unless ENV['TRAVIS']
   require 'rvm-tester'
   require 'wwtd/tasks'
   RVM::Tester::TesterTask.new(:suite) do |t|
-    t.rubies = %w(1.9.3 2.0.0 2.1.5 2.2.2) # which versions to test (required!)
+    t.rubies = %w(2.1.5 2.2.2) # which versions to test (required!)
     t.bundle_install = true # updates Gemfile.lock, default is true
     t.use_travis = true # looks for Rubies in .travis.yml (on by default)
     t.command = 'gem install bundler && bundle install && bundle exec rake' # runs plain "rake" by default
@@ -39,6 +41,20 @@ task :all do |_t|
   if ENV['TRAVIS']
     exec(' bundle exec phare &&  bundle exec appraisal install && bundle exec rake appraisal spec && bundle exec rake coveralls:push')
   else
-    exec(' bundle exec rubocop -a . && bundle exec phare &&  bundle exec appraisal install && bundle exec rake appraisal spec')
+  #  exec(' bundle exec rubocop -a . && bundle exec phare && ')
+   exec ('bundle exec appraisal install && bundle exec rake appraisal spec')
   end
 end
+
+YARD::Config.options[:load_plugins] = true
+YARD::Config.load_plugins
+
+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.stats_options = ['--list-undoc'] # optional
+end
+
+task :docs do
+  exec(' bundle exec rubocop -a .  && bundle exec phare  && bundle exec inch --pedantic && bundle exec yard')
+end

data/lib/washout_builder/document/complex_type.rb

@@ -6,7 +6,7 @@ module WashoutBuilder
       include WashoutBuilder::Document::SharedComplexType
 
       def find_complex_class_name(defined = [])
-        complex_class = struct? ? basic_type.gsub('.', '/').camelize : nil
+        complex_class = struct? ? basic_type.tr('.', '/').camelize : nil
         check_duplicate_complex_class(defined, complex_class) unless complex_class.nil? || defined.blank?
         complex_class
       end

data/lib/washout_builder/document/exception_model.rb

@@ -41,7 +41,7 @@ module WashoutBuilder
         method != :== && method != :! &&
           (instance_methods.include?(:"#{method}=") ||
             instance_methods.include?(:"#{method}")
-        )
+          )
       end
 
       def find_fault_attributes
@@ -49,7 +49,7 @@ module WashoutBuilder
         attrs = instance_methods(nil).map do |method|
           method.to_s if check_valid_fault_method?(method)
         end
-        attrs = attrs.delete_if { |method| method.end_with?('=') && attrs.include?(method.gsub('=', '')) }
+        attrs = attrs.delete_if { |method| method.end_with?('=') && attrs.include?(method.delete('=')) }
         attrs.concat(%w(message backtrace))
       end
 
@@ -67,7 +67,7 @@ module WashoutBuilder
       def find_fault_model_structure
         h = {}
         find_fault_attributes.each do |method_name|
-          method_name = method_name.to_s.end_with?('=') ? method_name.to_s.gsub('=', '') : method_name
+          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}",

data/lib/washout_builder/version.rb

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

data/spec/app/controllers/washout_builder_controller_spec.rb

@@ -27,22 +27,22 @@ describe WashoutBuilder::WashoutBuilderController, type: :controller do
 
   it 'gets the services' do
     get :all
-    assigns(:services).should eq([{ 'service_name' => 'Api', 'namespace' => '/api/wsdl', 'endpoint' => '/api/action', 'documentation_url' => 'http://test.host/Api' }])
+    expect(assigns(:services)).to eq([{ 'service_name' => 'Api', 'namespace' => '/api/wsdl', 'endpoint' => '/api/action', 'documentation_url' => 'http://test.host/Api' }])
   end
 
   it 'renders the template' do
     get :all
-    response.should render_template('wash_with_html/all_services')
+    expect(response).to render_template('wash_with_html/all_services')
   end
 
   it 'checks it controller is a service' do
-    controller.send(:controller_is_a_service?, 'api').should_not eq nil
+    expect(controller.send(:controller_is_a_service?, 'api')).not_to eq nil
   end
 
   it 'render a service documentation' do
     controller.expects(:controller_is_a_service?).with(params[:name]).returns(route)
     WashoutBuilder::Document::Generator.expects(:new).with(route.defaults[:controller])
     get :all, params
-    response.should render_template 'wash_with_html/doc'
+     expect(response).to  render_template 'wash_with_html/doc'
   end
 end

data/spec/app/helpers/washout_builder_complex_type_helper_spec.rb

@@ -15,7 +15,7 @@ describe WashoutBuilderComplexTypeHelper, type: :helper do
     def expect_included_type_result(pre, element)
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(element.type).returns(true)
       result = helper.create_element_type_html(pre, element)
-      result.should eq(["<span class='blue'>#{element.type}</span>&nbsp;<span class='bold'>#{element.name}</span>"])
+      expect(result).to eq(["<span class='blue'>#{element.type}</span>&nbsp;<span class='bold'>#{element.name}</span>"])
     end
 
     def expect_excluded_type_result(pre, element)
@@ -60,19 +60,19 @@ describe WashoutBuilderComplexTypeHelper, type: :helper do
 
     it 'returna simple type element description' do
       result = helper.create_complex_element_type_html(pre, element)
-      result.should eq(["<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"])
+      expect(result).to eq(["<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"])
     end
 
     it 'returns an array type element description' do
       element.stubs(:multiplied).returns(true)
       result = helper.create_complex_element_type_html(pre, element)
-      result.should eq(["<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"])
+      expect(result).to eq(["<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"])
     end
 
     it 'returns empty if no complex class' do
       element.stubs(:find_complex_class_name).returns(nil)
       result = helper.create_complex_element_type_html(pre, element)
-      result.should eq(nil)
+      expect(result).to eq(nil)
     end
   end
 end

data/spec/app/helpers/washout_builder_fault_type_helper_spec.rb

@@ -9,7 +9,7 @@ describe WashoutBuilderFaultTypeHelper, type: :helper do
     def check_result(array)
       attribute_primitive = array == true ? "Array of #{attr_primitive}" : "#{attr_primitive}"
       result = helper. create_fault_model_complex_element_type(pre, attr_primitive, attribute, array)
-      result.should eq(["<a href='##{attr_primitive}'><span class='lightBlue'> #{attribute_primitive}</span></a>&nbsp;<span class='bold'>#{attribute}</span>"])
+      expect(result).to eq(["<a href='##{attr_primitive}'><span class='lightBlue'> #{attribute_primitive}</span></a>&nbsp;<span class='bold'>#{attribute}</span>"])
     end
 
     it 'creates an array element ' do
@@ -25,14 +25,14 @@ describe WashoutBuilderFaultTypeHelper, type: :helper do
       attr_details = { member_type: 'STRING' }
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(attr_details[:member_type].to_s.downcase).returns(true)
       result = helper.member_type_is_basic?(attr_details)
-      result.should eq(attr_details[:member_type].to_s.downcase)
+      expect(result).to eq(attr_details[:member_type].to_s.downcase)
     end
 
     it 'returns a non-basic type' do
       attr_details = { member_type: 'STRING' }
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(attr_details[:member_type].to_s.downcase).returns(false)
       result = helper.member_type_is_basic?(attr_details)
-      result.should eq(attr_details[:member_type])
+      expect(result).to eq(attr_details[:member_type])
     end
   end
 
@@ -40,13 +40,13 @@ describe WashoutBuilderFaultTypeHelper, type: :helper do
     it 'returns true' do
       attr_details = { primitive: 'STRING' }
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(attr_details[:primitive].to_s.downcase).returns(true)
-      helper.primitive_type_is_basic?(attr_details).should eq(true)
+      expect(helper.primitive_type_is_basic?(attr_details)).to eq(true)
     end
 
     it 'returns false' do
       attr_details = { primitive: 'STRING' }
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(attr_details[:primitive].to_s.downcase).returns(false)
-      helper.primitive_type_is_basic?(attr_details).should eq(false)
+     expect(helper.primitive_type_is_basic?(attr_details)).to eq(false)
     end
   end
 
@@ -54,14 +54,14 @@ describe WashoutBuilderFaultTypeHelper, type: :helper do
     %w(NILCLASS nilclass).each do |primitive|
       it 'returns string in case of nilclass' do
         attr_details = { primitive: primitive }
-        helper.get_primitive_type_string(attr_details).should eq('string')
+         expect(helper.get_primitive_type_string(attr_details)).to eq('string')
       end
     end
 
     %w(BLA bla).each do |primitive|
       it 'returns the primitive if not niclass' do
         attr_details = { primitive: primitive }
-        helper.get_primitive_type_string(attr_details).should eq(primitive.to_s.downcase)
+         expect(helper.get_primitive_type_string(attr_details)).to eq(primitive.to_s.downcase)
       end
     end
   end
@@ -71,14 +71,14 @@ describe WashoutBuilderFaultTypeHelper, type: :helper do
       it 'checks the member type to be basic if primitive type array' do
         attr_details = { primitive: primitive }
         helper.expects(:member_type_is_basic?).with(attr_details).returns(true)
-        helper.get_member_type_string(attr_details).should eq(true)
+        expect(helper.get_member_type_string(attr_details) ).to eq(true)
       end
     end
 
     %w(BLA Bla bla).each do |primitive|
       it 'returns the primitive type as it is if not array' do
         attr_details = { primitive: primitive }
-        helper.get_member_type_string(attr_details).should eq(primitive)
+         expect( helper.get_member_type_string(attr_details) ).to  eq(primitive)
       end
     end
   end
@@ -95,7 +95,7 @@ describe WashoutBuilderFaultTypeHelper, type: :helper do
       type_string = 'string'
       helper.expects(:get_primitive_type_string).with(attr_details).returns(type_string)
       result = helper.create_html_fault_model_element_type(pre, attribute, attr_details)
-      result.should eq(["<span class='blue'>#{type_string}</span>&nbsp;<span class='bold'>#{attribute}</span>"])
+      expect(result).to eq(["<span class='blue'>#{type_string}</span>&nbsp;<span class='bold'>#{attribute}</span>"])
     end
 
     it 'returns the string element if primitive type is nilclass' do
@@ -120,7 +120,7 @@ describe WashoutBuilderFaultTypeHelper, type: :helper do
         helper.expects(:get_member_type_string).with(attr_details).returns(member_type)
         helper.expects(:create_fault_model_complex_element_type).with(pre, member_type, attribute, true).returns(expected)
         result = helper.create_html_fault_model_element_type(pre, attribute, attr_details)
-        result.should eq(expected)
+         expect(result).to eq(expected)
       end
     end
   end

data/spec/app/helpers/washout_builder_method_arguments_helper_spec.rb

@@ -20,7 +20,7 @@ describe WashoutBuilderMethodArgumentsHelper, type: :helper do
     def expect_method_arg_basic_type(mlen)
       use_spacer = mlen > 1 ? true : false
       result = helper.create_method_argument_element(pre, param, mlen)
-      result.should eq(["#{use_spacer ? spacer : ''}<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"])
+      expect(result).to eq(["#{use_spacer ? spacer : ''}<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"])
     end
 
     [0, 1, 2, 3, 4].each do |mlen|
@@ -36,7 +36,7 @@ describe WashoutBuilderMethodArgumentsHelper, type: :helper do
         param.expects(:multiplied).returns(true)
         use_spacer = mlen > 1 ? true : false
         result = helper.create_method_argument_element(pre, param, mlen)
-        result.should eq(["#{use_spacer ? spacer : ''}<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"])
+        expect(result).to eq(["#{use_spacer ? spacer : ''}<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"])
       end
     end
 
@@ -46,7 +46,7 @@ describe WashoutBuilderMethodArgumentsHelper, type: :helper do
         param.expects(:multiplied).returns(false)
         use_spacer = mlen > 1 ? true : false
         result = helper.create_method_argument_element(pre, param, mlen)
-        result.should eq(["#{use_spacer ? spacer : ''}<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"])
+        expect(result).to eq(["#{use_spacer ? spacer : ''}<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"])
       end
     end
   end
@@ -54,28 +54,28 @@ describe WashoutBuilderMethodArgumentsHelper, type: :helper do
   context 'create_argument_element_spacer' do
     it 'returns only the ) in bold ' do
       helper.create_argument_element_spacer(xml, 0, 1)
-      xml.target!.should eq("<span class=\"bold\">)</span>")
+      expect(xml.target!).to eq("<span class=\"bold\">)</span>")
     end
 
     it 'returns only the span with comma' do
       helper.create_argument_element_spacer(xml, -2, 1)
-      xml.target!.should eq('<span>, </span>')
+      expect(xml.target!).to eq('<span>, </span>')
     end
 
     it 'returns only the span with comma and a break ' do
       helper.create_argument_element_spacer(xml, 1, 3)
-      xml.target!.should eq('<span>, </span><br/>')
+      expect(xml.target!).to eq('<span>, </span><br/>')
     end
 
     it 'returns a break and a ) sign  ' do
       helper.create_argument_element_spacer(xml, 2, 3)
-      xml.target!.should eq("<br/><span class=\"bold\">)</span>")
+      expect(xml.target!).to eq("<br/><span class=\"bold\">)</span>")
     end
 
     [3, 4, 4, 5, 6].each do |j_value|
       it 'returns only the span with comma ' do
         helper.create_argument_element_spacer(xml, j_value, 3)
-        xml.target!.should eq('<br/>')
+        expect(xml.target!).to eq('<br/>')
       end
     end
   end
@@ -91,7 +91,7 @@ describe WashoutBuilderMethodArgumentsHelper, type: :helper do
       helper.stubs(:create_method_argument_element).returns('bla')
       helper.stubs(:create_argument_element_spacer).returns('blabla')
       helper. create_html_public_method_arguments(xml, pre, input)
-      xml.target!.should eq('<br/>')
+      expect(xml.target!).to eq('<br/>')
     end
   end
 end

data/spec/app/helpers/washout_builder_method_list_helper_spec.rb

@@ -11,13 +11,13 @@ describe WashoutBuilderMethodListHelper, type: :helper do
     it 'returns simple type ' do
       builder_elem.expects(:multiplied).returns(false)
       result = helper.create_return_complex_type_list_html(xml, complex_class, builder_out)
-      result.should eq("<span class=\"pre\"><a href=\"#SomeComplexClass\"><span class=\"lightBlue\">SomeComplexClass</span></a></span>")
+      expect(result).to eq("<span class=\"pre\"><a href=\"#SomeComplexClass\"><span class=\"lightBlue\">SomeComplexClass</span></a></span>")
     end
 
     it 'returns array type ' do
       builder_elem.expects(:multiplied).returns(true)
       result = helper.create_return_complex_type_list_html(xml, complex_class, builder_out)
-      result.should eq("<span class=\"pre\"><a href=\"#SomeComplexClass\"><span class=\"lightBlue\">Array of SomeComplexClass</span></a></span>")
+      expect(result).to eq("<span class=\"pre\"><a href=\"#SomeComplexClass\"><span class=\"lightBlue\">Array of SomeComplexClass</span></a></span>")
     end
   end
 
@@ -34,27 +34,27 @@ describe WashoutBuilderMethodListHelper, type: :helper do
 
     it 'returns void for nil' do
       helper.create_return_type_list_html(xml, nil)
-      xml.target!.should eq("<span class=\"pre\">void</span>")
+      expect(xml.target!).to eq("<span class=\"pre\">void</span>")
     end
 
     it 'returns basic type' do
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(true)
       helper.create_return_type_list_html(xml, output)
-      xml.target!.should eq("<span class=\"pre\"><span class=\"blue\">string</span></span>")
+      expect(xml.target!).to eq("<span class=\"pre\"><span class=\"blue\">string</span></span>")
     end
     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)
       result = helper.create_return_type_list_html(xml, output)
-      result.should eq(expected)
+      expect(result).to eq(expected)
     end
 
     it 'returns nil if complex class is nil' do
       builder_elem.stubs(:find_complex_class_name).returns(nil)
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(false)
       result = helper.create_return_type_list_html(xml, output)
-      result.should eq(nil)
+      expect(result).to eq(nil)
     end
   end
 end

data/spec/app/helpers/washout_builder_method_return_type_helper_spec.rb

@@ -17,34 +17,34 @@ describe WashoutBuilderMethodReturnTypeHelper, type: :helper do
 
     it 'returns void if output nil' do
       result = helper.create_html_public_method_return_type(xml, pre, nil)
-      result.should eq(['void'])
+      expect(result).to eq(['void'])
     end
 
     it 'returns basic type' do
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(true)
       result = helper.create_html_public_method_return_type(xml, pre, output)
-      result.should eq("<span class=\"blue\">#{type}</span>")
+      expect(result).to eq("<span class=\"blue\">#{type}</span>")
     end
 
     it 'returns simeple complex typel' do
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(false)
       builder_elem.expects(:multiplied).returns(false)
       result = helper.create_html_public_method_return_type(xml, pre, output)
-      result.should eq(["<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>"])
+      expect(result).to eq(["<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>"])
     end
 
     it 'returns array of complex typel' do
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(false)
       builder_elem.expects(:multiplied).returns(true)
       result = helper.create_html_public_method_return_type(xml, pre, output)
-      result.should eq(["<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>"])
+      expect(result).to eq(["<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>"])
     end
 
     it 'returns nil if complex class is nil' do
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(false)
       builder_elem.expects(:find_complex_class_name).returns(nil)
       result = helper.create_html_public_method_return_type(xml, pre, output)
-      result.should eq(nil)
+      expect(result).to eq(nil)
     end
   end
 end

data/spec/dummy/config.ru

@@ -1,4 +1,4 @@
 # This file is used by Rack-based servers to start the application.
 
-require ::File.expand_path('../config/environment',  __FILE__)
+require ::File.expand_path('../config/environment', __FILE__)
 run Dummy::Application

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

@@ -14,15 +14,15 @@ describe WashoutBuilder::Document::ComplexType do
   let(:namespaced_object) { get_wash_out_param(Api::TestType) }
 
   it 'returns the complex class name' do
-    subject.find_complex_class_name.should eq('ProjectType')
+    expect(subject.find_complex_class_name).to eq('ProjectType')
   end
 
   it 'returns the complex class name' do
-    subject.find_complex_class_name.should eq('ProjectType')
+    expect(subject.find_complex_class_name).to eq('ProjectType')
   end
 
   it 'returns the complex class with namespace' do
-    namespaced_object.find_complex_class_name.should eq('Api::TestType')
+    expect(namespaced_object.find_complex_class_name).to eq('Api::TestType')
   end
 
   it 'returns error if classname already detected (only used for hashes)' do
@@ -33,55 +33,55 @@ describe WashoutBuilder::Document::ComplexType do
   end
 
   it 'returns the param structure' do
-    subject.find_param_structure.should eq('project' => 'struct')
+    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)
-    subject.name.should eq(descendant.name)
-    subject.map[0].find_param_structure.should eq(descendant.map[0].find_param_structure)
+    expect(subject.name).to eq(descendant.name)
+    expect(subject.map[0].find_param_structure).to eq(descendant.map[0].find_param_structure)
   end
 
   it 'same as ancestor' do
-    subject.get_ancestors(ProjectType).should eq([])
+    expect(subject.get_ancestors(ProjectType)).to eq([])
   end
 
   it 'same as ancestor' do
-    subject.get_ancestors('WashoutBuilderSomeInexistentClass').should eq(nil)
+    expect(subject.get_ancestors('WashoutBuilderSomeInexistentClass')).to eq(nil)
   end
 
   it 'returns the complex type ancestors' do
     expected = 'some_name'
     subject.stubs(:classified?).returns(true)
     subject.expects(:get_class_ancestors).with(soap_config, ProjectType, []).returns(expected)
-    subject.complex_type_ancestors(soap_config, ProjectType, []).should eq(expected)
+    expect(subject.complex_type_ancestors(soap_config, ProjectType, [])).to eq(expected)
   end
 
   it 'returns nil  for unclassified objects' do
     subject.stubs(:classified?).returns(false)
-    subject.complex_type_ancestors(soap_config, ProjectType, []).should eq(nil)
+    expect(subject.complex_type_ancestors(soap_config, ProjectType, [])).to eq(nil)
   end
 
   it 'should remove inheritable elements' do
     subject_dup = subject.dup
     subject_dup.remove_type_inheritable_elements(['name'])
-    subject_dup.map.find { |element| element.name == 'name' }.should eq(nil)
+    expect(subject_dup.map.find { |element| element.name == 'name' }).to eq(nil)
   end
 
   it 'should return true if same structure' do
-    subject.same_structure_as_ancestor?(subject).should eq(true)
+    expect(subject.same_structure_as_ancestor?(subject)).to eq(true)
   end
 
   it 'should return true if same structure' do
-    subject.same_structure_as_ancestor?(get_wash_out_param(Fluffy)).should eq(false)
+    expect(subject.same_structure_as_ancestor?(get_wash_out_param(Fluffy))).to eq(false)
   end
 
   describe '#complex_type_descendants' do
     it 'returns empty array if not struct?' do
       defined = []
       subject.stubs(:struct?).returns(false)
-      subject.complex_type_descendants(soap_config, defined).should eq(defined)
+      expect(subject.complex_type_descendants(soap_config, defined)).to eq(defined)
     end
 
     it 'returns the descendants if  struct?' do
@@ -90,7 +90,7 @@ describe WashoutBuilder::Document::ComplexType do
         obj.expects(:get_nested_complex_types).with(soap_config, defined).returns([obj.name])
       end
       subject.stubs(:struct?).returns(true)
-      subject.complex_type_descendants(soap_config, defined).should eq(subject.map.map(&:name))
+      expect(subject.complex_type_descendants(soap_config, defined)).to eq(subject.map.map(&:name))
     end
   end
 
@@ -107,7 +107,7 @@ describe WashoutBuilder::Document::ComplexType do
       subject.expects(:complex_type_ancestors).with(soap_config, complex_class, 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)
-      subject.get_nested_complex_types(soap_config, defined).should eq(expected)
+      expect(subject.get_nested_complex_types(soap_config, defined)).to eq(expected)
     end
 
     it 'returns the the descendants' do
@@ -115,7 +115,7 @@ describe WashoutBuilder::Document::ComplexType do
       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)
-      subject.get_nested_complex_types(soap_config, defined).should eq(expected)
+      expect(subject.get_nested_complex_types(soap_config, defined)).to eq(expected)
     end
   end
 
@@ -124,7 +124,7 @@ describe WashoutBuilder::Document::ComplexType do
     let(:ancestors) { [ancestor_class] }
 
     it 'returns the ancestor structure' do
-      subject.ancestor_structure(ancestors).should eq(ancestors[0].to_s.downcase => ancestors[0].wash_out_param_map)
+      expect(subject.ancestor_structure(ancestors)).to eq(ancestors[0].to_s.downcase => ancestors[0].wash_out_param_map)
     end
   end
 
@@ -133,7 +133,7 @@ describe WashoutBuilder::Document::ComplexType do
     let(:ancestors) { ['something'] }
 
     it 'returns the complex_type_hash' do
-      subject.complex_type_hash(complex_class, subject, ancestors).should eq('class' => complex_class, :obj => subject, :ancestors => ancestors)
+      expect(subject.complex_type_hash(complex_class, subject, ancestors)).to eq('class' => complex_class, :obj => subject, :ancestors => ancestors)
     end
   end
 
@@ -147,7 +147,7 @@ describe WashoutBuilder::Document::ComplexType do
 
     it 'returns nil if no ancestors' do
       subject.expects(:get_ancestors).with(class_name).returns(nil)
-      subject.get_class_ancestors(soap_config, class_name, defined).should eq(nil)
+      expect(subject.get_class_ancestors(soap_config, class_name, defined)).to eq(nil)
     end
 
     it 'returns the ancestors and the top ones' do
@@ -157,7 +157,7 @@ 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)
-      subject.get_class_ancestors(soap_config, class_name, defined).should eq([complex_type_hash])
+      expect(subject.get_class_ancestors(soap_config, class_name, defined)).to eq([complex_type_hash])
     end
 
     it 'returns nil if same structure as ancestor' do
@@ -165,7 +165,7 @@ describe WashoutBuilder::Document::ComplexType do
       subject.expects(:ancestor_structure).with(ancestors).returns(ancestor_structure)
       WashOut::Param.stubs(:parse_def).returns([namespaced_object])
       subject.expects(:same_structure_as_ancestor?).with(namespaced_object).returns(true)
-      subject.get_class_ancestors(soap_config, class_name, defined).should eq(nil)
+      expect(subject.get_class_ancestors(soap_config, class_name, defined)).to eq(nil)
     end
   end
 end