wash_out_fork 0.0.1

data/init.rb

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

data/lib/wash_out_fork.rb

@@ -0,0 +1,60 @@
+require 'wash_out_fork/configurable'
+require 'wash_out_fork/soap_config'
+require 'wash_out_fork/soap'
+require 'wash_out_fork/engine'
+require 'wash_out_fork/param'
+require 'wash_out_fork/dispatcher'
+require 'wash_out_fork/soap'
+require 'wash_out_fork/router'
+require 'wash_out_fork/type'
+require 'wash_out_fork/model'
+require 'wash_out_fork/wsse'
+require 'wash_out_fork/middleware'
+
+module WashOutFork
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+end
+
+module ActionDispatch::Routing
+  class Mapper
+    # Adds the routes for a SOAP endpoint at +controller+.
+    def wash_out_fork(controller_name, options={})
+      if @scope
+        scope_frame = @scope.respond_to?(:frame) ? @scope.frame : @scope
+        options.each{ |key, value|  scope_frame[key] = value }
+      end
+
+      controller_class_name = [scope_frame[:module], controller_name].compact.join("/").underscore
+
+      match "#{controller_name}/wsdl"   => "#{controller_name}#_generate_wsdl", :via => :get, :format => false,
+        :as => "#{controller_class_name}_wsdl"
+      match "#{controller_name}/action" => WashOutFork::Router.new(controller_class_name), :via => [:get, :post],
+        :defaults => { :controller => controller_class_name, :action => 'soap' }, :format => false,
+        :as => "#{controller_class_name}_soap"
+    end
+  end
+end
+
+Mime::Type.register "application/soap+xml", :soap
+ActiveRecord::Base.send :extend, WashOutFork::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 WashOutFork::SOAP
+    self.soap_config = options
+  end
+end

data/lib/wash_out_fork/configurable.rb

@@ -0,0 +1,41 @@
+module WashOutFork
+  module Configurable
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_reader :soap_config
+      class_variable_set :@@soap_config, WashOutFork::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, WashOutFork::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, WashOutFork::SoapConfig.new(obj)
+        end
+      end
+    end
+  end
+end

data/lib/wash_out_fork/dispatcher.rb

@@ -0,0 +1,232 @@
+module WashOutFork
+  # The WashOutFork::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   = request.env['wash_out_fork.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
+
+      WashOutFork::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
+
+      render :template => "wash_out_fork/#{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_fork.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_fork/#{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_fork.soap_action']}")
+    end
+
+    def _invalid_request
+      render_soap_error("Invalid SOAP request")
+    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_fork/#{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)
+      entity = if defined?(Rails::VERSION::MAJOR) && (Rails::VERSION::MAJOR >= 4)
+        'action'
+      else
+        'filter' 
+      end
+
+      controller.send :"around_#{entity}", :_catch_soap_errors
+      controller.send :helper, :wash_out_fork
+      controller.send :"before_#{entity}", :_authenticate_wsse,   :if => :soap_action?
+      controller.send :"before_#{entity}", :_map_soap_parameters, :if => :soap_action?
+      controller.send :"skip_before_#{entity}", :verify_authenticity_token
+    end
+
+    def self.deep_select(collection, result=[], &blk)
+      values = collection.respond_to?(:values) ? collection.values : collection
+      result += values.select(&blk)
+
+      values.each do |value|
+        if value.is_a?(Hash) || value.is_a?(Array)
+          result = deep_select(value, result, &blk)
+        end
+      end
+
+      result
+    end
+
+    def self.deep_replace_href(element, replace)
+      return element unless element.is_a?(Array) || element.is_a?(Hash)
+
+      if element.is_a?(Array) # Traverse arrays
+        return element.map{|x| deep_replace_href(x, replace)}
+      end
+
+      if element.has_key?(:@href) # Replace needle and traverse replacement
+        return deep_replace_href(replace[element[:@href]], replace)
+      end
+
+      element.each do |key, value| # Traverse hashes
+        element[key] = deep_replace_href(value, replace)
+      end
+
+      element
+    end
+
+    private
+    def soap_action?
+      soap_action.present?
+    end
+
+    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_fork.soap_action']
+    end
+
+    def xml_data
+      xml_data = request.env['wash_out_fork.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_fork/engine.rb

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

data/lib/wash_out_fork/middleware.rb

@@ -0,0 +1,41 @@
+class WashOutFork::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
+WashOutFork::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

data/lib/wash_out_fork/model.rb

@@ -0,0 +1,29 @@
+module WashOutFork
+  module Model
+    def wash_out_fork_columns
+      columns_hash
+    end
+
+    def wash_out_fork_param_map
+      types = {
+        :text      => :string,
+        :float     => :double,
+        :decimal   => :double,
+        :timestamp => :string
+      }
+      map = {}
+
+      wash_out_fork_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_fork_param_name(*args)
+      return name.underscore
+    end
+  end
+end

data/lib/wash_out_fork/param.rb

@@ -0,0 +1,200 @@
+module WashOutFork
+  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
+    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       = 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_fork_param_map)
+        @source_class = type
+      else
+        @type = 'struct'
+        @map  = self.class.parse_def(soap_config, 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 WashOutFork::Dispatcher::SOAPError, "Required SOAP parameter '#{key}' is missing"
+      end
+
+      data = data[key]
+      data = [data] if @multiplied && !data.is_a?(Array)
+
+      if struct?
+        data ||= {}
+        if @multiplied
+          data.map do |x|
+            map_struct x do |param, dat, elem|
+              param.load(dat, elem)
+            end
+          end
+        else
+          map_struct data do |param, dat, elem|
+            param.load(dat, elem)
+          end
+        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
+          when 'base64Binary'; lambda{|dat| Base64.decode64(dat)}
+          else raise RuntimeError, "Invalid WashOutFork simple type: #{type}"
+        end
+
+        begin
+          if data.nil?
+            data
+          elsif @multiplied
+            return data.map{|x| x.send(operation)} if operation.is_a?(Symbol)
+            return data.map{|x| operation.call(x)} if operation.is_a?(Proc)
+          elsif operation.is_a? Symbol
+            data.send(operation)
+          else
+            operation.call(data)
+          end
+        rescue
+          raise WashOutFork::Dispatcher::SOAPError, "Invalid SOAP parameter '#{key}' format"
+        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_fork_param_name(@soap_config)
+    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 | WashOutFork::Param instance
+    #   type_hash   := { :parameter_name => nested_type, ... }
+    #   definition  := [ WashOutFork::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 WashOutFork::Param instance is passed as a +nested_type+, the corresponding
+    # +:parameter_name+ is ignored.
+    #
+    # This function returns an array of WashOutFork::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
+
+      if definition.is_a?(Class) && definition.ancestors.include?(WashOutFork::Type)
+        definition = definition.wash_out_fork_param_map
+      end
+
+      if [Array, Symbol].include?(definition.class)
+        definition = { :value => definition }
+      end
+
+      if definition.is_a? Hash
+        definition.map do |name, opt|
+          if opt.is_a? WashOutFork::Param
+            opt
+          elsif opt.is_a? Array
+            WashOutFork::Param.new(soap_config, name, opt[0], true)
+          else
+            WashOutFork::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 WashOutFork::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
+          param_name = param.attribute? ? param.attr_name : param.raw_name
+          struct[param_name] = yield param, data, param.raw_name
+        end
+      end
+
+      struct
+    end
+  end
+end