nogara-wash_out 0.5.2

data/init.rb

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

data/lib/wash_out.rb

@@ -0,0 +1,35 @@
+require 'wash_out/engine'
+require 'wash_out/param'
+require 'wash_out/dispatcher'
+require 'wash_out/soap'
+require 'wash_out/router'
+require 'wash_out/type'
+require 'wash_out/model'
+require 'wash_out/wsse'
+
+module ActionDispatch::Routing
+  class Mapper
+    # Adds the routes for a SOAP endpoint at +controller+.
+    def wash_out(controller_name, options={})
+      options.reverse_merge!(@scope) if @scope
+      controller_class_name = [options[:module], controller_name].compact.join("/")
+
+      match "#{controller_name}/wsdl"   => "#{controller_name}#_generate_wsdl", :via => :get, :format => false
+      match "#{controller_name}/action" => WashOut::Router.new(controller_class_name), :defaults => { :controller => controller_class_name, :action => '_action' }, :format => false
+    end
+  end
+end
+
+Mime::Type.register "application/soap+xml", :soap
+ActiveRecord::Base.send :extend, WashOut::Model if defined?(ActiveRecord)
+
+ActionController::Renderers.add :soap do |what, options|
+  _render_soap(what, options)
+end
+
+module ActionView
+  class Base
+    cattr_accessor :washout_namespace
+    @@washout_namespace = false
+  end
+end

data/lib/wash_out/dispatcher.rb

