wash_out 0.10.0.beta.1 → 0.10.0

data/gemfiles/rails_3.2.12.gemfile

@@ -0,0 +1,20 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "wasabi"
+gem "savon", ">= 2.0.0"
+gem "httpi"
+gem "rspec-rails"
+gem "guard"
+gem "guard-rspec"
+gem "rb-fsevent"
+gem "appraisal"
+gem "tzinfo"
+gem "pry"
+gem "simplecov"
+gem "simplecov-summary"
+gem "rails", "3.2.12"
+gem "test-unit"
+
+gemspec :path => "../"

data/gemfiles/rails_4.0.0.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "wasabi"
+gem "savon", ">= 2.0.0"
+gem "httpi"
+gem "rspec-rails"
+gem "guard"
+gem "guard-rspec"
+gem "rb-fsevent"
+gem "appraisal"
+gem "tzinfo"
+gem "pry"
+gem "simplecov"
+gem "simplecov-summary"
+gem "rails", "4.0.0"
+
+gemspec :path => "../"

data/gemfiles/rails_4.1.0.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "wasabi"
+gem "savon", ">= 2.0.0"
+gem "httpi"
+gem "rspec-rails"
+gem "guard"
+gem "guard-rspec"
+gem "rb-fsevent"
+gem "appraisal"
+gem "tzinfo"
+gem "pry"
+gem "simplecov"
+gem "simplecov-summary"
+gem "rails", "4.1.0"
+
+gemspec :path => "../"

data/gemfiles/rails_4.2.0.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "wasabi"
+gem "savon", ">= 2.0.0"
+gem "httpi"
+gem "rspec-rails"
+gem "guard"
+gem "guard-rspec"
+gem "rb-fsevent"
+gem "appraisal"
+gem "tzinfo"
+gem "pry"
+gem "simplecov"
+gem "simplecov-summary"
+gem "rails", "4.2.0"
+
+gemspec :path => "../"

data/lib/wash_out.rb

@@ -1,21 +1,53 @@
-require 'wash_out/exceptions/programmer_error'
-require 'wash_out/exceptions/soap_error'
+require 'wash_out/configurable'
+require 'wash_out/soap_config'
+require 'wash_out/soap'
+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'
+require 'wash_out/middleware'
 
-require 'wash_out/middlewares/router'
-require 'wash_out/middlewares/catcher'
+module WashOut
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+end
 
-require 'wash_out/wsse'
-require 'wash_out/type'
-require 'wash_out/param'
+module ActionDispatch::Routing
+  class Mapper
+    # Adds the routes for a SOAP endpoint at +controller+.
+    def wash_out(controller_name, options={})
+      options.each_with_index { |key, value|  @scope[key] = value } if @scope
+      controller_class_name = [options[:module], controller_name].compact.join("/")
 
-require 'wash_out/rails/active_record'
-require 'wash_out/rails/controller'
-require 'wash_out/rails/engine'
+      match "#{controller_name}/wsdl"   => "#{controller_name}#_generate_wsdl", :via => :get, :format => false
+      match "#{controller_name}/action" => WashOut::Router.new(controller_class_name), :via => [:get, :post], :defaults => { :controller => controller_class_name, :action => '_action' }, :format => false
+    end
+  end
+end
 
-module WashOut
-  def self.normalize(string, config)
-    return string.to_s if !config || !config.camelize_wsdl
-    return string.to_s.camelize(:lower) if config.camelize_wsdl == 'lower'
-    return string.to_s.camelize
+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
+
+ActionController::Base.class_eval do
+
+  # Define a SOAP service. The function has no required +options+:
+  # but allow any of :parser, :namespace, :wsdl_style, :snakecase_input,
+  # :camelize_wsdl, :wsse_username, :wsse_password and :catch_xml_errors.
+  #
+  # Any of the the params provided allows for overriding the defaults
+  # (like supporting multiple namespaces instead of application wide such)
+  #
+  def self.soap_service(options={})
+    include WashOut::SOAP
+    self.soap_config = options
   end
-end
+end

data/lib/wash_out/configurable.rb

