washout_builder 0.14.1 → 0.15.0

data/spec/app/helpers/washout_builder_method_list_helper_spec.rb

@@ -1,65 +1,60 @@
 require 'spec_helper'
 
-describe    WashoutBuilderMethodListHelper, :type => :helper do
-  let!(:xml) {  Builder::XmlMarkup.new}
-  
-      
-  context "create_return_complex_type_list_html" do
-    let(:complex_class) {"SomeComplexClass"}
-    let (:builder_elem) {mock}
-    let(:builder_out) {[builder_elem]}
-    
-    it "returns simple type " do
+describe WashoutBuilderMethodListHelper, type: :helper do
+  let!(:xml) { Builder::XmlMarkup.new }
+
+  context 'create_return_complex_type_list_html' do
+    let(:complex_class) { 'SomeComplexClass' }
+    let(:builder_elem) { mock }
+    let(:builder_out) { [builder_elem] }
+
+    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 = 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>")
     end
-    
-    it "returns array type " do
+
+    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 = 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>")
     end
-    
   end
-  
-  
-  context "create_return_type_list_html" do
-    let(:complex_class) {"SomeComplexClass"}
-    let (:builder_elem) {mock}
-    let(:output) {[builder_elem]}
-    let(:type) {"string"}
-      
+
+  context 'create_return_type_list_html' do
+    let(:complex_class) { 'SomeComplexClass' }
+    let(:builder_elem) { mock }
+    let(:output) { [builder_elem] }
+    let(:type) { 'string' }
+
     before(:each) do
-      builder_elem.stubs(:get_complex_class_name).returns(complex_class)
+      builder_elem.stubs(:find_complex_class_name).returns(complex_class)
       builder_elem.stubs(:type).returns(type)
     end
-    
-    it "returns void for nil" do
+
+    it 'returns void for nil' do
       helper.create_return_type_list_html(xml, nil)
       xml.target!.should eq("<span class=\"pre\">void</span>")
     end
-    
-    it "returns basic type" do
+
+    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>")
     end
-    it "returns complex type" do
-      expected ="some expected string"
+    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)
     end
-    
-    it "returns nil if complex class is nil" do
-      builder_elem.stubs(:get_complex_class_name).returns(nil)
+
+    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)
     end
-    
   end
-  
 end

data/spec/app/helpers/washout_builder_method_return_type_helper_spec.rb

@@ -1,52 +1,50 @@
-require "spec_helper"
-
-describe WashoutBuilderMethodReturnTypeHelper, :type => :helper do
-  let!(:xml) {  Builder::XmlMarkup.new}
-  let(:pre) {[]}
-  
-  context "create_html_public_method_return_type" do
-    let(:complex_class) {"SomeComplexClass"}
-    let (:builder_elem) {mock}
-    let(:output) {[builder_elem]}
-    let(:type) {"string"}
-    
+require 'spec_helper'
+
+describe WashoutBuilderMethodReturnTypeHelper, type: :helper do
+  let!(:xml) { Builder::XmlMarkup.new }
+  let(:pre) { [] }
+
+  context 'create_html_public_method_return_type' do
+    let(:complex_class) { 'SomeComplexClass' }
+    let(:builder_elem) { mock }
+    let(:output) { [builder_elem] }
+    let(:type) { 'string' }
+
     before(:each) do
-      builder_elem.stubs(:get_complex_class_name).returns(complex_class)
+      builder_elem.stubs(:find_complex_class_name).returns(complex_class)
       builder_elem.stubs(:type).returns(type)
     end
-    
-    it "returns void if output nil" do
+
+    it 'returns void if output nil' do
       result = helper.create_html_public_method_return_type(xml, pre, nil)
-      result.should eq(["void"])
+      result.should eq(['void'])
     end
-    
-    it "returns basic type" do
+
+    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>")
     end
-    
-    it "returns simeple complex typel" do
+
+    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>"])
     end
-    
-    it "returns array of complex typel" do
+
+    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>"])
     end
-    
-    it "returns nil if complex class is nil" do
+
+    it 'returns nil if complex class is nil' do
       WashoutBuilder::Type::BASIC_TYPES.expects(:include?).with(builder_elem.type).returns(false)
-      builder_elem.expects(:get_complex_class_name).returns(nil)
+      builder_elem.expects(:find_complex_class_name).returns(nil)
       result = helper.create_html_public_method_return_type(xml, pre, output)
       result.should eq(nil)
     end
