washout_builder 0.3.5

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTBjY2VlMDQ3YTc5N2ZjZWIzOTU5MWI5NDEwOTBmMTMzYWM2NDVmNg==
+  data.tar.gz: !binary |-
+    OTViODkwOTQyOTY2Y2I1MjI3YmI1Mzc4OTczMjRlZDVjOTViOGYxOQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MDZkYjlkZDFlMDEwYTEwNTJjMzMyOWQxYzk2YmYxYTUyZWUwNTA4MTZhZDU2
+    NWQ2NWFhOWQxYzIyMGY3ODg1MWIxZjIyOTI1MjM3YTBkYTNmNWZkYzQ1MzQ0
+    ODA5NzgxNzdiOTUzN2Q2NTE1NGU5ZGJhZDgxN2UwZjU4ZTRiNDE=
+  data.tar.gz: !binary |-
+    Yjg5MTQ5ZDM3ZDg3NjAxY2U0ZmQ0YTIyYmRhMmZhOWY1NmExNDM5YzA5Nzk1
+    OWM2YmU3MGM1NjgzMWYxOTgzYzk4N2FkZGE4NDQ2ZDk1YWE0Zjg1MjA4OGU1
+    OWMwMzQ5YWEzZjMxZGYyZTNlYzQzN2RmOWI0NjNlMTA2ZWI3NzI=

data/.gitignore

@@ -0,0 +1,17 @@
+s.rbx/
+.bundle/
+*.gem
+.idea/
+.rvmrc
+*.swp
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+gemfiles
+coverage
+tags
+Gemfile.lock
+/nbproject/
+/.git-rewrite/

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -0,0 +1,6 @@
+before_install:
+  - gem install bundler
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - 2.0.0

data/Appraisals

@@ -0,0 +1,15 @@
+appraise "rails-3.2.8" do
+  gem "rails", "3.2.8"
+end
+
+appraise "rails-3.1.3" do
+  gem "rails", "3.1.3"
+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

data/Gemfile

@@ -0,0 +1,21 @@
+source "http://rubygems.org"
+
+gemspec
+
+
+gem 'wash_out', "~> 0.9.1"
+
+gem 'wasabi'
+gem 'savon', '>= 2.0.0'
+gem 'httpi', :git => 'git://github.com/savonrb/httpi.git'
+
+gem 'rspec-rails'
+gem 'guard'
+gem 'guard-rspec'
+gem 'rb-fsevent'
+gem 'appraisal'
+gem 'tzinfo'
+gem 'pry'
+gem 'simplecov'
+gem 'simplecov-summary'
+

data/Guardfile