@@ -0,0 +1,41 @@
+module WashOut
+  module Configurable
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_reader :soap_config
+      class_variable_set :@@soap_config, WashOut::SoapConfig.new({})
+    end
+
+    module ClassMethods
+
+      def soap_config=(obj)
+
+        unless obj.is_a?(Hash)
+          raise "Value needs to be a Hash."
+        end
+
+        if class_variable_defined?(:@@soap_config)
+          class_variable_get(:@@soap_config).configure obj
+        else
+          class_variable_set :@@soap_config, WashOut::SoapConfig.new(obj)
+        end
+      end
+    end
+
+    def soap_config=(obj)
+
+      unless obj.is_a?(Hash)
+        raise "Value needs to be a Hash."
+      end
+
+      class_eval do
+        if class_variable_defined?(:@@soap_config)
+          class_variable_get(:@@soap_config).configure obj
+        else
+          class_variable_set :@@soap_config, WashOut::SoapConfig.new(obj)
+        end
+      end
+    end
+  end
+end

data/lib/wash_out/dispatcher.rb

@@ -0,0 +1,212 @@
+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
+      attr_accessor :code
+      def initialize(message, code=nil)
+        super(message)
+        @code = code
+      end
+    end
+
+    class ProgrammerError < Exception; end
+
+    def _authenticate_wsse
+
+      begin
+        xml_security   = env['wash_out.soap_data'].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 soap_config, username_token
+
+      request.env['WSSE_TOKEN'] = username_token.with_indifferent_access unless username_token.blank?
+    end
+
+    def _map_soap_parameters
+      @_params = _load_params action_spec[:in],
+        _strip_empty_nodes(action_spec[:in], xml_data)
+    end
+
+    def _strip_empty_nodes(params, hash)
+      hash.keys.each do |key|
+        param = params.detect { |a| a.raw_name.to_s == key.to_s }
+        next if !(param && hash[key].is_a?(Hash))
+
+        value = hash[key].delete_if do |k, _|
+          k.to_s[0] == '@' && !param.map.detect { |a| a.raw_name.to_s == k.to_s }
+        end
+
+        if value.length > 0
+          hash[key] = _strip_empty_nodes param.map, value
+        else
+          hash[key] = nil
+        end
+      end
+
+      hash
+    end
+
+    # Creates the final parameter hash based on the request spec and xml_data from the request
+    def _load_params(spec, xml_data)
+      params = HashWithIndifferentAccess.new
+      spec.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
+      params
+    end
+
+    # This action generates the WSDL for defined SOAP methods.
+    def _generate_wsdl
+
+      @map       = self.class.soap_actions
+      @namespace = soap_config.namespace
+      @name      = controller_path.gsub('/', '_')
+
+      render :template => "wash_out/#{soap_config.wsdl_style}/wsdl", :layout => false,
+             :content_type => 'text/xml'
+    end
+
+    # Render a SOAP response.
+    def _render_soap(result, options)
+      @namespace   = soap_config.namespace
+      @operation   = soap_action = request.env['wash_out.soap_action']
+      @action_spec = self.class.soap_actions[soap_action]
+
+      result = { 'value' => result } unless result.is_a? Hash
+      result = HashWithIndifferentAccess.new(result)
+
+      inject = lambda {|data, map|
+        result_spec = []
+        return result_spec if data.nil?
+
+        map.each_with_index do |param, i|
+          result_spec[i] = param.flat_copy
+
+          unless data.is_a?(Hash)
+            raise ProgrammerError,
+              "SOAP response used #{data.inspect} (which is #{data.class.name}), " +
+              "in the context where a Hash with key of '#{param.raw_name}' " +
+              "was expected."
+          end
+
+          value = data[param.raw_name]
+
+          unless value.nil?
+            if param.multiplied && !value.is_a?(Array)
+              raise ProgrammerError,
+                "SOAP response tried to use '#{value.inspect}' " +
+                "(which is of type #{value.class.name}), as the value for " +
+                "'#{param.raw_name}' (which expects an Array)."
+            end
+
+            # Inline complex structure              {:foo => {bar: ...}}
+            if param.struct? && !param.multiplied
+              result_spec[i].map = inject.call(value, param.map)
+
+            # Inline array of complex structures    {:foo => [{bar: ...}]}
+            elsif param.struct? && param.multiplied
+              result_spec[i].map = value.map{|e| inject.call(e, param.map)}
+
+            # Inline scalar                         {:foo => :string}
+            else
+              result_spec[i].value = value
+            end
+          end
+        end
+
+        return result_spec
+      }
+
+      render :template => "wash_out/#{soap_config.wsdl_style}/response",
+             :layout => false,
+             :locals => { :result => inject.call(result, @action_spec[:out]) },
+             :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 _catch_soap_errors
+      yield
+    rescue SOAPError => error
+      render_soap_error(error.message, error.code)
+    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, code=nil)
+      render :template => "wash_out/#{soap_config.wsdl_style}/error", :status => 500,
+             :layout => false,
+             :locals => { :error_message => message, :error_code => (code || 'Server') },
+             :content_type => 'text/xml'
+    end
+
+    def self.included(controller)
+      controller.send :around_filter, :_catch_soap_errors
+      controller.send :helper, :wash_out
+      controller.send :before_filter, :_authenticate_wsse,     :except => [
+        :_generate_wsdl, :_invalid_action ]
+      controller.send :before_filter, :_map_soap_parameters,   :except => [
+        :_generate_wsdl, :_invalid_action ]
+      controller.send :skip_before_filter, :verify_authenticity_token
+    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
+
+    private
+
+    def action_spec
+      self.class.soap_actions[soap_action]
+    end
+
+    def request_input_tag
+      action_spec[:request_tag]
+    end
+
+    def soap_action
+      request.env['wash_out.soap_action']
+    end
+
+    def xml_data
+      xml_data = env['wash_out.soap_data'].values_at(:envelope, :Envelope).compact.first
+      xml_data = xml_data.values_at(:body, :Body).compact.first || {}
+      return xml_data if soap_config.wsdl_style == "document"
+      xml_data = xml_data.values_at(soap_action.underscore.to_sym, soap_action.to_sym, request_input_tag.to_sym).compact.first || {}
+    end
+
+  end
+end