-    
   end
-  
 end

data/spec/dummy/config/application.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../boot', __FILE__)
 
-require "action_controller/railtie"
-require "rails/test_unit/railtie"
+require 'action_controller/railtie'
+require 'rails/test_unit/railtie'
 
 if Rails::VERSION::MAJOR >= 4
   # Ugly hack to make Rails 4 JRuby-compatible to escape Travis errors
@@ -13,7 +13,7 @@ if Rails::VERSION::MAJOR >= 4
 end
 
 Bundler.require
-require "wash_out"
+require 'wash_out'
 
 module Dummy
   class Application < Rails::Application
@@ -43,7 +43,7 @@ module Dummy
     # config.action_view.javascript_expansions[:defaults] = %w(jquery rails)
 
     # Configure the default encoding used in templates for Ruby 1.9.
-    config.encoding = "utf-8"
+    config.encoding = 'utf-8'
 
     # Configure sensitive parameters which will be filtered from the log file.
     config.filter_parameters += [:password]

data/spec/dummy/config/boot.rb

@@ -7,4 +7,4 @@ if File.exist?(gemfile)
   Bundler.setup
 end
 
-$:.unshift File.expand_path('../../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)

data/spec/dummy/config/environments/development.rb

@@ -10,8 +10,8 @@ Dummy::Application.configure do
   config.whiny_nils = true
 
   # Show full error reports and disable caching
-  config.consider_all_requests_local       = true
-  config.action_view.debug_rjs             = true
+  config.consider_all_requests_local = true
+  config.action_view.debug_rjs = true
   config.action_controller.perform_caching = false
 
   # Print deprecation notices to the Rails logger
@@ -20,4 +20,3 @@ Dummy::Application.configure do
   # Only use best-standards-support built into browsers
   config.action_dispatch.best_standards_support = :builtin
 end
-

data/spec/dummy/config/environments/test.rb

@@ -10,14 +10,14 @@ Dummy::Application.configure do
   config.eager_load = true
 
   # Show full error reports and disable caching
-  config.consider_all_requests_local       = true
+  config.consider_all_requests_local = true
   config.action_controller.perform_caching = false
-
+  config.active_support.test_order = :sorted
   # Raise exceptions instead of rendering exception templates
   config.action_dispatch.show_exceptions = false
 
   # Disable request forgery protection in test environment
-  config.action_controller.allow_forgery_protection    = false
+  config.action_controller.allow_forgery_protection = false
 
   # Use SQL instead of Active Record's schema dumper when creating the test database.
   # This is necessary if your schema can't be completely dumped by the schema dumper,

data/spec/dummy/config/initializers/secret_token.rb

@@ -5,4 +5,4 @@
 # Make sure the secret is at least 30 characters and all random,
 # no regular words or you'll be exposed to dictionary attacks.
 Dummy::Application.config.secret_token = 'b8d5d5687c012c2ef1a7a6e8006172402c48a3dcccca67c076eaad81c4712ad236ca2717c3706df7b286468c749d223f22acb0d96c27bdf33bbdbb9684ad46e5'
-Dummy::Application.config.secret_key_base = 'ed27a919186a27649accc93ad8c2750a022ef255780e8a15a439658e9f8c520ed70ea071e596b2d23ed41163cf36c21ff5afcd31d19439bb1e4c420f2a57bce6'
+Dummy::Application.config.secret_key_base = 'ed27a919186a27649accc93ad8c2750a022ef255780e8a15a439658e9f8c520ed70ea071e596b2d23ed41163cf36c21ff5afcd31d19439bb1e4c420f2a57bce6'

data/spec/dummy/config/initializers/session_store.rb

@@ -1,6 +1,6 @@
 # Be sure to restart your server when you modify this file.
 
-Dummy::Application.config.session_store :cookie_store, :key => '_dummy_session'
+Dummy::Application.config.session_store :cookie_store, key: '_dummy_session'
 
 # Use the database for sessions instead of the cookie-based default,
 # which shouldn't be used to store highly confidential information

data/spec/dummy/config/routes.rb

@@ -55,5 +55,4 @@ Dummy::Application.routes.draw do
   # This is a legacy wild controller route that's not recommended for RESTful applications.
   # Note: This route will make all actions in every controller accessible via GET requests.
   # match ':controller(/:action(/:id(.:format)))'
-  
 end

data/spec/dummy/script/rails

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
 
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
+APP_PATH = File.expand_path('../../config/application', __FILE__)
+require File.expand_path('../../config/boot', __FILE__)
 require 'rails/commands'

data/spec/integration/washout_builder_all_services_spec.rb

@@ -1,7 +1,4 @@
 require 'spec_helper'
 
-feature "All Services" do
-  
-  
-  
-end
+feature 'All Services' do
+end

data/spec/integration/washout_builder_service_spec.rb

@@ -1,7 +1,4 @@
 require 'spec_helper'
 
-feature "Service" do
-  
-  
-  
-end
+feature 'Service' do
+end

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

@@ -1,175 +1,157 @@
-#encoding:utf-8
+# encoding:utf-8
 require 'spec_helper'
 
-
 describe WashoutBuilder::Document::ComplexType do
-  let(:soap_config) { OpenStruct.new(
+  let(:soap_config) do
+    OpenStruct.new(
       camelize_wsdl: false,
-      namespace: "/api/wsdl",
-      description: "some description"
-    ) }
-    
-  let(:subject) {  get_wash_out_param(ProjectType) }
+      namespace: '/api/wsdl',
+      description: 'some description'
+    )
+  end
+
+  let(:subject) { get_wash_out_param(ProjectType) }
   let(:namespaced_object) { get_wash_out_param(Api::TestType) }
-  
-  it "returns the complex class name" do
-    subject.get_complex_class_name.should eq("ProjectType")
-  end
-  
-  
-  it "returns the complex class name" do
-    subject.get_complex_class_name.should eq("ProjectType")
-  end
-   
-  
-  it "returns the complex class with namespace" do
-    namespaced_object.get_complex_class_name.should eq("Api::TestType")
-  end
-  
-    
-  it "returns error if classname already detected (only used for hashes)" do
+
+  it 'returns the complex class name' do
+    subject.find_complex_class_name.should eq('ProjectType')
+  end
+
+  it 'returns the complex class name' do
+    subject.find_complex_class_name.should eq('ProjectType')
+  end
+
+  it 'returns the complex class with namespace' do
+    namespaced_object.find_complex_class_name.should eq('Api::TestType')
+  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.get_complex_class_name(defined) }.to  raise_error(RuntimeError, "Duplicate use of `ProjectType` type name. Consider using classified types.")
+    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.')
   end
