lib/wash_out/param.rb in wash_out-0.10.0.beta.1 vs lib/wash_out/param.rb in wash_out-0.10.0

@@ -5,40 +5,45 @@
     attr_accessor :map
     attr_accessor :type
     attr_accessor :multiplied
     attr_accessor :value
     attr_accessor :source_class
+    attr_accessor :soap_config
 
     # Defines a WSDL parameter with name +name+ and type specifier +type+.
     # The type specifier format is described in #parse_def.
     def initialize(soap_config, name, type, multiplied = false)
       type ||= {}
       @soap_config = soap_config
-      @name       = WashOut.normalize(name, soap_config)
+      @name       = name.to_s
       @raw_name   = name.to_s
       @map        = {}
       @multiplied = multiplied
 
+      if soap_config.camelize_wsdl.to_s == 'lower'
+        @name = @name.camelize(:lower)
+      elsif soap_config.camelize_wsdl
+        @name = @name.camelize
+      end
+
       if type.is_a?(Symbol)
         @type = type.to_s
       elsif type.is_a?(Class)
         @type         = 'struct'
         @map          = self.class.parse_def(soap_config, type.wash_out_param_map)
         @source_class = type
-      elsif type.is_a?(Hash)
+      else
         @type = 'struct'
         @map  = self.class.parse_def(soap_config, type)
-      else
-        raise RuntimeError, "Wrong definition: #{type.inspect}"
       end
     end
 
     # Converts a generic externally derived Ruby value, such as String or
     # Hash, to a native Ruby object according to the definition of this type.
     def load(data, key)
       if !data.has_key? key
-        raise WashOut::SOAPError, "Required SOAP parameter '#{key}' is missing"
+        raise WashOut::Dispatcher::SOAPError, "Required SOAP parameter '#{key}' is missing"
       end
 
       data = data[key]
       data = [data] if @multiplied && !data.is_a?(Array)
 
@@ -57,10 +62,11 @@
         end
       else
         operation = case type
           when 'string';       :to_s
           when 'integer';      :to_i
+          when 'long';         :to_i
           when 'double';       :to_f
           when 'boolean';      lambda{|dat| dat === "0" ? false : !!dat}
           when 'date';         :to_date
           when 'datetime';     :to_datetime
           when 'time';         :to_time
@@ -78,11 +84,11 @@
             data.send(operation)
           else
             operation.call(data)
           end
         rescue
-          raise WashOut::SOAPError, "Invalid SOAP parameter '#{key}' format"
+          raise WashOut::Dispatcher::SOAPError, "Invalid SOAP parameter '#{key}' format"
         end
       end
     end
 
     # Checks if this Param defines a complex type.
@@ -128,43 +134,64 @@
     # This function returns an array of WashOut::Param objects.
     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 = { :value => definition } unless definition.is_a?(Hash)
+      if definition.is_a?(Class) && definition.ancestors.include?(WashOut::Type)
+        definition = definition.wash_out_param_map
+      end
 
-      definition.map do |name, opt|
-        if opt.is_a? WashOut::Param
-          opt
-        elsif opt.is_a? Array
-          WashOut::Param.new(soap_config, name, opt[0], true)
-        else
-          WashOut::Param.new(soap_config, name, opt)
+      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(soap_config, name, opt[0], true)
+          else
+            WashOut::Param.new(soap_config, name, opt)
+          end
         end
+      else
+        raise RuntimeError, "Wrong definition: #{definition.inspect}"
       end
     end
 
     def flat_copy
       copy = self.class.new(@soap_config, @name, @type.to_sym, @multiplied)
       copy.raw_name = raw_name
+      copy.source_class = source_class
       copy
     end
 
+    def attribute?
+      name[0] == "@"
+    end
+
+    def attr_name
+      raise 'Not attribute' unless attribute?
+      name[1..-1]
+    end
+
     private
 
     # Used to load an entire structure.
     def map_struct(data)
       unless data.is_a?(Hash)
-        raise WashOut::SOAPError, "SOAP message structure is broken"
+        raise WashOut::Dispatcher::SOAPError, "SOAP message structure is broken"
       end
 
       data   = data.with_indifferent_access
       struct = {}.with_indifferent_access
 
       # RUBY18 Enumerable#each_with_object is better, but 1.9 only.
       @map.map do |param|
         if data.has_key? param.raw_name
-          struct[param.raw_name] = yield param, data, param.raw_name
+          param_name = param.attribute? ? param.attr_name : param.raw_name
+          struct[param_name] = yield param, data, param.raw_name
         end
       end
 
       struct
     end