data/lib/wash_out/engine.rb

@@ -0,0 +1,12 @@
+
+module WashOut
+  class Engine < ::Rails::Engine
+    config.wash_out = ActiveSupport::OrderedOptions.new
+    initializer "wash_out.configuration" do |app|
+      if app.config.wash_out[:catch_xml_errors]
+        app.config.middleware.insert_after 'ActionDispatch::ShowExceptions', WashOut::Middleware
+      end
+    end
+
+  end
+end

data/lib/wash_out/middleware.rb

@@ -0,0 +1,41 @@
+class WashOut::Middleware
+  def initialize app
+    @app = app
+  end
+
+  def call env
+    begin
+      @app.call env
+    rescue REXML::ParseException => e
+      self.class.raise_or_render_rexml_parse_error e, env
+    end
+  end
+
+  def self.raise_or_render_rexml_parse_error e, env
+    raise e unless env.has_key? 'HTTP_SOAPACTION'
+  
+    # Normally input would be a StringIO, but Passenger has a different API:
+    input = env['rack.input']
+    req = if input.respond_to? :string then input.string else input.read end
+
+    env['rack.errors'].puts <<-EOERR
+WashOut::Exception: #{e.continued_exception} for:
+#{req}
+    EOERR
+    [400, {'Content-Type' => 'text/xml'},
+      [render_client_soap_fault("Error parsing SOAP Request XML")]]
+  end
+
+  def self.render_client_soap_fault msg
+    xml = Builder::XmlMarkup.new
+    xml.tag! 'soap:Envelope', 'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/',
+      'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance' do
+        xml.tag! 'soap:Body' do
+          xml.tag! 'soap:Fault', :encodingStyle => 'http://schemas.xmlsoap.org/soap/encoding/' do
+            xml.faultcode 'Client'
+            xml.faultstring msg
+          end
+        end
+      end
+  end
+end