wash_out 0.10.0.beta.1 → 0.10.0

data/lib/wash_out/model.rb

@@ -0,0 +1,29 @@
+module WashOut
+  module Model
+    def wash_out_columns
+      columns_hash
+    end
+
+    def wash_out_param_map
+      types = {
+        :text      => :string,
+        :float     => :double,
+        :decimal   => :double,
+        :timestamp => :string
+      }
+      map = {}
+
+      wash_out_columns.each do |key, column|
+        type = column.type
+        type = types[type] if types.has_key?(type)
+        map[key] = type
+      end
+
+      map
+    end
+
+    def wash_out_param_name(*args)
+      return name.underscore
+    end
+  end
+end

data/lib/wash_out/param.rb

@@ -7,28 +7,33 @@ module WashOut
     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
 
@@ -36,7 +41,7 @@ module WashOut
     # 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]
@@ -59,6 +64,7 @@ module WashOut
         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
@@ -80,7 +86,7 @@ module WashOut
             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
@@ -130,31 +136,51 @@ module WashOut
       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
@@ -163,7 +189,8 @@ module WashOut
       # 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
 

data/lib/wash_out/router.rb

@@ -0,0 +1,95 @@
+require 'nori'
+
+module WashOut
+  # This class is a Rack middleware used to route SOAP requests to a proper
+  # action of a given SOAP controller.
+  class Router
+    def initialize(controller_name)
+      @controller_name = "#{controller_name.to_s}_controller".camelize
+    end
+
+    def controller
+      @controller
+    end
+
+    def parse_soap_action(env)
+      return env['wash_out.soap_action'] if env['wash_out.soap_action']
+
+      soap_action = controller.soap_config.soap_action_routing ? env['HTTP_SOAPACTION'].to_s.gsub(/^"(.*)"$/, '\1')
+                                                               : ''
+
+      if soap_action.blank?
+        parsed_soap_body = nori(controller.soap_config.snakecase_input).parse(soap_body env)
+        return nil if parsed_soap_body.blank?
+
+        soap_action = parsed_soap_body
+            .values_at(:envelope, :Envelope).compact.first
+            .values_at(:body, :Body).compact.first
+            .keys.first.to_s
+      end
+
+      # RUBY18 1.8 does not have force_encoding.
+      soap_action.force_encoding('UTF-8') if soap_action.respond_to? :force_encoding
+
+      if controller.soap_config.namespace
+        namespace = Regexp.escape controller.soap_config.namespace.to_s
+        soap_action.gsub!(/^(#{namespace}(\/|#)?)?([^"]*)$/, '\3')
+      end
+
+      env['wash_out.soap_action'] = soap_action
+    end
+
+    def nori(snakecase=false)
+      Nori.new(
+        :parser => controller.soap_config.parser,
+        :strip_namespaces => true,
+        :advanced_typecasting => true,
+        :convert_tags_to => (
+          snakecase ? lambda { |tag| tag.snakecase.to_sym }
+                    : lambda { |tag| tag.to_sym }
+        )
+      )
+    end
+
+    def soap_body(env)
+      body = env['rack.input']
+      body.rewind if body.respond_to? :rewind
+      body.respond_to?(:string) ? body.string : body.read
+    ensure
+      body.rewind if body.respond_to? :rewind
+    end
+
+    def parse_soap_parameters(env)
+      return env['wash_out.soap_data'] if env['wash_out.soap_data']
+
+      env['wash_out.soap_data'] = nori(controller.soap_config.snakecase_input).parse(soap_body env)
+      references = WashOut::Dispatcher.deep_select(env['wash_out.soap_data']){|k,v| v.is_a?(Hash) && v.has_key?(:@id)}
+
+      unless references.blank?
+        replaces = {}; references.each{|r| replaces['#'+r[:@id]] = r}
+        env['wash_out.soap_data'] = WashOut::Dispatcher.deep_replace_href(env['wash_out.soap_data'], replaces)
+      end
+
+      env['wash_out.soap_data']
+    end
+
+    def call(env)
+      @controller = @controller_name.constantize
+
+      soap_action     = parse_soap_action(env)
+      return [200, {}, ['OK']] if soap_action.blank?
+
+      soap_parameters = parse_soap_parameters(env)
+
+      action_spec = controller.soap_actions[soap_action]
+
+      if action_spec
+        action = action_spec[:to]
+      else
+        action = '_invalid_action'
+      end
+
+      controller.action(action).call(env)
+    end
+  end
+end

data/lib/wash_out/soap.rb

@@ -0,0 +1,48 @@
+require 'active_support/concern'
+
+module WashOut
+  module SOAP
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_accessor :soap_actions
+
+      # 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={})
+        if action.is_a?(Symbol)
+          if soap_config.camelize_wsdl.to_s == 'lower'
+            options[:to] ||= action.to_s
+            action         = action.to_s.camelize(:lower)
+          elsif soap_config.camelize_wsdl
+            options[:to] ||= action.to_s
+            action         = action.to_s.camelize
+          end
+
+        end
+
+        default_response_tag = soap_config.camelize_wsdl ? 'Response' : '_response'
+        default_response_tag = action+default_response_tag
+
+        self.soap_actions[action] = options.merge(
+          :in           => WashOut::Param.parse_def(soap_config, options[:args]),
+          :request_tag  => options[:as] || action,
+          :out          => WashOut::Param.parse_def(soap_config, options[:return]),
+          :to           => options[:to] || action,
+          :response_tag => options[:response_tag] || default_response_tag
+        )
+      end
+    end
+
+    included do
+      include WashOut::Configurable
+      include WashOut::Dispatcher
+      include WashOut::WsseParams
+      self.soap_actions = {}
+    end
+  end
+end

data/lib/wash_out/soap_config.rb

@@ -0,0 +1,93 @@
+module WashOut
+  require 'forwardable'
+  # Configuration options for {Client}, defaulting to values
+  # in {Default}
+  class SoapConfig
+    extend Forwardable
+    DEFAULT_CONFIG = {
+      parser: :rexml,
+      namespace: 'urn:WashOut',
+      wsdl_style: 'rpc',
+      snakecase_input: false,
+      camelize_wsdl: false,
+      catch_xml_errors: false,
+      wsse_username: nil,
+      wsse_password: nil,
+      wsse_auth_callback: nil,
+      soap_action_routing: true,
+    }
+
+    attr_reader :config
+    def_delegators :@config, :[], :[]=, :sort
+
+
+    # The keys allowed
+    def self.keys
+      @keys ||= config.keys
+    end
+
+    def self.config
+      DEFAULT_CONFIG
+    end
+
+    def self.soap_accessor(*syms)
+      syms.each do |sym|
+
+        unless sym =~ /^[_A-Za-z]\w*$/
+          raise NameError.new("invalid class attribute name: #{sym}")
+        end
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          unless defined? @#{sym}
+            @#{sym} = nil
+          end
+
+          def #{sym}
+            @#{sym}
+          end
+
+          def #{sym}=(obj)
+            @#{sym} = obj
+          end
+        EOS
+      end
+    end
+
+    soap_accessor(*WashOut::SoapConfig.keys)
+
+    def initialize(options = {})
+      @config = {}
+      options.reverse_merge!(engine_config) if engine_config
+      options.reverse_merge!(DEFAULT_CONFIG)
+      configure options
+    end
+
+    def default?
+      DEFAULT_CONFIG.sort == config.sort
+    end
+
+    def configure(options = {})
+      @config.merge! validate_config!(options)
+
+      config.each do |key,value|
+        send("#{key}=", value)
+      end
+    end
+
+    private
+
+      def engine_config
+        @engine_config ||= WashOut::Engine.config.wash_out
+      end
+
+      def validate_config!(options = {})
+        rejected_keys = options.keys.reject do |key|
+          WashOut::SoapConfig.keys.include?(key)
+        end
+
+        if rejected_keys.any?
+          raise "The following keys are not allows: #{rejected_keys}\n Did you intend for one of the following? #{WashOut::SoapConfig.keys}"
+        end
+        options
+      end
+  end
+end

data/lib/wash_out/type.rb

@@ -1,22 +1,29 @@
 module WashOut
   class Type
-    class <<self
-      def type_name(value)
-        @param_type_name = value.to_s
-      end
 
-      def map(value)
-        raise RuntimeError, "Wrong definition: #{value.inspect}" unless value.is_a?(Hash)
-        @param_map = value
-      end
+    def self.type_name(value)
+      @param_type_name = value.to_s
+    end
 
-      def wash_out_param_map
-        @param_map
-      end
+    def self.map(value)
+      raise RuntimeError, "Wrong definition: #{value.inspect}" unless value.is_a?(Hash)
+      @param_map = value
+    end
+
+    def self.wash_out_param_map
+      @param_map
+    end
+
+    def self.wash_out_param_name(soap_config = nil)
+      soap_config ||= WashOut::SoapConfig.new({})
+      @param_type_name ||= name.underscore.gsub '/', '.'
 
-      def wash_out_param_name(soap_config = nil)
-        WashOut.normalize(@param_type_name || name.underscore.gsub('/', '.'), soap_config)
+      if soap_config.camelize_wsdl.to_s == 'lower'
+        @param_type_name = @param_type_name.camelize(:lower)
+      elsif soap_config.camelize_wsdl
+        @param_type_name = @param_type_name.camelize
       end
+      @param_type_name
     end
   end
 end

data/lib/wash_out/version.rb

@@ -1,3 +1,3 @@
 module WashOut
-  VERSION = "0.10.0.beta.1"
+  VERSION = "0.10.0"
 end