-  
-  it "returns the param structure" do
-    subject.get_param_structure.should eq({"project"=>"struct"})
+
+  it 'returns the param structure' do
+    subject.find_param_structure.should eq('project' => 'struct')
   end
-  
-  it "fixes the first descendant " do
+
+  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].get_param_structure.should eq(descendant.map[0].get_param_structure)
+    subject.map[0].find_param_structure.should eq(descendant.map[0].find_param_structure)
   end
-  
-  it "same as ancestor" do
+
+  it 'same as ancestor' do
     subject.get_ancestors(ProjectType).should eq([])
   end
-  
-  it "same as ancestor" do
-    subject.get_ancestors("WashoutBuilderSomeInexistentClass").should eq(nil)
+
+  it 'same as ancestor' do
+    subject.get_ancestors('WashoutBuilderSomeInexistentClass').should eq(nil)
   end
-  
-  it "returns the complex type ancestors" do
-    expected = "some_name"
+
+  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)
+    subject.complex_type_ancestors(soap_config, ProjectType, []).should eq(expected)
   end
-  
-  it "returns nil  for unclassified objects" do
+
+  it 'returns nil  for unclassified objects' do
     subject.stubs(:classified?).returns(false)
-    subject.complex_type_ancestors(soap_config, ProjectType, [] ).should eq(nil)
+    subject.complex_type_ancestors(soap_config, ProjectType, []).should eq(nil)
   end
-  
-  it "should remove inheritable elements" do
+
+  it 'should remove inheritable elements' do
     subject_dup = subject.dup
-    subject_dup.remove_type_inheritable_elements(["name"])
-    subject_dup.map.detect {|element|  element.name == "name" }.should eq(nil)
+    subject_dup.remove_type_inheritable_elements(['name'])
+    subject_dup.map.find { |element| element.name == 'name' }.should eq(nil)
   end