@@ -0,0 +1,206 @@
+require 'nori'
+
+module WashOut
+  # The WashOut::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
+    # A SOAPError exception can be raised to return a correct SOAP error
+    # response.
+    class SOAPError < Exception; end
+    class ProgrammerError < Exception; end
+
+    # This filter parses the SOAP request and puts it into +params+ array.
+    def _parse_soap_parameters
+      # Do not interfere with project-space Nori setup
+      strip    = Nori.strip_namespaces?
+      convert  = Nori.convert_tags?
+      typecast = Nori.advanced_typecasting?
+
+      Nori.strip_namespaces = true
+      Nori.advanced_typecasting = false
+
+      if WashOut::Engine.snakecase_input
+        Nori.convert_tags_to { |tag| tag.snakecase.to_sym }
+      else
+        Nori.convert_tags_to { |tag| tag.to_sym }
+      end
+
+      request_body = request.body.read
+      @_params = Nori.parse(request_body)
+
+      references = WashOut::Dispatcher.deep_select(@_params){|k,v| v.is_a?(Hash) && v.has_key?(:@id)}
+
+      unless references.blank?
+        replaces = {}; references.each{|r| replaces['#'+r[:@id]] = r}
+        @_params = WashOut::Dispatcher.deep_replace_href(@_params, replaces)
+      end
+
+      # Reset Nori setup to project-space
+      Nori.strip_namespaces = strip
+      Nori.advanced_typecasting = typecast
+      Nori.convert_tags_to convert
+    end
+
+    def _authenticate_wsse
+      begin
+        xml_security   = @_params.values_at(:envelope, :Envelope).compact.first
+        xml_security   = xml_security.values_at(:header, :Header).compact.first
+        xml_security   = xml_security.values_at(:security, :Security).compact.first
+        username_token = xml_security.values_at(:username_token, :UsernameToken).compact.first
+      rescue
+        username_token = nil
+      end
+
+      WashOut::Wsse.authenticate username_token
+
+      request.env['WSSE_TOKEN'] = username_token.with_indifferent_access unless username_token.blank?
+    end
+
+    def _map_soap_parameters
+      soap_action = request.env['wash_out.soap_action']
+      action_spec = self.class.soap_actions[soap_action]
+
+      xml_data = @_params.values_at(:envelope, :Envelope).compact.first
+      xml_data = xml_data.values_at(:body, :Body).compact.first
+      xml_data = xml_data.values_at(soap_action.underscore.to_sym,
+                                    soap_action.to_sym).compact.first || {}
+
+      strip_empty_nodes = lambda{|hash|
+        hash.each do |key, value|
+          if value.is_a? Hash
+            value = value.delete_if{|key, value| key.to_s[0] == '@'}
+
+            if value.length > 0
+              hash[key] = strip_empty_nodes.call(value)
+            else
+              hash[key] = nil
+            end
+          end
+        end
+
+        hash
+      }
+      xml_data = strip_empty_nodes.call(xml_data)
+      @_params = HashWithIndifferentAccess.new
+
+      action_spec[:in].each do |param|
+        key = param.raw_name.to_sym
+
+        if xml_data.has_key? key
+          @_params[param.raw_name] = param.load(xml_data, key)
+        end
+      end
+    end
+
+    # This action generates the WSDL for defined SOAP methods.
+    def _generate_wsdl
+      @map       = self.class.soap_actions
+      @namespace = WashOut::Engine.namespace
+      @name      = controller_path.gsub('/', '_')
+
+      render :template => 'wash_with_soap/wsdl', :layout => false
+    end
+
+    # Render a SOAP response.
+    def _render_soap(result, options)
+      @namespace  = WashOut::Engine.namespace
+      @operation  = soap_action = request.env['wash_out.soap_action']
+      action_spec = self.class.soap_actions[soap_action][:out]
+
+      result = { 'value' => result } unless result.is_a? Hash
+      result = HashWithIndifferentAccess.new(result)
+
+      inject = lambda {|data, map|
+        result_spec = []
+
+        map.each_with_index do |param, i|
+          result_spec[i] = param.flat_copy
+
+          # Inline complex structure
+          if param.struct? && !param.multiplied
+            result_spec[i].map = inject.call(data[param.raw_name], param.map)
+
+          # Inline array of complex structures
+          elsif param.struct? && param.multiplied
+            if data.nil?
+              data = {} # when no data is given
+            elsif data.is_a?(Array)
+              raise ProgrammerError,
+                "SOAP response used #{data.inspect} (which is an Array), " +
+                "in the context where a Hash with key of '#{param.raw_name}' " +
+                "was expected."
+            end
+            data[param.raw_name] = [] unless data[param.raw_name].is_a?(Array)
+            result_spec[i].map = data[param.raw_name].map{|e| inject.call(e, param.map)}
+
+          else
+            val = data[param.raw_name]
+            if param.multiplied and val and not val.is_a?(Array)
+              raise ProgrammerError,
+                "SOAP response tried to use '#{val.inspect}' " +
+                "(which is of type #{val.class}), as the value for " +
+                "'#{param.raw_name}' (which expects an Array)."
+            end
+            result_spec[i].value = val
+          end
+        end
+
+        return result_spec
+      }
+
+      render :template => 'wash_with_soap/response',
+             :layout => false,
+             :locals => { :result => inject.call(result, action_spec) },
+             :content_type => 'text/xml'
+    end
+
+    # This action is a fallback for all undefined SOAP actions.
+    def _invalid_action
+      render_soap_error("Cannot find SOAP action mapping for #{request.env['wash_out.soap_action']}")
+    end
+
+    def _render_soap_exception(error)
+      render_soap_error(error.message)
+    end
+
+    # Render a SOAP error response.
+    #
+    # Rails do not support sequental rescue_from handling, that is, rescuing an
+    # exception from a rescue_from handler. Hence this function is a public API.
+    def render_soap_error(message)
+      render :template => 'wash_with_soap/error', :status => 500,
+             :layout => false,
+             :locals => { :error_message => message },
+             :content_type => 'text/xml'
+    end
+
+    def self.included(controller)
+      controller.send :rescue_from, SOAPError, :with => :_render_soap_exception
+      controller.send :helper, :wash_out
+      controller.send :before_filter, :_parse_soap_parameters, :except => [ :_generate_wsdl, :_invalid_action ]
+      controller.send :before_filter, :_authenticate_wsse,     :except => [ :_generate_wsdl, :_invalid_action ]
+      controller.send :before_filter, :_map_soap_parameters,   :except => [ :_generate_wsdl, :_invalid_action ]
+    end
+
+    def self.deep_select(hash, result=[], &blk)
+      result += Hash[hash.select(&blk)].values
+
+      hash.each do |key, value|
+        result = deep_select(value, result, &blk) if value.is_a? Hash
+      end
+
+      result
+    end
+
+    def self.deep_replace_href(hash, replace)
+      return replace[hash[:@href]] if hash.has_key?(:@href)
+
+      hash.keys.each do |key, value|
+        hash[key] = deep_replace_href(hash[key], replace) if hash[key].is_a?(Hash)
+      end
+
+      hash
+    end
+  end
+end

data/lib/wash_out/engine.rb

@@ -0,0 +1,30 @@
+module WashOut
+  class Engine < ::Rails::Engine
+    class << self
+      attr_accessor :namespace
+      attr_accessor :snakecase, :snakecase_input, :camelize_wsdl
+      attr_accessor :wsse_username, :wsse_password
+    end
+
+    self.namespace = 'urn:WashOut'
+    self.snakecase = nil
+
+    self.snakecase_input = false
+    self.camelize_wsdl   = false
+
+    self.wsse_username = nil
+    self.wsse_password = nil
+
+    config.wash_out = ActiveSupport::OrderedOptions.new
+
+    initializer "wash_out.configuration" do |app|
+      app.config.wash_out.each do |key, value|
+        self.class.send "#{key}=", value
+      end
+
+      unless self.class.snakecase.nil?
+        raise "Usage of wash_out.snakecase is deprecated. You should use wash_out.snakecase_input and wash_out.camelize_wsdl"
+      end
+    end
+  end
+end

