washout_builder 0.13.2 → 0.13.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjdhNzFiNjYwNDg0M2U0ZGQ5ZTcxNjg3NWIzMDJiYmIzYjZmYTI4MQ==
+    NDQ4NTEwNjQwOGY4ZjA3NmY2MmE3MzA2MjNlZGFhY2FkNDJlOGFjNQ==
   data.tar.gz: !binary |-
-    NmY0Y2ZiM2NjZWQzYzEwZTNhZThhNjJkYzczNzczOGI3Y2M0NGYzYw==
+    OGU0MjUxMGVlMWIxODc1MGE3ODY2ZDY1Njc1NWZmOTlmMzAwY2ExNQ==
 SHA512:
   metadata.gz: !binary |-
-    MDc1YjY5MDBjYjkyYWIyMmE3MTE0M2ZlZGE2OGY1OTQzZDAxZTNiNGU4YWRj
-    ZTQzODRlZmUyZmIwYzUxNzBmY2RmMTEwYjQzNDk0NDE2MjBhMmFkMjFmZjJh
-    Y2NkZTNlYmQ1ZDU4YjZjODQxOGI2ZmJiNDA0ZjI1MjFmN2E3ZjE=
+    MWQ0OTQyZjUwNzFiZWZjN2EyOGJhZTJkZDU4YTk1NWViNTM0ODBmOWQ0ZGU5
+    YWNjNTMwMTMwMzQ2YjUwMDhkYTRmYzA2MGZjYmE0OGUyMTllZWI3MzVkZTcy
+    ZjEyNDRhZGJiYmQ4ZTU0NzVjMTg5OTkxMjc4ZDY3NmE0NWVmOTA=
   data.tar.gz: !binary |-
-    Y2Y3MTRjNzZkYWE0MjUyZDRlMDE1YmZkNDgxYzdiOWMxMzRlYzdmYjRkMTg5
-    M2NjNjI4ZDgwOTczZTlkM2JmYWJmYmIyYTdhZGQ0NjZhYWE4N2Q0ZWUyZTlj
-    ODM3OWVhNWQwMmE1YjM3ZTllNjExNWUwMGM5NGIxMjEzN2IyOGM=
+    N2YxYTQ5ZWQyMDA0NTJlMjMwNTdiOTRhYjM5ZDk1M2IzOGQwZmQwZWI2ZDg3
+    ZmVjODhlOWU1MTA2YzE4MzI5MjE1NDhmZDA0MmMxOGVhZjIwZTkwNTk4NjEw
+    NWE5MmRkZjI0ZjIxMzAxNzY3M2UwMTk5M2Y1ZTNmMzJmMTNkOTI=

data/app/helpers/washout_builder_complex_type_helper.rb

@@ -0,0 +1,26 @@
+module WashoutBuilderComplexTypeHelper
+  
+  def create_complex_type_element_html(xml, element)
+    element.type = "string" if element.type == "text"
+    element.type = "integer" if element.type == "int"
+    xml.li { |pre|
+      if WashoutBuilder::Type::BASIC_TYPES.include?(element.type)
+        pre << "<span class='blue'>#{element.type}</span>&nbsp;<span class='bold'>#{element.name}</span>"
+      else
+        create_element_type_html(pre, element)
+      end
+    }
+  end
+  
+  def create_element_type_html(pre, element)
+    complex_class = element.get_complex_class_name
+    unless  complex_class.nil?
+      complex_class_content =  element.multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
+      pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class_content}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
+    end
+  end
+
+end
+
+
+  

data/app/helpers/washout_builder_fault_type_helper.rb