-  
-  
-  it "should return true if same structure" do
+
+  it 'should return true if same structure' do
     subject.same_structure_as_ancestor?(subject).should eq(true)
   end
-  
-  
-    
-  it "should return true if same structure" do
+
+  it 'should return true if same structure' do
     subject.same_structure_as_ancestor?(get_wash_out_param(Fluffy)).should eq(false)
   end
-  
-  
+
   describe '#complex_type_descendants' do
-    
-    it "returns empty array if not struct?" 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)
     end
-    
-    it "returns the descendants if  struct?" do
+
+    it 'returns the descendants if  struct?' do
       defined = []
-      subject.map.each { |obj|  
+      subject.map.each do |obj|
         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.collect{|x| x.name } )
+      subject.complex_type_descendants(soap_config, defined).should eq(subject.map.map(&:name))
     end
-    
-  end
-  
-  
-  describe "#get_nested_complex_types" do
-    
-    let(:complex_class) {"ProjectType" }
-    let(:ancestors) { ["something"]}
-    let(:complex_type_hash) { {:class =>complex_class, :obj =>subject ,  :ancestors => ancestors   }}
-    let(:expected) { [complex_type_hash]}
-    
-    it "returns the complex class ancestors" do
+  end
+
+  describe '#get_nested_complex_types' do
+    let(:complex_class) { 'ProjectType' }
+    let(:ancestors) { ['something'] }
+    let(:complex_type_hash) { { class: complex_class, obj: subject, ancestors: ancestors } }
+    let(:expected) { [complex_type_hash] }
+
+    it 'returns the complex class ancestors' do
       defined = []
-      subject.expects(:get_complex_class_name).with(defined).returns(complex_class)
+      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)
-      subject.expects(:complex_type_hash).with(complex_class, subject, ancestors ).returns(complex_type_hash)
+      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)
     end
-    
-    it "returns the the descendants" do
+
+    it 'returns the the descendants' do
       defined = nil
-      subject.expects(:get_complex_class_name).with([]).returns(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)
       subject.get_nested_complex_types(soap_config, defined).should eq(expected)
     end
-    
   end
-  
-  
+
   describe '#ancestor_structure' do
-    let(:ancestor_class) {ProjectType}
+    let(:ancestor_class) { ProjectType }
     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  })
+
+    it 'returns the ancestor structure' do
+      subject.ancestor_structure(ancestors).should eq(ancestors[0].to_s.downcase => ancestors[0].wash_out_param_map)
     end
-    
   end
- 
-  
+
   describe '#complex_type_hash' do
-    let(:complex_class) {"ProjectType" }
-    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   })
+    let(:complex_class) { 'ProjectType' }
+    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)
     end
-    
   end
-  
-  
+
   describe '#get_class_ancestors' do
-    let(:class_name) {"ProjectType" }
+    let(:class_name) { 'ProjectType' }
     let(:defined) { [] }
-    let(:ancestors) { ["SomeInexistentClass"] }
-    let(:ancestor_structure) {{ ancestors[0].to_s.downcase => "bla" }}
-    let(:top_ancestors){}
-    let(:complex_type_hash) { {:class =>class_name, :obj =>subject ,  :ancestors => ancestors   }}
-     
-    it "returns nil if no ancestors" do
+    let(:ancestors) { ['SomeInexistentClass'] }
+    let(:ancestor_structure) { { ancestors[0].to_s.downcase => 'bla' } }
+    let(:top_ancestors) {}
+    let(:complex_type_hash) { { class: class_name, obj: subject, ancestors: ancestors } }
+
+    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)
     end
-    
-    it "returns the ancestors and the top ones" do
-      skip "recursion problem"
+
+    it 'returns the ancestors and the top ones' do
+      skip 'recursion problem'
       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])
@@ -177,15 +159,13 @@ describe WashoutBuilder::Document::ComplexType do
       subject.expects(:complex_type_hash).returns(complex_type_hash)
       subject.get_class_ancestors(soap_config, class_name, defined).should eq([complex_type_hash])
     end
-    
-    it "returns nil if same structure as ancestor" do
+
+    it 'returns nil if same structure as ancestor' do
       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])
       subject.expects(:same_structure_as_ancestor?).with(namespaced_object).returns(true)
       subject.get_class_ancestors(soap_config, class_name, defined).should eq(nil)
     end
-    
   end
-  
-end
+end