wash_out 0.2.6 → 0.3.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    wash_out (0.2.5)
+    wash_out (0.3.0)
       nori
 
 GEM

data/README.md

@@ -59,7 +59,7 @@ class RumbasController < ApplicationController
               :args   => { :circle => { :center => { :x => :integer,
                                                      :y => :integer },
                                         :radius => :double } },
-              :return => [],
+              :return => nil, # [] for wash_out below 0.3.0
               :to     => :add_circle
   def add_circle
     circle = params[:circle]
@@ -100,6 +100,11 @@ client.wsdl.soap_actions # => [:integer_to_string, :concat, :add_circle]
 result = client.request(:concat) do
   soap.body = { :a => "123", :b => "abc" }
 end
+
+# actual wash_out
+result.to_hash # => {:concat_reponse => {:value=>"123abc"}}
+
+# wash_out below 0.3.0 (and this is malformed response so please update)
 result.to_hash # => {:value=>"123abc"}
 ```
 

data/app/helpers/wash_out_helper.rb

@@ -1,11 +1,24 @@
 module WashOutHelper
-  def wsdl_data(xml, param)
-    if param.is_a? Hash
-      wsdl_data xml, param.map
-    else
-      param.each do |opt, value|
-        xml.tag! opt.name, value.to_s
+  def wsdl_data(xml, params)
+    params.each do |param|
+      if param.multiplied
+        param.value.each{|v| wsdl_data_value xml, param, v}
+      else
+        wsdl_data_value xml, param
+      end
+    end
+  end
+  
+  def wsdl_data_value(xml, param, value=false)
+    value  ||= param.value.to_s
+    tag_name = "tns:#{param.name}"
+    
+    if param.struct?
+      xml.tag! tag_name, "xsi:type" => param.namespaced_type do
+        wsdl_data(xml, param.map)
       end
+    else
+      xml.tag! tag_name, value, "xsi:type" => param.namespaced_type
     end
   end
 
@@ -30,8 +43,8 @@ module WashOutHelper
 
   def wsdl_occurence(param, extend_with = {})
     data = !param.multiplied ? {} : {
-      :minOccurs => 0,
-      :maxOccurs => 'unbounded'
+      "xsi:minOccurs" => 0,
+      "xsi:maxOccurs" => 'unbounded'
     }
 
     extend_with.merge(data)

data/app/views/wash_with_soap/response.builder

@@ -1,7 +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
-    wsdl_data xml, result
+xml.tag! "soap:Envelope", "xmlns:soap" => 'http://schemas.xmlsoap.org/soap/envelope/',
+             "xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance',
+             "xmlns:tns" => @namespace do
+  xml.tag! "soap:Body" do
+    xml.tag! "tns:#{@operation}_response" do
+      wsdl_data xml, result
+    end
   end
-end
+end

data/app/views/wash_with_soap/wsdl.builder

@@ -3,6 +3,7 @@ xml.definitions 'xmlns' => 'http://schemas.xmlsoap.org/wsdl/',
                 'xmlns:tns' => @namespace,
                 'xmlns:soap' => 'http://schemas.xmlsoap.org/wsdl/soap/',
                 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+                "xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance',
                 'xmlns:soap-enc' => 'http://schemas.xmlsoap.org/soap/encoding/',
                 'xmlns:wsdl' => 'http://schemas.xmlsoap.org/wsdl/',
                 'name' => @name,

data/lib/wash_out/dispatcher.rb

@@ -5,6 +5,9 @@ module WashOut
   # as a SOAP endpoint. It includes actions for generating WSDL and handling
   # SOAP requests.
   module Dispatcher
+    # Default Type namespace
+    NAMESPACE = 'urn:WashOut'
+    
     # A SOAPError exception can be raised to return a correct SOAP error
     # response.
     class SOAPError < Exception; end
@@ -35,7 +38,7 @@ module WashOut
     # This action generates the WSDL for defined SOAP methods.
     def _generate_wsdl
       @map       = self.class.soap_actions
-      @namespace = 'urn:WashOut'
+      @namespace = NAMESPACE
       @name      = controller_path.gsub('/', '_')
 
       render :template => 'wash_with_soap/wsdl'
@@ -43,17 +46,25 @@ module WashOut
 
     # Render a SOAP response.
     def _render_soap(result, options)
-      soap_action = request.env['wash_out.soap_action']
-      action_spec = self.class.soap_actions[soap_action]
+      @namespace  = NAMESPACE
+      @operation  = soap_action = request.env['wash_out.soap_action']
+      action_spec = self.class.soap_actions[soap_action][:out].clone
 
       result = { 'value' => result } unless result.is_a? Hash
       result = HashWithIndifferentAccess.new(result)
-      result = Hash[*action_spec[:out].map do |param|
-        [param, param.store(result[param.name])]
-      end.flatten]
+      
+      inject = lambda {|data, spec|
+        spec.each do |param|
+          if param.struct?
+            inject.call(data[param.name], param.map)
+          else
+            param.value = data[param.name]
+          end
+        end
+      }
 
       render :template => 'wash_with_soap/response',
-             :locals => { :result => result }
+             :locals => { :result => inject.call(result, action_spec) }
     end
 
     # This action is a fallback for all undefined SOAP actions.

data/lib/wash_out/param.rb

@@ -4,6 +4,7 @@ module WashOut
     attr_accessor :map
     attr_accessor :type
     attr_accessor :multiplied
+    attr_accessor :value
 
     # Defines a WSDL parameter with name +name+ and type specifier +type+.
     # The type specifier format is described in #parse_def.
@@ -27,27 +28,26 @@ module WashOut
     def load(data)
       check_if_missing(data)
 
+      data = Array(data) if @multiplied
+
       if struct?
         map_struct(data) { |param, elem| param.load(elem) }
       else
-        case type
-          when 'string';  data.to_s
-          when 'integer'; data.to_i
-          when 'double';  data.to_f
-          when 'boolean'; data # Nori handles that for us
+        operation = case type
+          when 'string';  :to_s
+          when 'integer'; :to_i
+          when 'double';  :to_f
+          when 'boolean'; nil # Nori handles that for us
           else raise RuntimeError, "Invalid WashOut simple type: #{type}"
         end
-      end
-    end
-
-    # The opposite of #load.
-    def store(data)
-      check_if_missing(data)
-
-      if struct?
-        map_struct(data) { |param, elem| param.store(elem) }
-      else
-        data.to_s
+        
+        if operation.nil?
+          data
+        elsif data.is_a? Array
+          data.map{|x| x.send(operation)}
+        else
+          data.send(operation)
+        end
       end
     end
 
@@ -78,24 +78,37 @@ module WashOut
     #
     # This function returns an array of WashOut::Param objects.
     def self.parse_def(definition)
-      definition = { :value => definition } if definition.is_a? Symbol
+      raise RuntimeError, "[] should not be used in your params. Use nil if you want to mark empty set." if definition == []
+      return [] if definition == nil
+      
+      if [Array, Symbol].include?(definition.class)
+        definition = { :value => definition }
+      end
 
       if definition.is_a? Hash
         definition.map do |name, opt|
           if opt.is_a? WashOut::Param
             opt
+          elsif opt.is_a? Array
+            WashOut::Param.new(name, opt[0], true)
           else
             WashOut::Param.new(name, opt)
           end
         end
       else
-        definition.to_a
+        raise RuntimeError, "Wrong definition: #{type.inspect}"
       end
     end
+    
+    def clone
+      copy = self.class.new(@name, @type.to_sym, @multiplied)
+      copy.map = @map.map{|x| x.clone}
+      copy
+    end
 
     private
 
-    # Used to load or store an entire structure.
+    # Used to load an entire structure.
     def map_struct(data)
       data   = data.with_indifferent_access
       struct = {}.with_indifferent_access

data/lib/wash_out/version.rb

@@ -1,3 +1,3 @@
 module WashOut
-  VERSION = "0.2.6"
+  VERSION = "0.3.0"
 end

data/spec/wash_out_spec.rb

@@ -17,12 +17,12 @@ describe WashOut do
 
   it "should generate WSDL" do
     mock_controller do
-      soap_action "answer", :args => [], :return => :int
+      soap_action "answer", :args => nil, :return => :int
       def answer
         render :soap => "42"
       end
 
-      soap_action "getArea", :args   => { :circle => { :center => { :x => :integer,
+      soap_action "getArea", :args   => { :circle => { :center => { :x => [:integer],
                                                                     :y => :integer },
                                                        :radius => :double } },
                              :return => { :area => :double,
@@ -34,7 +34,7 @@ describe WashOut do
                           :distance_from_o => Math.sqrt(circle[:center][:x] ** 2 + circle[:center][:y] ** 2) }
       end
     end
-
+    
     client = savon_instance
     xml    = Nori.parse client.wsdl.xml
 
@@ -42,27 +42,31 @@ describe WashOut do
     # get back just what we have at controller
     client.wsdl.soap_actions.should == [:answer, :get_area]
 
+    x = xml[:definitions][:types][:schema][:complex_type].find{|x| x[:'@name'] == 'center'}[:sequence][:element].find{|x| x[:'@name'] == 'x'}
+    x[:'@xsi:min_occurs'].should == "0"
+    x[:'@xsi:max_occurs'].should == "unbounded"
+
     xml[:definitions][:binding][:operation].map{|e| e[:'@name']}.should == ['answer', 'getArea']
   end
 
   it "should allow definition of a simple action" do
     lambda {
       mock_controller do
-        soap_action "answer", :args => [], :return => :int
+        soap_action "answer", :args => nil, :return => :int
       end
     }.should_not raise_exception
   end
 
   it "should answer to request without parameters" do
     mock_controller do
-      soap_action "answer", :args => [], :return => :int
+      soap_action "answer", :args => nil, :return => :int
       def answer
         render :soap => "42"
       end
     end
 
     client = savon_instance
-    client.request(:answer).to_hash[:value].should == "42"
+    client.request(:answer).to_hash[:answer_response][:value].should == "42"
   end
 
   it "should answer to request with one parameter" do
@@ -76,10 +80,10 @@ describe WashOut do
     client = savon_instance
     client.request(:check_answer) do
       soap.body = { :value => 42 }
-    end.to_hash[:value].should == true
+    end.to_hash[:check_answer_response][:value].should == true
     client.request(:check_answer) do
       soap.body = { :value => 13 }
-    end.to_hash[:value].should == false
+    end.to_hash[:check_answer_response][:value].should == false
   end
 
   it "should answer to request with two parameter" do
@@ -93,7 +97,7 @@ describe WashOut do
     client = savon_instance
     client.request(:funky) do
       soap.body = { :a => 42, :b => 'k' }
-    end.to_hash[:value].should == '420k'
+    end.to_hash[:funky_response][:value].should == '420k'
   end
 
   it "should understand nested parameter specifications" do
@@ -115,25 +119,27 @@ describe WashOut do
     client.request(:get_area) do
       soap.body = { :circle => { :center => { :x => 3, :y => 4 },
                                  :radius => 5 } }
-    end.to_hash.should == ({ :area => (Math::PI * 25).to_s, :distance_from_o => (5.0).to_s })
+    end.to_hash[:get_area_response].should == ({ :area => (Math::PI * 25).to_s, :distance_from_o => (5.0).to_s })
   end
 
   it "should allow arbitrary action names" do
+    name = 'AnswerToTheUltimateQuestionOfLifeTheUniverseAndEverything'
+    
     mock_controller do
-      soap_action "AnswerToTheUltimateQuestionOfLifeTheUniverseAndEverything",
-                  :args => [], :return => :integer, :to => :answer
+      soap_action name,
+                  :args => nil, :return => :integer, :to => :answer
       def answer
         render :soap => "forty two"
       end
     end
 
     client = savon_instance
-    client.request('AnswerToTheUltimateQuestionOfLifeTheUniverseAndEverything').to_hash[:value].should == "forty two"
+    client.request(name).to_hash["#{name.underscore}_response".to_sym][:value].should == "forty two"
   end
 
   it "should correctly report SOAP errors" do
     mock_controller do
-      soap_action "error", :args => { :need_error => :boolean }, :return => []
+      soap_action "error", :args => { :need_error => :boolean }, :return => nil
       def error
         raise self.class.const_get(:SOAPError), "you wanted one" if params[:need_error]
 
@@ -165,7 +171,7 @@ describe WashOut do
 
   it "should be possible to explicitly render a SOAP error" do
     mock_controller do
-      soap_action "error", :args => [], :return => []
+      soap_action "error", :args => nil, :return => nil
       def error
         render_soap_error "a message"
       end
@@ -176,4 +182,81 @@ describe WashOut do
       client.request(:error)
     }.should raise_exception(Savon::SOAP::Fault)
   end
+  
+  it "should handle nested returns" do
+    mock_controller do
+      soap_action "gogogo",
+                  :args   => nil,
+                  :return => {
+                    :zoo => :string,
+                    :boo => {
+                      :moo => :string,
+                      :doo => :string
+                    }
+                  }
+      def gogogo
+        render :soap => {
+          :zoo => 'zoo',
+          :boo => {
+            :moo => 'moo',
+            :doo => 'doo'
+          }
+        }
+      end
+    end
+    
+    savon_instance.request(:gogogo)[:gogogo_response].should == {:zoo=>"zoo", :boo=>{:moo=>"moo", :doo=>"doo", :"@xsi:type"=>"tns:boo"}}
+  end
+  
+  it "should handle arrays" do
+    mock_controller do
+      soap_action "rumba",
+                  :args   => {
+                    :rumbas => [:integer]
+                  },
+                  :return => nil
+      def rumba
+        params.should == {"rumbas" => [1, 2, 3]}
+        render :soap => nil
+      end
+    end
+    
+    savon_instance.request(:rumba) do
+      soap.body = {
+        :rumbas => [1, 2, 3]
+      }
+    end
+  end
+  
+  it "should be able to return arrays" do
+    mock_controller do
+      soap_action "rumba",
+                  :args   => nil,
+                  :return => {
+                    :rumbas => [:integer]
+                  }
+      def rumba
+        render :soap => {:rumbas => [1, 2, 3]}
+      end
+    end
+    
+    savon_instance.request(:rumba).to_hash[:rumba_response].should == {:rumbas => ["1", "2", "3"]}
+  end
+  
+  it "should deprecate old syntax" do
+    # save rspec context check
+    raise_runtime_exception = raise_exception(RuntimeError)
+
+    mock_controller do
+      lambda {
+        soap_action "rumba",
+                    :args   => :integer,
+                    :return => []
+      }.should raise_runtime_exception
+      def rumba
+        render :soap => nil
+      end
+    end
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wash_out
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-21 00:00:00.000000000 Z
+date: 2012-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nori
-  requirement: &70359974011000 !ruby/object:Gem::Requirement
+  requirement: &70332337988240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70359974011000
+  version_requirements: *70332337988240
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &70359974009900 !ruby/object:Gem::Requirement
+  requirement: &70332337984940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70359974009900
+  version_requirements: *70332337984940
 - !ruby/object:Gem::Dependency
   name: appraisal
-  requirement: &70359974008240 !ruby/object:Gem::Requirement
+  requirement: &70332346016840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70359974008240
+  version_requirements: *70332346016840
 - !ruby/object:Gem::Dependency
   name: tzinfo
-  requirement: &70359974007200 !ruby/object:Gem::Requirement
+  requirement: &70332346016420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +55,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70359974007200
+  version_requirements: *70332346016420
 - !ruby/object:Gem::Dependency
   name: savon
-  requirement: &70359974006560 !ruby/object:Gem::Requirement
+  requirement: &70332346016000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,7 +66,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70359974006560
+  version_requirements: *70332346016000
 description: Dead simple Rails 3 SOAP server library
 email: boris@roundlake.ru
 executables: []