@@ -0,0 +1,25 @@
+module WashoutBuilderFaultTypeHelper
+  
+  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
+  
+  
+  def create_html_fault_model_element_type(xml, attribute, attr_details)
+    xml.li { |pre|
+      if WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:primitive].to_s.downcase) || attr_details[:primitive] == "nilclass" 
+        pre << "<span class='blue'>#{attr_details[:primitive].to_s.downcase == "nilclass" ? "string" : attr_details[:primitive].to_s.downcase }</span>&nbsp;<span class='bold'>#{attribute}</span>"
+        
+      else
+        if  attr_details[:primitive].to_s.downcase == "array"
+          
+          attr_primitive =  WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:member_type].to_s.downcase) ? attr_details[:member_type].to_s.downcase : attr_details[:member_type]
+          create_fault_model_complex_element_type(pre,attr_primitive, attribute, true )
+        else
+          create_fault_model_complex_element_type(pre,attr_details[:primitive], attribute, false )
+        end
+      end
+    }
+  end
+end

data/app/helpers/washout_builder_method_arguments_helper.rb

@@ -0,0 +1,41 @@
+module WashoutBuilderMethodArgumentsHelper
+ 
+  def create_method_argument_element( pre, param, mlen)
+    spacer = "    "
+    complex_class = param.get_complex_class_name  
+    use_spacer =  mlen > 1 ? true : false
+    if WashoutBuilder::Type::BASIC_TYPES.include?(param.type)
+      pre << "#{use_spacer ? spacer: ''}<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"
+    else
+      unless 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
+    end
+  end
+  
+  def create_argument_element_spacer(xml, j, mlen )
+    if j< (mlen-1)
+      xml.span ", "
+    end
+    if mlen > 1
+      xml.br
+    end
+    if (j+1) == mlen
+      xml.span("class" => "bold") {|y|  y << ")" }
+    end
+  end
+  
+  
+  
+  def create_html_public_method_arguments(xml, pre, input)
+    mlen = input.size
+    xml.br if mlen > 1
+    if mlen > 0
+      input.each_with_index do |element, index|
+        create_method_argument_element( pre, element, mlen)
+        create_argument_element_spacer(xml, index, mlen )
+      end
+    end
+  end
+end

data/app/helpers/washout_builder_method_list_helper.rb

@@ -0,0 +1,38 @@
+module WashoutBuilderMethodListHelper
+  
+  def create_element_exceptions_list_html(p)
+    xml.li("class" => "pre"){ |y| y<< "<a href='##{p.to_s}'><span class='lightBlue'> #{p.to_s}</span></a>" }
+  end
+  
+  def create_parameters_element_list_html(xml, param)
+    xml.li("class" => "pre") { |pre|
+      if WashoutBuilder::Type::BASIC_TYPES.include?(param.type)
+        pre << "<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"
+      else
+        create_element_type_html(pre, param)
+      end
+    }
+  end
+  
+  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") { xml.a("href" => "##{complex_class}") { |xml| xml.span("class" => "lightBlue") { |y| y<<"#{return_content}" } } }
+  end
+
+  
+  def create_return_type_list_html(xml, output)
+    unless output.nil?
+      complex_class = output[0].get_complex_class_name  
+      if WashoutBuilder::Type::BASIC_TYPES.include?(output[0].type)
+        xml.span("class" => "pre") { |xml| xml.span("class" => "blue") { |sp| sp << "#{output[0].type}" } }
+      else
+        create_return_complex_type_html(xml, complex_class, output) unless complex_class.nil?
+      end
+    else
+      xml.span("class" => "pre") { |sp| sp << "void" }
+    end
+    
+  
+  end  
+    
+end

data/app/helpers/washout_builder_method_return_type_helper.rb

@@ -0,0 +1,20 @@
+module WashoutBuilderMethodReturnTypeHelper
+
+  def create_html_public_method_return_type(xml,pre, output)
+    if !output.nil?
+      complex_class = output[0].get_complex_class_name  
+      if WashoutBuilder::Type::BASIC_TYPES.include?(output[0].type)
+        xml.span("class" => "blue") { |y| y<<  "#{output[0].type}" }
+      else
+        complex_return_type =  output[0].multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
+        pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_return_type}</span></a>" unless complex_class.nil?
+      end
+    else
+      pre << "void"
+    end
+  end
+  
+  
+
+
+end

