wash_out 0.1

data/README.rdoc

@@ -0,0 +1,55 @@
+== Wash Out
+
+Wash Out is very simple SOAP service solution. It allows you to create SOAP services on top of your controllers in 3 steps (see Usage).
+
+== Install
+
+  gem install wash_out
+  
+== Usage
+
+=== I. Define structure in your controller
+
+  class TestController < ApplicationController
+    wash_with_soap :my_soap_method => { 
+      :in => { 'structure' => { 'foo' => :string }, 'bar' => :integer },
+      :out => :boolean
+    }
+
+Defined this way method "my_soap_method" will wait for two parameters:
+
+1. 'structure' will wait for complex type (defined separately in WSDL)
+2. 'bar' will wait for string (xsd:string in WSDL)
+  
+On the other side it will return boolean (xsd:boolean in WSDL).
+
+=== II. Define worker
+
+At same controller define action "my_soap_method"
+
+  def my_soap_method
+    @soap # this will contain data passed by SOAP request
+  end
+  
+Parameters are handling by WashOut::Param entity. To get values use 'value' and '[]' methods.
+
+To get 'bar' parameter: 
+  @soap['bar'].value
+  
+To get 'foo' from 'structure': 
+  @soap['structure']['foo'].value
+
+=== III. Return something
+
+Return from your method to respond. In our case we should just respond with 
+  return true #or return false
+  
+In complex scenarios we can do 
+  return { :foo => 'foo', :bar => 'bar' }
+  
+  
+== Complex cases
+
+=== I have same substructures for several methods. Are there any ways to define WSDL besides hash?
+
+=== How to respond with SOAP error?

data/app/helpers/wash_out_helper.rb

@@ -0,0 +1,41 @@
+module WashOutHelper
+  def wsdl_data(xml, param)
+    if param.struct?
+      param.value.values.each do |p|
+        wsdl_data xml, p
+      end
+    else
+      xml.tag! param.name, param.value.to_s
+    end
+  end
+  
+  def wsdl_type(xml, param)
+    more = []
+    
+    if param.struct?
+      return if param.value.blank?
+      
+      xml.complexType :name => param.name do
+        xml.sequence do
+          param.value.each do |key, value|
+            more << value if value.struct?
+            xml.element wsdl_occurence(value, :name => key, :type => value.namespaced_type)
+          end
+        end
+      end
+    end
+    
+    more.each do |p|
+      wsdl_type xml, p
+    end
+  end
+  
+  def wsdl_occurence(param, extend_with = {})
+    data = !param.multiplied ? {} : {
+      :minOccurs => 0,
+      :maxOccurs => 'unbounded'
+    }
+    
+    return extend_with.merge(data)
+  end
+end

data/app/views/wash_with_soap/error.builder

@@ -0,0 +1,10 @@
+xml.instruct!
+xml.Envelope "xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance',
+             :xmlns => 'http://schemas.xmlsoap.org/soap/envelope/' do
+  xml.Body do
+    xml.Fault :encodingStyle => 'http://schemas.xmlsoap.org/soap/encoding/' do
+      xml.faultcode "Server", 'xsi:type' => 'xsd:QName'
+      xml.faultstring @error, 'xsi:type' => 'xsd:string'
+    end
+  end
+end

data/app/views/wash_with_soap/response.builder

@@ -0,0 +1,7 @@
+xml.instruct!
+xml.Envelope "xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance',
+             :xmlns => 'http://schemas.xmlsoap.org/soap/envelope/' do
+  xml.Body do
+    wsdl_data xml, @result
+  end
+end

data/app/views/wash_with_soap/wsdl.builder