@@ -0,0 +1,12 @@
+# More info at https://github.com/guard/guard#readme
+
+# Could be changed to whatever you want.
+#  See: https://github.com/guard/guard#notification
+notification :off
+
+guard 'rspec' do
+  watch %r{^spec/.+_spec\.rb$}
+  watch %r{lib/} do 'spec' end
+end
+
+# vim:ft=ruby

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 bogdanRada
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,116 @@
+= washout_builder
+
+= Overview
+WashOutBuilder is a  Soap Service Documentation generator (extends WashOut https://github.com/inossidabile/wash_out/)
+
+The way WashOut is used is not modified, it just extends its functionality by providing html documentation
+
+= Features
+
+* Provides way of seeing the available services with links to documentation, endpoint and namespace
+* Provides a human-readable HTML documentation generated  for each service that you write
+* Can also create custom exception  classes and use them to send custom fault errors to the client application
+
+= Screenshots (just an example)
+
+* {Screenshot 1}[https://f.cloud.github.com/assets/1104923/1582604/53ad8c04-51f1-11e3-963c-fb6c58d0a6a6.png]
+* {Screenshot 2}[https://f.cloud.github.com/assets/1104923/1563031/0efe630c-5058-11e3-8502-1e0b145de80c.png]
+* {Screenshot 3}[https://f.cloud.github.com/assets/1104923/1563032/0f43ddb0-5058-11e3-91d1-35409d4017b0.png]
+
+= Requirements
+
+1. {Ruby 1.9.x}[http://www.ruby-lang.org]
+2. {Ruby on Rails}[http://rubyonrails.org].
+3. {WashOut Gem v. 0.9.0}[https://github.com/inossidabile/wash_out]
+4. {Nori Gem}[https://github.com/savonrb/nori]
+
+= Compatibility
+
+Rails >3.0 only. MRI 1.9, 2.0, JRuby (--1.9).
+
+Ruby 1.8 is not officially supported since 0.5.3. We will accept further compatibilty pull-requests but no upcoming versions will be tested against it.
+
+Rubinius support temporarily dropped since 0.6.2 due to Rails 4 incompatibility.
+
+= Setup
+
+Type the following from the command line to install:
+
+  gem install washout_builder  
+
+Add the following to your Gemfile:
+
+  gem 'wash_out',"~> 0.9.0", git: 'git://github.com/inossidabile/wash_out.git'
+  gem "washout_builder"
+
+it will automatically install  also wash_out version 0.9.0 that is currently used
+
+Please read {release details}[https://github.com/bogdanRada/washout_builder/releases] if you are upgrading. We break backward compatibility between large ticks but you can expect it to be specified at release notes.
+
+= Usage
+
+The way soap_actions, or reusable types are defined or how the configuration is made using WashOut(https://github.com/inossidabile/wash_out)  haven't changed
+You can still do everything that gem does .
+
+when specifying the soap_action you can also pass a option for description and a list of exceptions that the method can raise at a certain moment.
+The exception classes used must inherit from WashOut::SoapError and have accessible_attributes in order to show up in the documentation
+
+Here is an example :
+
+ soap_action "find",  :args   => {:number => :integer} , :return => :boolean, :raises => [MyFirstExceptionClass, MySecondExceptionClass ] , :description => "some description about this method to show in the documentation"
+
+
+In order to see the documentation you must write something like this  in the routes (exactly like you would do when using only WashOut)
+
+In the following file  +config/routes.rb+ you can put this configuration 
+
+ WashOutSample::Application.routes.draw do
+  wash_out :rumbas
+  wash_out :my_other_service
+ end
+
+You can access the url +/washout+ and you will see a list with available services ( in our case there are only two : The RumbasController and MyOtherServiceController) with links to their documentation and where you can find the WSDL.
+
+If you want to access directly the hml documentation that was generated for RumbasController  you can do that by accessing url +/rumbas/doc+ And the WSDL will be available at +/rumbas/wsdl+
+
+= Setup  custom  exceptions
+
+There is a class WashOut::SoapError
+This class has as attributes :  a error_code, and a message. 
+
+If you only  want to send a faultcode for your exception in the webservice application you can do this
+
+ class MyException < WashOut::SoapError; end
+ 
+and then when you raise it in the code you can do this 
+
+  raise MyException.new (1001, "damn! found a error") . 
+
+This exception is going to be catched by the gem and is going to send it to the client with the specified fault code and message
+
+= Testing
+
+To test, do the following:
+
+1. cd to the gem root.
+2. bundle install
+3. bundle exec rake
+
+= Contributions
+
+Please log all feedback/issues via {GitHub Issues}[http://github.com/bogdanRada/washout_builder/issues]. Thanks.
+
+== Contributing to washout_builder
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 bogdanRada. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'appraisal'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Default: run the unit tests."
+task :default => [:all]
+
+desc 'Test the plugin under all supported Rails versions.'
+task :all => ["appraisal:install"] do |t|
+  exec('rake appraisal spec')
+end

data/app/controllers/washout_builder_controller.rb

@@ -0,0 +1,34 @@
+class WashoutBuilderController < ActionController::Base
+  protect_from_forgery
+
+  def all
+    # get a list of unique controller names
+    controllers = Rails.application.routes.routes.map do |route|
+      if route.defaults[:action] == "_generate_doc"
+       {:class => "#{route.defaults[:controller]}_controller".camelize.constantize, :name => route.defaults[:controller] }
+      end
+    end.uniq.compact
+
+    @services = []
+   unless controllers.blank?
+    controllers.map do |hash|
+      namespace  = hash[:class].soap_config.namespace
+      @services << {
+        :service_name =>  hash[:class].to_s.underscore.gsub("_controller", "").camelize ,
+        :namespace => namespace,
+        :endpoint => namespace.gsub("/wsdl", "/action"),
+        :documentation_url => "#{request.protocol}#{request.host_with_port}/#{hash[:name]}/doc",
+        }
+    end
+   end
+
+
+    render :template => "wash_with_html/all_services", :layout => false,
+      :content_type => 'text/html'
+
+  end
+
+
+
+
+end

data/app/helpers/washout_builder_helper.rb

@@ -0,0 +1,302 @@
+module WashoutBuilderHelper
+  include WashOutHelper
+
+  def get_complex_class_name(p, defined = [])
+    complex_class = nil
+    complex_class = p.basic_type.to_s.classify  if p.is_complex?
+    
+    if !complex_class.nil? && !defined.blank?
+     
+      found = false
+      defined.each do |hash|
+        found = true if hash[:class] == complex_class
+      end
+      if found == true && p.struct?  &&  !p.classified? && p.source_class_name.blank?
+        raise RuntimeError, "Duplicate use of `#{p.basic_type}` type name. Consider using classified types."
+      end
+    end
+
+    return complex_class
+  end
+
+
+  def get_nested_complex_types(param, defined)
+    defined = [] if defined.blank?
+    complex_class = get_complex_class_name(param, defined)
+    defined << {:class =>complex_class, :obj => param} unless complex_class.nil?
+    if param.is_complex?
+      c_names = []
+      param.map.each do |obj|
+        nested = get_nested_complex_types(obj, defined)
+        nested.each  do |hash|
+          c_names << hash
+        end
+      end
+      defined.concat(c_names)
+    end
+    defined.sort_by { |hash| hash[:class].downcase }.uniq unless defined.blank?
+  end
+
+
+  def get_complex_types(map)
+    defined = []
+    map.each do |operation, formats|
+      (formats[:input] + formats[:output]).each do |p|
+        nested = get_nested_complex_types(p, defined)
+        nested.each  do |hash|
+          defined << hash
+        end
+      end
+    end
+    defined <<  {:class =>"ValidationErrors", :obj => nil} unless get_fault_types_names(map).blank?
+    defined.sort_by { |hash| hash[:class].downcase }.uniq unless defined.blank?
+  end
+
+  def get_fault_types_names(map)
+    defined = []
+    map.each do |operation, formats|
+      faults = formats[:raises]
+      unless faults.blank?
+        faults = [formats[:raises]] if !faults.is_a?(Array)
+        faults.each do |p|
+          defined << p.to_s.classify
+        end
+      end
+    end
+    defined.sort_by { |name| name.downcase }.uniq unless defined.blank?
+  end
+
+  def get_soap_action_names(map)
+    defined = []
+    unless map.blank?
+      map.each do |operation, formats|
+        defined << operation.to_s
+      end
+    end
+    defined.sort_by { |name| name.downcase }.uniq unless defined.blank?
+  end
+
+
+
+  def create_html_complex_type_validation_errors(xml)
+    xml.a( "name" => "ValidationErrors")  { }
+    xml.h3 "ValidationErrors"
+
+    xml.ul("class" => "pre") {
+      xml.li { |pre| pre << "<span class='blue'>string</span>&nbsp;<span class='bold'>related</span>" }
+      xml.li { |pre| pre << "<span class='blue'>string</span>&nbsp;<span class='bold'>message</span>" }
+      xml.li { |pre| pre << "<span class='blue'>Array of string</span>&nbsp;<span class='bold'>arguments</span>" }
+    }
+  end
+
+
+
+  def create_html_complex_types(xml, types)
+    types.each do |hash|
+      create_complex_type_html(xml, hash[:obj], hash[:class])
+    end
+  end
+
+
+
+  def create_complex_type_html(xml, param, class_name)
+    unless param.blank?
+      xml.a( "name" => "#{class_name}")  { }
+      xml.h3 "#{class_name}"
+
+      if param.is_a?(WashoutBuilder::Param)
+        xml.ul("class" => "pre") {
+
+          param.map.each do |element|
+            # raise YAML::dump(element) if class_name.include?("ype") and element.name == "members"
+            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 = get_complex_class_name(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
+            }
+
+          end
+
+        }
+
+      end
+    end
+  end
+
+  def create_html_fault_types_details(xml, map)
+    defined = []
+    unless map.blank?
+      map =  map.sort_by { |operation, formats| formats[:raises].to_s.downcase }.uniq
+      map.each do |operation, formats|
+        faults = formats[:raises]
+        unless faults.blank?
+          faults = [formats[:raises]] if !faults.is_a?(Array)
+          faults.each do |p|
+            defined << p
+          end
+        end
+      end
+    end
+    unless defined.blank?
+      defined =  defined.sort_by { |name| name.to_s.downcase }.uniq
+      defined.each do |fault|
+        create_html_fault_type(xml, fault)
+      end
+    end
+  end
+
+  def create_html_fault_type(xml, param)
+    xml.h3 "#{param}"
+    xml.a("name" => "#{param}") {}
+    xml.ul("class" => "pre") {
+      if param.ancestors.include?(WashoutBuilder::SoapFault)
+
+        param.accessible_attributes.each do |attribute|
+          xml.li { |pre|
+            if WashoutBuilder::Type::BASIC_TYPES.include?(attribute.class.name.downcase) && attribute != "errors"
+              pre << "<span class='blue'>#{attribute.class.name.downcase}</span>&nbsp;<span class='bold'>#{attribute}</span>"
+            elsif attribute == "errors"
+              pre << "<a href='#ValidationErrors'><span class='lightBlue'>Array of ValidationErrors</span></a>&nbsp;<span class='bold'>#{attribute}</span>"
+            else
+              pre << "<a href='##{attribute.class.name}'><span class='lightBlue'>#{attribute.class.name}</span></a>&nbsp;<span class='bold'>#{attribute}</span>"
+            end
+          }
+        end
+        xml.li { |pre| pre << "<span class='blue'>string</span>&nbsp;<span class='bold'>backtrace</span>" }
+      end
+    }
+  end
+
+  def create_html_public_methods(xml, map)
+    unless map.blank?
+      map =map.sort_by { |operation, formats| operation.downcase }.uniq
+
+      map.each do |operation, formats|
+        create_html_public_method(xml, operation, formats)
+      end
+    end
+  end
+
+
+
+  def create_html_public_method(xml, operation, formats)
+    # raise YAML::dump(formats[:input])
+    xml.h3 "#{operation}"
+    xml.a("name" => "#{operation}") {}
+
+
+    xml.p("class" => "pre"){ |pre|
+      if !formats[:output].nil?
+        if WashoutBuilder::Type::BASIC_TYPES.include?(formats[:output][0].type)
+          xml.span("class" => "blue") { |y| y<<  "#{formats[:output][0].type}" }
+        else
+          xml.a("href" => "##{formats[:output][0].type}") { |xml| xml.span("class" => "lightBlue") { |y| y<<"#{formats[:output][0].type}" } }
+        end
+      else
+        pre << "void"
+      end
+
+      xml.span("class" => "bold") {|y|  y << "#{operation} (" }
+      mlen = formats[:input].size
+      xml.br if mlen > 1
+      spacer = "&nbsp;&nbsp;&nbsp;&nbsp;"
+      if mlen > 0
+        j=0
+        while j<mlen
+          param = formats[:input][j]
+          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
+            complex_class = get_complex_class_name(param)
+            unless complex_class.nil?
+              if  param.multiplied == false
+                pre << "#{use_spacer ? spacer: ''}<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"
+              else
+                pre << "#{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
+          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
+
+
+
+    }
+    xml.p "#{formats[:description]}" if !formats[:description].blank?
+    xml.p "Parameters:"
+
+    xml.ul {
+      j=0
+      mlen = formats[:input].size
+      while j<mlen
+        param = formats[:input][j]
+        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
+            complex_class = get_complex_class_name(param)
+            unless complex_class.nil?
+              if  param.multiplied == false
+                pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"
+              else
+                pre << "<a href='##{complex_class}'><span class='lightBlue'>Array of #{complex_class}</span></a>&nbsp;<span class='bold'>#{param.name}</span>"
+              end
+            end
+          end
+        }
+        j+=1
+      end
+
+    }
+
+    xml.p "Return value:"
+    xml.ul {
+      xml.li {
+        if !formats[:output].nil?
+
+          if WashoutBuilder::Type::BASIC_TYPES.include?(formats[:output][0].type)
+            xml.span("class" => "pre") { |xml| xml.span("class" => "blue") { |sp| sp << "#{formats[:output][0].type}" } }
+          else
+            xml.span("class" => "pre") { xml.a("href" => "##{formats[:output][0].type}") { |xml| xml.span("class" => "lightBlue") { |y| y<<"#{formats[:output][0].type}" } } }
+          end
+        else
+          xml.span("class" => "pre") { |sp| sp << "void" }
+        end
+
+      }
+    }
+    unless formats[:raises].blank?
+      faults = formats[:raises]
+      faults = [formats[:raises]] if !faults.is_a?(Array)
+
+      xml.p "Exceptions:"
+      xml.ul {
+        faults.each do |p|
+          xml.li("class" => "pre"){ |y| y<< "<a href='##{p.to_s.classify}'><span class='lightBlue'> #{p.to_s.classify}</span></a>" }
+        end
+      }
+    end
+  end
+
+end

data/app/views/wash_with_html/all_services.builder

@@ -0,0 +1,51 @@
+xml.instruct!
+xml.declare! :DOCTYPE, :html, :PUBLIC, "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
+
+xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
+
+  xml.head {
+
+    xml.title "Available Services"
+
+    xml.style( "type"=>"text/css" ,"media" => "all" ) { xml.text! "
+    body{font-family:Calibri,Arial;background-color:#fefefe;}
+    .pre{font-family:Courier;}
+    .normal{font-family:Calibri,Arial;}
+    .bold{font-weight:bold;}
+    h1,h2,h3{font-family:Verdana,Times;}
+    h1{border-bottom:1px solid gray;}
+    h2{border-bottom:1px solid silver;}
+    h3{border-bottom:1px dashed silver;}
+    a{text-decoration:none;}
+    a:hover{text-decoration:underline;}
+    .blue{color:#3400FF;}
+    .lightBlue{color:#5491AF;}
+      "
+
+    }
+
+    xml.style( "type"=>"text/css", "media" => "print" ) { xml.text! "
+    .noprint{display:none;}
+      "
+
+    }
+
+
+  }
+
+
+  xml.body {
+  unless @services.blank?
+
+    @services.each do |service|
+      xml.h1 "#{service[:service_name]} Soap Webservice"
+      xml.p {|pre| pre << "Documentation URI: &nbsp;<a href='#{service[:documentation_url]}'><span class='pre'>#{service[:documentation_url]}</span></a>" }
+       xml.p {|pre| pre << "Endpoint URI: &nbsp;<span class='pre'>#{service[:endpoint]}</span>" }
+      xml.p {|pre|  pre << "WSDL URI: &nbsp;<a href='#{service[:namespace]}'><span class='pre'>#{service[:namespace]}</span></a>" }
+    end
+  end
+  
+  }
+
+
+}

data/app/views/wash_with_html/doc.builder

@@ -0,0 +1,118 @@
+xml.instruct!
+xml.declare! :DOCTYPE, :html, :PUBLIC, "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
+
+xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
+
+  xml.head {
+
+    xml.title "#{@service} interface description"
+
+    xml.style( "type"=>"text/css" ,"media" => "all" ) { xml.text! "
+    body{font-family:Calibri,Arial;background-color:#fefefe;}
+    .pre{font-family:Courier;}
+    .normal{font-family:Calibri,Arial;}
+    .bold{font-weight:bold;}
+    h1,h2,h3{font-family:Verdana,Times;}
+    h1{border-bottom:1px solid gray;}
+    h2{border-bottom:1px solid silver;}
+    h3{border-bottom:1px dashed silver;}
+    a{text-decoration:none;}
+    a:hover{text-decoration:underline;}
+    .blue{color:#3400FF;}
+    .lightBlue{color:#5491AF;}
+      "
+
+    }
+
+    xml.style( "type"=>"text/css", "media" => "print" ) { xml.text! "
+    .noprint{display:none;}
+      "
+
+    }
+
+
+  }
+
+  xml.body {
+
+
+    xml.h1 "#{ @service} Soap WebService interface description"
+
+    xml.p{ |y| y << "Endpoint URI:";
+      xml.span( "class" => "pre") { |y| y << "#{@endpoint}"};
+    }
+
+    xml.p{ |y| y << "WSDL URI:";
+      xml.span( "class" => "pre") {
+        xml.a( "href" => "#{@namespace}") { |y| y << "#{@namespace}" }
+      };}
+
+    unless @service_description.blank?
+      xml.h1 "#{@service}"
+      xml.p "#{@service_description}"
+    end
+
+    xml.div("class" => "noprint") {
+
+      xml.h2 "Index "
+      xml.p  "Complex Types: "
+      @complex_types =  get_complex_types(@map)
+      xml.ul do
+        @complex_types.each do |hash|
+          xml.li { |y| y << "<a href='##{hash[:class]}'><span class='pre'>#{hash[:class]}</span></a>" }
+        end
+      end
+
+
+      @fault_types = get_fault_types_names(@map)
+      unless @fault_types.blank?
+        xml.p  "Fault Types: "
+
+        xml.ul do
+          @fault_types.each do |name|
+            xml.li { |y| y << "<a href='##{name}'><span class='pre'>#{name}</span></a>" }
+          end
+        end
+      end
+
+
+      methods = get_soap_action_names(@map)
+      unless methods.blank?
+        xml.p  "Public Methods:"
+
+        xml.ul do
+          methods.each do |name|
+            xml.li { |y| y << "<a href='##{name}'><span class='pre'>#{name}</span></a>" }
+          end
+        end
+      end
+
+
+
+    }
+
+
+    xml.h2 "Complex types:"
+
+    create_html_complex_types(xml, @complex_types)
+
+
+
+    unless @fault_types.blank?
+        create_html_complex_type_validation_errors(xml)
+       xml.h2 "Fault types:"
+       create_html_fault_types_details(xml, @map)
+     end
+
+
+
+    xml.h2 "Public methods:"
+    create_html_public_methods(xml, @map)
+
+
+
+
+
+  }
+
+}

data/app/views/wash_with_soap/document/custom_error.builder

@@ -0,0 +1,10 @@
+xml.instruct!
+xml.tag! "soap:Envelope", "xmlns:soap" => 'http://schemas.xmlsoap.org/soap/envelope/' do
+  xml.tag! "soap:Body" do
+    xml.tag! "soap:Fault" do
+      xml.faultcode error_faultcode
+      xml.faultstring error_message
+      xml.errors errors
+    end
+  end
+end

data/app/views/wash_with_soap/rpc/custom_error.builder

@@ -0,0 +1,11 @@
+xml.instruct!
+xml.tag! "soap:Envelope", "xmlns:soap" => 'http://schemas.xmlsoap.org/soap/envelope/',
+                          "xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance' do
+  xml.tag! "soap:Body" do
+    xml.tag! "soap:Fault", :encodingStyle => 'http://schemas.xmlsoap.org/soap/encoding/' do
+     xml.faultcode error_faultcode
+      xml.faultstring error_message
+      xml.errors errors
+    end
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'washout_builder'

data/lib/washout_builder.rb

@@ -0,0 +1,54 @@
+require 'wash_out'
+
+require 'washout_builder/soap'
+require 'washout_builder/param'
+require 'washout_builder/engine'
+require 'washout_builder/dispatcher'
+require 'washout_builder/type'
+
+
+module ActionDispatch::Routing
+  class  Mapper
+
+    alias_method  :original_wash_out,:wash_out
+
+    # Adds the routes for a SOAP endpoint at +controller+.
+    def wash_out(controller_name, options={})
+      options.reverse_merge!(@scope) if @scope
+
+      match "#{controller_name}/doc"   => "#{controller_name}#_generate_doc", :via => :get, :format => false
+      original_wash_out(controller_name, options)
+
+
+    end
+  end
+end
+
+
+
+
+Mime::Type.register "application/soap+xml", :soap
+ActiveRecord::Base.send :extend, WashOut::Model if defined?(ActiveRecord)
+
+WashOut::SOAP::ClassMethods.class_eval do
+  alias_method :original_soap_action, :soap_action
+end
+
+ActionController::Renderers.add :soap do |what, options|
+  _render_soap(what, options)
+end
+
+ActionController::Base.class_eval do
+
+  # Define a SOAP service. The function has no required +options+:
+  # but allow any of :parser, :namespace, :wsdl_style, :snakecase_input,
+  # :camelize_wsdl, :wsse_username, :wsse_password and :catch_xml_errors.
+  #
+  # Any of the the params provided allows for overriding the defaults
+  # (like supporting multiple namespaces instead of application wide such)
+  #
+  def self.soap_service(options={})
+    include WashoutBuilder::SOAP
+    self.soap_config = options
+  end
+end

data/lib/washout_builder/dispatcher.rb

@@ -0,0 +1,44 @@
+require 'nori'
+
+module WashoutBuilder
+  # The WashoutBuilder::Dispatcher module should be included in a controller acting
+  # as a SOAP endpoint. It includes actions for generating WSDL and handling
+  # SOAP requests.
+  module Dispatcher
+    extend WashOut::Dispatcher
+
+    def _generate_doc
+      @map       = self.class.soap_actions
+      @namespace = soap_config.namespace
+      @name      = controller_path.gsub('/', '_')
+      @service = self.class.name.underscore.gsub("_controller", "").camelize
+      @endpoint  = @namespace.gsub("/wsdl", "/action")
+
+      render :template => "wash_with_html/doc", :layout => false,
+        :content_type => 'text/html'
+    end
+
+    def self.included(controller)
+      controller.send :rescue_from, WashOut::Dispatcher::SOAPError, :with => :_render_soap_exception
+      controller.send :helper, :wash_out, :washout_builder
+      controller.send :before_filter, :_parse_soap_parameters, :except => [
+        :_generate_wsdl, :_generate_doc, :_invalid_action ]
+      controller.send :before_filter, :_authenticate_wsse,     :except => [
+        :_generate_wsdl,:_generate_doc,:_invalid_action ]
+      controller.send :before_filter, :_map_soap_parameters,   :except => [
+        :_generate_wsdl, :_generate_doc,:_invalid_action ]
+      controller.send :skip_before_filter, :verify_authenticity_token
+      controller.send :around_filter, :_catch_soap_faults
+    end
+
+    def _catch_soap_faults
+      yield
+    rescue => exception
+      if exception.class <= WashOut::Dispatcher::SOAPError
+        _render_soap_fault_exception(exception)
+      else
+        raise exception
+      end
+    end
+  end
+end

data/lib/washout_builder/engine.rb

@@ -0,0 +1,13 @@
+module WashoutBuilder
+  class Engine < ::Rails::Engine
+    config.wash_out = ActiveSupport::OrderedOptions.new
+    initializer "wash_out.configuration" do |app|
+      app.routes.append do
+          match "/washout"   => "washout_builder#all", :via => :get, :format => false
+      end
+      if app.config.wash_out[:catch_xml_errors]
+        app.config.middleware.insert_after 'ActionDispatch::ShowExceptions',  WashOut::Middleware
+      end
+    end
+  end
+end

data/lib/washout_builder/param.rb

@@ -0,0 +1,51 @@
+module WashoutBuilder
+  class Param < WashOut::Param
+   
+    attr_accessor :source_class_name
+    
+    def initialize(soap_config, name, type, class_name, multiplied = false)
+      @source_class_name = class_name
+       super(soap_config, name, type, multiplied )
+    end
+    
+    def self.parse_def(soap_config, definition)
+      raise RuntimeError, "[] should not be used in your params. Use nil if you want to mark empty set." if definition == []
+      return [] if definition == nil
+
+      definition_class_name = nil
+      if definition.is_a?(Class) && definition.ancestors.include?(WashOut::Type)
+        definition_class_name = definition.to_s.classify
+        definition = definition.wash_out_param_map
+      end
+
+      if [Array, Symbol].include?(definition.class)
+        definition = { :value => definition }
+      end
+
+      if definition.is_a? Hash
+        definition.map do |name, opt|
+          if opt.is_a? WashoutBuilder::Param
+             opt
+          elsif opt.is_a? Array
+           WashoutBuilder::Param.new(soap_config, name, opt[0],definition_class_name, true)
+          else
+            WashoutBuilder::Param.new(soap_config, name, opt, definition_class_name)
+          end
+        end
+      else
+        raise RuntimeError, "Wrong definition: #{definition.inspect}"
+      end
+    end
+    
+    def basic_type
+      return source_class_name unless source_class_name.nil?
+      super
+    end
+  
+    def is_complex?
+      !source_class_name.nil? || (struct? && classified? ) || struct?
+    end
+    
+    
+  end
+end

data/lib/washout_builder/soap.rb

@@ -0,0 +1,35 @@
+require 'active_support/concern'
+
+module WashoutBuilder
+  module SOAP
+    extend ActiveSupport::Concern
+    include WashOut::SOAP
+  
+    
+      module ClassMethods
+       
+      # Define a SOAP action +action+. The function has two required +options+:
+      # :args and :return. Each is a type +definition+ of format described in
+      # WashOut::Param#parse_def.
+      #
+      # An optional option :to can be passed to allow for names of SOAP actions
+      # which are not valid Ruby function names.
+      def soap_action(action, options={})
+          original_soap_action(action, options)
+          
+          current_action = self.soap_actions[action]
+        
+          current_action[:input] = WashoutBuilder::Param.parse_def(soap_config, options[:args])
+          current_action[:output] = WashoutBuilder::Param.parse_def(soap_config, options[:return])
+         
+      end
+    end
+    
+
+    included do
+      include WashOut::Configurable
+      include WashoutBuilder::Dispatcher
+      self.soap_actions = {}
+    end
+  end
+end

data/lib/washout_builder/type.rb

@@ -0,0 +1,17 @@
+module WashoutBuilder
+  class Type < WashOut::Type
+
+
+    BASIC_TYPES=[
+      "string",
+      "integer",
+      "double",
+      "boolean",
+      "date",
+      "datetime",
+      "float",
+      "time"
+    ]
+
+  end
+end

data/lib/washout_builder/version.rb

@@ -0,0 +1,3 @@
+module WashoutBuilder
+  VERSION = "0.3.5"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] = "test"
+
+require "simplecov"
+SimpleCov.start do
+  add_filter 'spec'
+  add_group 'Library', 'lib'
+  add_group 'App', 'app'
+
+  at_exit do; end
+end
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+require "rspec/rails"
+require "pry"
+require "savon"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  require 'rspec/expectations'
+  config.include RSpec::Matchers
+
+  config.mock_with :rspec
+  config.before(:all) do
+    WashOut::Engine.config.wash_out = {
+      snakecase_input: false,
+      camelize_wsdl: false,
+      namespace: false
+    }
+  end
+
+  config.after(:suite) do
+    if SimpleCov.running
+      silence_stream(STDOUT) do
+        SimpleCov::Formatter::HTMLFormatter.new.format(SimpleCov.result)
+      end
+
+      SimpleCov::Formatter::SummaryFormatter.new.format(SimpleCov.result)
+    end
+  end
+end
+
+HTTPI.logger = Logger.new(open("/dev/null", 'w'))
+HTTPI.adapter = :rack
+
+HTTPI::Adapter::Rack.mount 'app', Dummy::Application
+Dummy::Application.routes.draw do
+  wash_out :api
+end
+
+def mock_controller(options = {}, &block)
+  Object.send :remove_const, :ApiController if defined?(ApiController)
+  Object.send :const_set, :ApiController, Class.new(ApplicationController) {
+    soap_service options.reverse_merge({
+      snakecase_input: true,
+      camelize_wsdl: true,
+      namespace: false
+    })
+    class_exec &block if block
+  }
+
+  ActiveSupport::Dependencies::Reference.instance_variable_get(:'@store').delete('ApiController')
+end

data/washout_builder.gemspec

@@ -0,0 +1,19 @@
+require File.expand_path("../lib/washout_builder/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "washout_builder"
+  s.version     = WashoutBuilder::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "WashOut Soap Service Documentation builder (extends WashOut https://github.com/inossidabile/wash_out/)"
+  s.email       = "raoul_ice@yahoo.com"
+  s.homepage    = "http://github.com/bogdanRada/washout_builder/"
+  s.description = "WashOut Soap Service Documentation builder (extends WashOut https://github.com/inossidabile/wash_out/) "
+  s.authors     = ["bogdanRada"]
+  s.date = "2013-11-20"
+  
+  s.licenses = ["MIT"]
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.add_dependency("nori", ">= 2.0.0")
+  s.add_dependency("wash_out", "= 0.9.1")
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: washout_builder
+version: !ruby/object:Gem::Version
+  version: 0.3.5
+platform: ruby
+authors:
+- bogdanRada
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nori
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: wash_out
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+description: ! 'WashOut Soap Service Documentation builder (extends WashOut https://github.com/inossidabile/wash_out/) '
+email: raoul_ice@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Appraisals
+- Gemfile
+- Guardfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- app/controllers/washout_builder_controller.rb
+- app/helpers/washout_builder_helper.rb
+- app/views/wash_with_html/all_services.builder
+- app/views/wash_with_html/doc.builder
+- app/views/wash_with_soap/document/custom_error.builder
+- app/views/wash_with_soap/rpc/custom_error.builder
+- init.rb
+- lib/washout_builder.rb
+- lib/washout_builder/dispatcher.rb
+- lib/washout_builder/engine.rb
+- lib/washout_builder/param.rb
+- lib/washout_builder/soap.rb
+- lib/washout_builder/type.rb
+- lib/washout_builder/version.rb
+- spec/spec_helper.rb
+- washout_builder.gemspec
+homepage: http://github.com/bogdanRada/washout_builder/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: WashOut Soap Service Documentation builder (extends WashOut https://github.com/inossidabile/wash_out/)
+test_files: []