data/app/views/wash_with_html/_complex_type.builder

@@ -0,0 +1,14 @@
+
+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>" } " }   
+
+  
+  if object.is_a?(WashOut::Param)
+    xml.ul("class" => "pre") {
+      object.map.each do |element|
+        create_complex_type_element_html(xml, element)
+      end
+    }
+  end
+end

data/app/views/wash_with_html/_fault_type.builder

@@ -0,0 +1,9 @@
+if object.is_a?(Class) 
+  xml.h3  { |pre| pre << "#{object} #{ancestors.blank? ? "" : "<small>(extends <a href='##{ancestors[0].to_s.classify}'>#{ancestors[0].to_s.classify}</a>)</small>" } " }
+  xml.a("name" => "#{object}") {}
+  xml.ul("class" => "pre") {
+    structure.each do |attribute, attr_details|
+      create_html_fault_model_element_type(xml, attribute, attr_details)
+    end
+  }
+end

data/app/views/wash_with_html/_public_method.builder

@@ -0,0 +1,36 @@
+xml.h3 "#{operation}"
+xml.a("name" => "#{operation}") {}
+
+xml.p("class" => "pre"){ |pre|
+  create_html_public_method_return_type(xml,pre, output)
+  xml.span("class" => "bold") {|y|  y << "#{operation} (" }
+  create_html_public_method_arguments(xml, pre, input)
+}
+xml.p "#{description}" unless description.blank?
+
+
+ xml.p "Parameters:"
+    xml.ul {
+      input.each do |element|
+        create_parameters_element_list_html(xml,element)
+      end
+    }
+
+  xml.p "Return value:"
+    xml.ul {
+      xml.li {
+    
+        create_return_type_list_html(xml,output)
+      }
+    }
+
+
+operation_exceptions = @document.operation_exceptions(operation)
+unless operation_exceptions.blank?
+xml.p "Exceptions:"
+    xml.ul {
+      operation_exceptions.each do |p|
+       create_element_exceptions_list_html(p)
+      end
+    }
+end

data/app/views/wash_with_html/doc.builder

@@ -41,7 +41,7 @@ xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
       xml.span( "class" => "pre") {
         xml.a( "href" => "#{@document.namespace}") { |y| y << "#{@document.namespace}" }
       };}
-      xml.p ""
+    xml.p ""
     unless @document.service_description.blank?
       xml.p "#{@document.service_description}"
     end
@@ -87,18 +87,25 @@ xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
 
     unless @complex_types.blank?
       xml.h2 "Complex types:"
-      create_html_complex_types(xml, @complex_types)
-    end
-    unless @fault_complex_types.blank?
-      create_html_fault_types_details(xml, @fault_complex_types)
+      @complex_types.each  { |hash|            
+        xml <<    render(:partial => "wash_with_html/complex_type", :locals => { :object => hash[:obj], :class_name =>  hash[:class], :ancestors => hash[:ancestors]})
+      }
     end
     unless @fault_types.blank?
       xml.h2 "Fault types:"
-      create_html_fault_types_details(xml, @fault_types)
+      @fault_types.each  { |hash|            
+        xml <<    render(:partial => "wash_with_html/fault_type", :locals => { :object => hash[:fault], :structure =>  hash[:structure], :ancestors => hash[:ancestors]})
+      }
     end
     unless @methods.blank?
       xml.h2 "Public methods:"
-      create_html_public_methods(xml, @document.soap_actions)
+      @map =  @document.sorted_operations
+      unless @map.blank?
+        @map.each {  |operation, formats| 
+          xml <<    render(:partial => "wash_with_html/public_method", :locals => { :operation=> operation, :input =>  formats[:in], :output => formats[:out] , :exceptions => formats[:raises], :description => formats[:description]})
+        }
+      end
+      
     end
     
     if @complex_types.blank? && @fault_types.blank? &&  @methods.blank?

data/lib/washout_builder/document/exception_model.rb

@@ -12,7 +12,7 @@ module WashoutBuilder
         bool_the_same = false
         ancestors  = fault_ancestors
         if  ancestors.blank?
-          defined << fault_ancestor_hash(get_virtus_model_structure, []) 
+          defined << fault_ancestor_hash(get_fault_model_structure, []) 
         else
           defined << fault_ancestor_hash(fault_without_inheritable_elements(ancestors), ancestors)
           ancestors[0].get_fault_class_ancestors( defined)
@@ -22,7 +22,7 @@ module WashoutBuilder
       
            
       def fault_without_inheritable_elements(ancestors)
-        remove_fault_type_inheritable_elements(  ancestors[0].get_virtus_model_structure.keys)
+        remove_fault_type_inheritable_elements(  ancestors[0].get_fault_model_structure.keys)
       end
       
       def fault_ancestors
@@ -34,33 +34,44 @@ module WashoutBuilder
       end
       
       def remove_fault_type_inheritable_elements( keys)
-        get_virtus_model_structure.delete_if{|key,value|  keys.include?(key) }
+        get_fault_model_structure.delete_if{|key,value|  keys.include?(key) }
       end
        
-       
+      def check_valid_fault_method?(method)
+        method != :== && method != :! &&
+          (  self.instance_methods.include?(:"#{method}=") || 
+            self.instance_methods.include?(:"#{method}")  
+        )
+      end      
+      
       
-      def get_exception_attributes
-        attrs = self.instance_methods.find_all do |method|
-          method != :== &&
-            method != :! &&
-            self.instance_methods.include?(:"#{method}=") 
+      def get_fault_attributes
+        attrs = []
+        attrs = self.instance_methods(nil).collect 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.concat(["message", "backtrace"])
       end
       
+      def get_fault_type_method(method_name)
+        case method_name.to_s.downcase
+        when "code" 
+          "integer"
+        when "message", "backtrace"
+          "string"
+        else
+          "string"
+        end
+      end
+      
       
-      def get_virtus_model_structure
+      def get_fault_model_structure
         h = {}
-        get_exception_attributes.each do |method_name|
-          primitive_type = case method_name.to_s.downcase
-          when "code" 
-             "integer"
-          when "message", "backtrace"
-             "string"
-          else
-             "string"
-          end
-          h["#{method_name}"]= { 
+        get_fault_attributes.each do |method_name|
+          method_name = method_name.to_s.end_with?("=") ? method_name.to_s.gsub("=", '') : method_name
+          primitive_type = get_fault_type_method(method_name)
+          h["#{method_name}"]= {
             :primitive => "#{primitive_type}", 
             :member_type => nil
           }

data/lib/washout_builder/document/generator.rb

@@ -39,6 +39,19 @@ module WashoutBuilder
         soap_actions.map { |operation, formats| operation }
       end
       
+      def sorted_operations
+          soap_actions.sort_by { |operation, formats| operation.downcase }.uniq unless soap_actions.blank?
+      end
+      
+      def operation_exceptions(operation_name)
+        hash_object = soap_actions.detect {|operation, formats|  operation.to_s.downcase == operation_name.to_s.downcase}
+        unless hash_object.blank?
+          faults =  hash_object[1][:raises] 
+          faults = faults.is_a?(Array) ? faults :  [faults]
+          faults.select { |x| WashoutBuilder::Type.valid_fault_class?(x)  }
+        end
+      end
+      
       def sort_complex_types(types, type)
         types.sort_by { |hash| hash[type.to_sym].to_s.downcase }.uniq {|hash| hash[type.to_sym] } unless types.blank?
       end

data/lib/washout_builder/version.rb

@@ -1,3 +1,3 @@
 module WashoutBuilder
-  VERSION = "0.13.2"
+  VERSION = "0.13.3"
 end

data/spec/app/helpers/washout_builder_complex_type_helper_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe WashoutBuilderComplexTypeHelper  do
+  
+  
+  
+  
+end

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

@@ -1,18 +1,19 @@
 #encoding:utf-8
 require 'spec_helper'
 
-class SOAPError < WashOut::Dispatcher::SOAPError
-  
-end
 
 describe WashoutBuilder::Document::ExceptionModel do
 
-  let(:subject) { SOAPError}
+  let(:subject) { WashOut::Dispatcher::SOAPError}
   
   
   
   it "gets the strcuture" do
-    subject.get_virtus_model_structure.should eq({"code"=>{:primitive=>"integer", :member_type=>nil}, "message"=>{:primitive=>"string", :member_type=>nil}, "backtrace"=>{:primitive=>"string", :member_type=>nil}})
+    subject.get_fault_model_structure.should eq({"code"=>{:primitive=>"integer", :member_type=>nil}, "message"=>{:primitive=>"string", :member_type=>nil}, "backtrace"=>{:primitive=>"string", :member_type=>nil}})
+  end
+  
+    it "gets the strcuture" do
+    subject.get_fault_attributes.should eq(["code","message", "backtrace"])
   end
 #  
 #  it "gets the member type for arrays" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: washout_builder
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.13.3
 platform: ruby
 authors:
 - bogdanRada
@@ -48,7 +48,14 @@ files:
 - README.rdoc
 - Rakefile
 - app/controllers/washout_builder/washout_builder_controller.rb
-- app/helpers/washout_builder_helper.rb
+- app/helpers/washout_builder_complex_type_helper.rb
+- app/helpers/washout_builder_fault_type_helper.rb
+- app/helpers/washout_builder_method_arguments_helper.rb
+- app/helpers/washout_builder_method_list_helper.rb
+- app/helpers/washout_builder_method_return_type_helper.rb
+- app/views/wash_with_html/_complex_type.builder
+- app/views/wash_with_html/_fault_type.builder
+- app/views/wash_with_html/_public_method.builder
 - app/views/wash_with_html/all_services.builder
 - app/views/wash_with_html/doc.builder
 - config/routes.rb
@@ -63,7 +70,7 @@ files:
 - lib/washout_builder/type.rb
 - lib/washout_builder/version.rb
 - spec/app/controllers/washout_builder_controller_spec.rb
-- spec/app/helpers/washout_builder_helper_spec.rb
+- spec/app/helpers/washout_builder_complex_type_helper_spec.rb
 - spec/app/integration/washout_builder_all_services_spec.rb
 - spec/app/integration/washout_builder_service_spec.rb
 - spec/dummy/Rakefile
@@ -126,7 +133,7 @@ specification_version: 4
 summary: WashOut Soap Service HTML-Documentation generator (extends WashOut https://github.com/inossidabile/wash_out/)
 test_files:
 - spec/app/controllers/washout_builder_controller_spec.rb
-- spec/app/helpers/washout_builder_helper_spec.rb
+- spec/app/helpers/washout_builder_complex_type_helper_spec.rb
 - spec/app/integration/washout_builder_all_services_spec.rb
 - spec/app/integration/washout_builder_service_spec.rb
 - spec/dummy/Rakefile

data/app/helpers/washout_builder_helper.rb

@@ -1,245 +0,0 @@
-module WashoutBuilderHelper
-
-  def create_html_complex_types(xml, types)
-    types.each  { |hash| create_complex_type_html(xml, hash[:obj], hash[:class], hash[:ancestors]) }
-  end
-
-  
-  
-  def create_element_type_html(pre, complex_class, element)
-    unless  complex_class.nil?
-      if  element.multiplied == false
-        pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
-      else
-        pre << "<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
-      end
-    end
-  end
-  
-    
-  def create_class_type_html(xml, class_name, ancestors)
-    xml.h3  { |pre| pre << "#{class_name} #{ancestors.blank? ? "" : "<small>(extends <a href='##{ancestors[0].to_s.classify}'>#{ancestors[0].to_s.classify}</a>)</small>" } " }
-  end
-
-  
-  def create_complex_type_element_html(xml, element)
-    element.type = "string" if element.type == "text"
-    element.type = "integer" if element.type == "int"
-    xml.li { |pre|
-      if WashoutBuilder::Type::BASIC_TYPES.include?(element.type)
-        pre << "<span class='blue'>#{element.type}</span>&nbsp;<span class='bold'>#{element.name}</span>"
-      else
-        complex_class = element.get_complex_class_name
-        create_element_type_html(pre, complex_class, element)
-      end
-    }
-  end
-
-
-  def create_complex_type_html(xml, param, class_name, ancestors)
-    unless param.blank?
-      xml.a( "name" => "#{class_name}")  { }
-     
-      create_class_type_html(xml, class_name, ancestors)
-      if param.is_a?(WashOut::Param)
-        xml.ul("class" => "pre") {
-          param.map.each do |element|
-            create_complex_type_element_html(xml, element)
-          end
-        }
-      end
-    end
-  end
-
-  def create_html_fault_types_details(xml, fault_types)
-    unless fault_types.blank?
-      
-      fault_types.each {  |hash| 
-        create_html_virtus_model_type(xml, hash[:fault],hash[:structure],  hash[:ancestors]) 
-      }  
-    end
-  end
-
-  def create_virtus_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
-  
-  
-  def create_html_virtus_model_element_type(xml, attribute, attr_details)
-    xml.li { |pre|
-      if WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:primitive].to_s.downcase) || attr_details[:primitive] == "nilclass" 
-        pre << "<span class='blue'>#{attr_details[:primitive].to_s.downcase == "nilclass" ? "string" : attr_details[:primitive].to_s.downcase }</span>&nbsp;<span class='bold'>#{attribute}</span>"
-        
-      else
-        if  attr_details[:primitive].to_s.downcase == "array"
-          
-          attr_primitive =  WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:member_type].to_s.downcase) ? attr_details[:member_type].to_s.downcase : attr_details[:member_type]
-          create_virtus_model_complex_element_type(pre,attr_primitive, attribute, true )
-        else
-          create_virtus_model_complex_element_type(pre,attr_details[:primitive], attribute, false )
-        end
-      end
-    }
-  end
-  
-  
-  def create_html_virtus_model_type(xml, param, fault_structure, ancestors)
-    if param.is_a?(Class) 
-      create_class_type_html(xml, param, ancestors)
-      xml.a("name" => "#{param}") {}
-      xml.ul("class" => "pre") {
-        fault_structure.each do |attribute, attr_details|
-          create_html_virtus_model_element_type(xml, attribute, attr_details)
-        end
-      }
-    end
-  end
-
-  def create_html_public_methods(xml, map)
-    unless map.blank?
-      map =map.sort_by { |operation, formats| operation.downcase }.uniq
-      map.each {  |operation, formats| create_html_public_method(xml, operation, formats) }
-    end
-  end
-
-  
-  def create_return_complex_type_html(xml, complex_class, builder_out)
-    return_content =  builder_out[0].multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
-    xml.span("class" => "pre") { xml.a("href" => "##{complex_class}") { |xml| xml.span("class" => "lightBlue") { |y| y<<"#{return_content}" } } }
-  end
-
-  
-  def create_return_type_html(xml, formats)
-    xml.p "Return value:"
-    xml.ul {
-      xml.li {
-        unless formats[:builder_out].nil?
-          complex_class = formats[:builder_out][0].get_complex_class_name  
-          if WashoutBuilder::Type::BASIC_TYPES.include?(formats[:builder_out][0].type)
-            xml.span("class" => "pre") { |xml| xml.span("class" => "blue") { |sp| sp << "#{formats[:builder_out][0].type}" } }
-          else
-            create_return_complex_type_html(xml, complex_class, formats[:builder_out]) unless complex_class.nil?
-          end
-        else
-          xml.span("class" => "pre") { |sp| sp << "void" }
-        end
-        
-      }
-    }
-  end
-  
-  
-  def create_parameters_html(xml, formats)
-    xml.p "Parameters:"
-    xml.ul {
-      j=0
-      mlen = formats[:builder_in].size
-      while j<mlen
-        param = formats[:builder_in][j]
-        complex_class = param.get_complex_class_name  
-        xml.li("class" => "pre") { |pre|
-          if WashoutBuilder::Type::BASIC_TYPES.include?(param.type)
-            pre << "<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"
-          else
-            create_element_type_html(pre, complex_class, param)
-          end
-        }
-        j+=1
-      end
-      
-    }
-  end
-  
-  def create_exceptions_list_html(xml, formats)
-    unless formats[:raises].blank?
-      faults = formats[:raises]
-      faults = [formats[:raises]] if !faults.is_a?(Array)
-      
-      faults = faults.select { |x| WashoutBuilder::Type.valid_fault_class?(x)  }
-      unless faults.blank?
-        xml.p "Exceptions:"
-        xml.ul {
-          faults.each do |p|
-            xml.li("class" => "pre"){ |y| y<< "<a href='##{p.to_s}'><span class='lightBlue'> #{p.to_s}</span></a>" }
-          end
-        }
-      end
-    end
-  end
-  
-  
-  def create_html_public_method_return_type(xml,pre, formats)
-    unless formats[:builder_out].nil?
-      complex_class = formats[:builder_out][0].get_complex_class_name  
-      if WashoutBuilder::Type::BASIC_TYPES.include?(formats[:builder_out][0].type)
-        xml.span("class" => "blue") { |y| y<<  "#{formats[:builder_out][0].type}" }
-      else
-        unless complex_class.nil?
-          if  formats[:builder_out][0].multiplied == false
-            pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>"
-          else
-            pre << "<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>"
-          end
-        end
-      end
-    else
-      pre << "void"
-    end
-  end
-  
-  def create_html_public_method_arguments_complex_type(pre, spacer, use_spacer, complex_class, param)
-    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
-  
-  def create_html_public_method_arguments(xml, pre, operation, formats)
-    mlen = formats[:builder_in].size
-    xml.br if mlen > 1
-    spacer = "&nbsp;&nbsp;&nbsp;&nbsp;"
-    if mlen > 0
-      j=0
-      while j<mlen
-        param = formats[:builder_in][j]
-        complex_class = param.get_complex_class_name  
-        use_spacer =  mlen > 1 ? true : false
-        if WashoutBuilder::Type::BASIC_TYPES.include?(param.type)
-          pre << "#{use_spacer ? spacer: ''}<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"
-        else
-          unless complex_class.nil?
-            create_html_public_method_arguments_complex_type(pre, spacer, use_spacer, complex_class, param)
-          end
-        end
-        if j< (mlen-1)
-          xml.span ", "
-        end
-        if mlen > 1
-          xml.br
-        end
-        if (j+1) == mlen
-          xml.span("class" => "bold") {|y|  y << ")" }
-        end
-        j+=1
-      end
-
-    end
-  end
-  
-  
-  def create_html_public_method(xml, operation, formats)
-    # raise YAML::dump(formats[:builder_in])
-    xml.h3 "#{operation}"
-    xml.a("name" => "#{operation}") {}
-
-    xml.p("class" => "pre"){ |pre|
-      create_html_public_method_return_type(xml,pre, formats)
-       xml.span("class" => "bold") {|y|  y << "#{operation} (" }
-      create_html_public_method_arguments(xml, pre, operation, formats)
-    }
-    xml.p "#{formats[:description]}" if !formats[:description].blank?
-    create_parameters_html(xml, formats)
-    create_return_type_html(xml, formats)
-    create_exceptions_list_html(xml, formats)
-  end
-
-end

data/spec/app/helpers/washout_builder_helper_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe WashoutBuilderHelper  do
-  
-  
-  
-  
-end