@@ -0,0 +1,75 @@
+xml.instruct!
+xml.definitions 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema', 
+                'xmlns:soap' => 'http://schemas.xmlsoap.org/wsdl/soap/', 
+                'xmlns:soapenc' => 'http://schemas.xmlsoap.org/soap/encoding/',
+                'xmlns:wsdl' => 'http://schemas.xmlsoap.org/wsdl/',
+                'xmlns:typens' => @namespace,
+                'targetNamespace' => @namespace,
+                'xmlns' => 'http://schemas.xmlsoap.org/wsdl/' do
+  xml.types do
+    xml.tag! "xsd:schema", :xmlns => 'http://www.w3.org/2001/XMLSchema', :targetNamespace => @namespace
+    
+    @map.each do |operation, formats|
+      formats.each do |kind, params|
+        if params.struct?
+          params.value.each{|foo, p| wsdl_type xml, p}
+        end
+      end
+    end
+  end
+  
+  @map.each do |operation, formats|
+    xml.message :name => "#{operation}" do
+      if formats[:in].struct?
+        formats[:in].value.each do |name, p|
+          xml.part wsdl_occurence(p, :name => p.name, :type => p.namespaced_type)
+        end
+      else
+        xml.part wsdl_occurence(formats[:in], :name => operation, :type => formats[:in].namespaced_type)
+      end
+    end
+    xml.message :name => "#{operation}_responce" do
+      if formats[:out].struct?
+        formats[:out].value.each do |name, p|
+          xml.part wsdl_occurence(p, :name => p.name, :type => p.namespaced_type)
+        end
+      else
+        xml.part wsdl_occurence(formats[:out], :name => operation, :type => formats[:out].namespaced_type)
+      end
+    end
+  end
+  
+  xml.portType :name => "#{@name}_port" do
+    @map.keys.each do |operation|
+      xml.operation :name => operation do
+        xml.input :message => "typens:#{operation}"
+        xml.otput :message => "typens:#{operation}_responce"
+      end
+    end
+  end
+  
+  xml.binding :name => "#{@name}_binding", :type => "typens:#{@name}_port" do
+    xml.tag! "soap:binding", :style => 'rpc', :transport => 'http://schemas.xmlsoap.org/soap/http'
+    @map.keys.each do |operation|
+      xml.operation :name => operation do
+        xml.tag! "soap:operation", :soapAction => operation
+        xml.input do
+          xml.tag! "soap:body", 
+            :use => "encoded", :encodingStyle => 'http://schemas.xmlsoap.org/soap/encoding/',
+            :namespace => @namespace
+        end
+        xml.output do
+          xml.tag! "soap:body", 
+            :use => "encoded", :encodingStyle => 'http://schemas.xmlsoap.org/soap/encoding/',
+            :namespace => @namespace
+        end
+      end
+    end
+  end
+  
+  xml.service :name => "service" do
+    xml.port :name => "#{@name}_port", :binding => "#{@name}_binding" do
+      xml.tag! "soap:address", :location => url_for(:action => :soap, :only_path => false)
+    end
+  end
+end

data/init.rb

@@ -0,0 +1,19 @@
+require 'crack/xml'
+require 'wash_out/param'
+require 'wash_out/dispatcher'
+require 'wash_out/wash_with_soap'
+
+ActionController::Base.class_eval do
+  include WashOut::WashWithSoap
+end
+
+ActionController::Base.helper(WashOutHelper)
+
+module ActionDispatch::Routing
+  class Mapper
+    def wash_with_soap(controller)
+      match "#{controller.to_s}/wsdl" => "#{controller.to_s}#wsdl"
+      match "#{controller.to_s}/soap" => "#{controller.to_s}#soap"
+    end
+  end
+end

data/lib/wash_out/dispatcher.rb