data/lib/wash_out/model.rb

@@ -0,0 +1,25 @@
+module WashOut
+  module Model
+    def wash_out_param_map
+      types = {
+        :text      => :string,
+        :float     => :double,
+        :decimal   => :double,
+        :timestamp => :string
+      }
+      map = {}
+
+      columns_hash.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
+      return name.underscore
+    end
+  end
+end

data/lib/wash_out/param.rb

@@ -0,0 +1,176 @@
+module WashOut
+  class Param
+    attr_accessor :raw_name
+    attr_accessor :name
+    attr_accessor :map
+    attr_accessor :type
+    attr_accessor :multiplied
+    attr_accessor :value
+    attr_accessor :source_class
+
+    # Defines a WSDL parameter with name +name+ and type specifier +type+.
+    # The type specifier format is described in #parse_def.
+    def initialize(name, type, multiplied = false)
+      type ||= {}
+
+      @name       = name.to_s
+      @raw_name   = name.to_s
+      @map        = {}
+      @multiplied = multiplied
+
+      if WashOut::Engine.camelize_wsdl.to_s == 'lower'
+        @name = @name.camelize(:lower)
+      elsif WashOut::Engine.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(type.wash_out_param_map)
+        @source_class = type
+      else
+        @type = 'struct'
+        @map  = self.class.parse_def(type)
+      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::Dispatcher::SOAPError, "Required SOAP parameter '#{key}' is missing"
+      end
+
+      data = data[key]
+      data = [data] if @multiplied && !data.is_a?(Array)
+
+      if struct?
+        if @multiplied
+          data.map do |x|
+            map_struct x do |param, data, elem|
+              param.load(data, elem)
+            end
+          end
+        else
+          map_struct data do |param, data, elem|
+            param.load(data, elem)
+          end
+        end
+      else
+        operation = case type
+          when 'string';    :to_s
+          when 'integer';   :to_i
+          when 'double';    :to_f
+          when 'boolean';   lambda { |v| v == 'true' }
+          when 'date';      :to_date
+          when 'datetime';  :to_datetime
+          when 'time';      :to_time
+          else raise RuntimeError, "Invalid WashOut simple type: #{type}"
+        end
+
+        if operation.nil? || data.nil?
+          data
+        elsif @multiplied
+          data.map{|x| x.send(operation)}
+        elsif operation.is_a? Symbol
+          data.send(operation)
+        else
+          operation.call(data)
+        end
+      end
+    end
+
+    # Checks if this Param defines a complex type.
+    def struct?
+      type == 'struct'
+    end
+
+    def classified?
+      !source_class.nil?
+    end
+
+    def basic_type
+      return name unless classified?
+      return source_class.wash_out_param_name
+    end
+
+    def xsd_type
+      return 'int' if type.to_s == 'integer'
+      return 'dateTime' if type.to_s == 'datetime'
+      return type
+    end
+
+    # Returns a WSDL namespaced identifier for this type.
+    def namespaced_type
+      struct? ? "tns:#{basic_type}" : "xsd:#{xsd_type}"
+    end
+
+    # Parses a +definition+. The format of the definition is best described
+    # by the following BNF-like grammar.
+    #
+    #   simple_type := :string | :integer | :double | :boolean
+    #   nested_type := type_hash | simple_type | WashOut::Param instance
+    #   type_hash   := { :parameter_name => nested_type, ... }
+    #   definition  := [ WashOut::Param, ... ] |
+    #                  type_hash |
+    #                  simple_type
+    #
+    # If a simple type is passed as the +definition+, a single Param is returned
+    # with the +name+ set to "value".
+    # If a WashOut::Param instance is passed as a +nested_type+, the corresponding
+    # +:parameter_name+ is ignored.
+    #
+    # This function returns an array of WashOut::Param objects.
+    def self.parse_def(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
+
+      if [Array, Symbol, Class].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
+        raise RuntimeError, "Wrong definition: #{definition.inspect}"
+      end
+    end
+
+    def flat_copy
+      copy = self.class.new(@name, @type.to_sym, @multiplied)
+      copy.raw_name = raw_name
+      copy
+    end
+
+    private
+
+    # Used to load an entire structure.
+    def map_struct(data)
+      unless data.is_a?(Hash)
+        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
+        end
+      end
+
+      struct
+    end
+  end
+end