@@ -0,0 +1,32 @@
+module WashOut
+  module Dispatcher
+    def wsdl
+      @map       = self.class.wash_with_soap_map
+      @name      = controller_path.gsub('/', '_')
+      @namespace = 'urn:WashOut'
+      
+      render :template => 'wash_with_soap/wsdl'
+    end
+    
+    def soap
+      @map     = self.class.wash_with_soap_map
+      @method  = request.env['HTTP_SOAPACTION'].gsub(/^\"(.*)\"$/, '\1')
+      @current = @map[@method] || @map[@method.to_sym]
+      
+      wash_out_error("Method does not exist") and return if @current.blank?
+      
+      data = Crack::XML.parse(request.raw_post).values.first.select{|k,v| k[-4,4] == "Body"}.values.first[@method]
+      
+      @soap   = @current[:in].load(data)
+      @result = @current[:out].load(send @method.to_sym)
+      
+      render :template => 'wash_with_soap/response'
+    end
+    
+  private
+    
+    def wash_out_error(description)
+      @error = description and render :template => 'wash_with_soap/error'
+    end
+  end
+end

data/lib/wash_out/param.rb

@@ -0,0 +1,66 @@
+module WashOut
+  class Param
+    attr_accessor :name
+    attr_accessor :map
+    attr_accessor :type
+    attr_accessor :multiplied
+    
+    attr_accessor :value
+    def value
+      struct? ? map : @value
+    end
+    
+    def [](key)
+      map[key]
+    end
+    
+    def struct?
+      type == 'struct'
+    end
+    
+    def namespaced_type
+      struct? ? "typens:#{name}" : "xsd:#{type}"
+    end
+    
+    def initialize(name, type, multiplied = false)
+      type ||= {}
+      
+      @name       = name.to_s
+      @map        = {}
+      @multiplied = multiplied
+
+      if type.is_a?(Hash)
+        @type = 'struct'
+        
+        type.each do |name, type|
+          if type.is_a?(Array)
+            @map[name.to_s] = Param.new(name, type[0], true) 
+          else
+            @map[name.to_s] = Param.new(name, type)
+          end
+        end
+      else
+        @type = type.to_s
+      end
+    end
+    
+    def load(data)
+      if struct?
+        map.each do |name, param|
+          param.load(data[name] || data[name.to_sym])
+        end
+      else
+        @value = Param.convert_scalar(data, type)
+      end
+      
+      self
+    end
+    
+    def self.convert_scalar(data, type)
+      return data.to_s    if type == 'string'
+      return data.to_i    if type == 'integer'
+      return data.to_f    if type == 'double'
+      return data.to_bool if type == 'boolean'
+    end
+  end
+end

data/lib/wash_out/wash_with_soap.rb

@@ -0,0 +1,24 @@
+module WashOut
+  module WashWithSoap
+    def self.included(base)
+      
+      base.class_eval do
+        class <<self
+          attr_accessor :wash_with_soap_map
+        end
+        
+        def self.wash_with_soap(map)
+          map.each do |method, params|
+            params[:in]  = WashOut::Param.new(method, map[method][:in]) unless map[method][:in].is_a?(Param)
+            params[:out] = WashOut::Param.new("#{method}_responce", map[method][:out]) unless map[method][:out].is_a?(Param)
+          end
+          
+          self.wash_with_soap_map = map
+          
+          include WashOut::Dispatcher
+        end
+      end
+      
+    end
+  end
+end

data/wash_out.gemspec

@@ -0,0 +1,16 @@
+SPEC = Gem::Specification.new do |s|
+  s.name        = "wash_out"
+  s.version     = "0.1"
+  s.platform    = Gem::Platform::RUBY  
+  s.summary     = "Dead simple Rails 3 SOAP server library"
+  s.email       = "boris@roundlake.ru"
+  s.homepage    = "http://github.com/roundlake/wash_out"
+  s.description = "Dead simple Rails 3 SOAP server library"
+  s.authors     = ['Boris Staal']
+
+  s.add_dependency "crack"
+
+  s.has_rdoc = false # disable rdoc generation until we've got more
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: wash_out
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Boris Staal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: &70092761237000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70092761237000
+description: Dead simple Rails 3 SOAP server library
+email: boris@roundlake.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.rdoc
+- app/helpers/wash_out_helper.rb
+- app/views/wash_with_soap/error.builder
+- app/views/wash_with_soap/response.builder
+- app/views/wash_with_soap/wsdl.builder
+- init.rb
+- lib/wash_out/dispatcher.rb
+- lib/wash_out/param.rb
+- lib/wash_out/wash_with_soap.rb
+- wash_out.gemspec
+homepage: http://github.com/roundlake/wash_out
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Dead simple Rails 3 SOAP server library
+test_files: []