wash_out 0.9.2 → 0.10.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9149b2f9a1a04ad8d6ba859ef68f2dbf9db6d585
-  data.tar.gz: 55936871f904cf8d45517312b4479a39a5a5e5d5
+  metadata.gz: 443e624e950f3d062ccc19a9d2221dbc1ac91b25
+  data.tar.gz: facd37fd93991475d04e93a3544e156db1736a2c
 SHA512:
-  metadata.gz: 5e2798c550e16322bb72de0dfa08c0e3a18ec3d292b481fc905d36f72d4b51a60bd889a583b723fc54081a484520c260a07e8b28dab1bb9babfa10f115e76e4b
-  data.tar.gz: 08821de12b76c9fc9f4c79ddc381279ebddfa7c42d6a197e9a7b7528f94044b46927edffab4bf9bb7dfcb090e4678effe80ef1e61cfd4cdee6c339dd0ed64090
+  metadata.gz: c7e405ff31de4bdae9c2927e28791167a36a942a999a1eb732fcaa459855b5b1f227e30ab71d784a4efd6ec0b4a10d5d23b170dba8c27287c71b7d1d4aeab9f9
+  data.tar.gz: 6874a42fc4db8368b1cbb7fff4989ce5741449f743d2924b234be4da80762ac4688a4354aa5a5e245eb0d067b249c9dd01ceabe82239f0c05e384ba978cf2dc5

data/.gitignore

@@ -2,8 +2,6 @@
 .bundle/
 *.gem
 .idea/
-.ruby-gemset
-.ruby-version
 .rvmrc
 *.swp
 log/*.log

data/.travis.yml

@@ -4,4 +4,3 @@ rvm:
   - 1.9.3
   - jruby-19mode
   - 2.0.0
-  - 2.1.0

data/Appraisals

@@ -12,12 +12,4 @@ end
 
 appraise "rails-4.0.0" do
   gem "rails", "4.0.0"
-end
-
-appraise "rails-4.1.0" do
-  gem "rails", "4.1.0"
-end
-
-appraise "rails-4.2.0" do
-  gem "rails", "4.2.0"
-end
+end

data/Gemfile

@@ -4,7 +4,7 @@ gemspec
 
 gem 'wasabi'
 gem 'savon', '>= 2.0.0'
-gem 'httpi'
+gem 'httpi', :git => 'git://github.com/savonrb/httpi.git'
 
 gem 'rspec-rails'
 gem 'guard'

data/README.md

@@ -63,7 +63,7 @@ class RumbasController < ApplicationController
   def add_circle
     circle = params[:circle]
 
-    raise SOAPError, "radius is too small" if circle[:radius] < 3.0
+    raise WashOut::SOAPError, "radius is too small" if circle[:radius] < 3.0
 
     Circle.new(circle[:center][:x], circle[:center][:y], circle[:radius])
 
@@ -94,7 +94,7 @@ WashOutSample::Application.routes.draw do
 end
 ```
 
-In such a setup, the generated WSDL may be queried at path `/rumbas/wsdl`. So, with a
+In such a setup, the generated WSDL may be queried at path `/api/wsdl`. So, with a
 gem like Savon, a request can be done using this path:
 
 ```ruby
@@ -137,32 +137,6 @@ To use defined type inside your inline declaration, pass the class instead of ty
 Note that WashOut extends the `ActiveRecord` so every model you use is already a WashOut::Type and can be used
 inside your interface declarations.
 
-## WSSE Authentication
-
-WashOut provides two mechanism for WSSE Authentication. 
-
-### Static Authentication
-
-You can configure the service to validate against a username and password with the following configuration:
-
-```ruby
-soap_service namespace: "wash_out", wsse_username: "username", wsse_password: "password"
-```
-
-With this mechanism, all the actions in the controller will be authenticated against the specified username and password. If you need to authenticate different users, you can use the dynamic mechanism described below.
-
-### Dynamic Authentication
-
-Dynamic authentication allows you to process the username and password any way you want, with the most common case being authenticating against a database. The configuration option for this mechanism is called `wsse_auth_callback`:
-
-```ruby
-soap_service namespace: "wash_out", wsse_auth_callback: ->(username, password) {
-  return !User.find_by(username: username).authenticate(password).blank?
-}
-```
-
-Keep in mind that the password may already be hashed by the SOAP client, so you would have to check against that condition too as per [spec](http://www.oasis-open.org/committees/download.php/16782/wss-v1.1-spec-os-UsernameTokenProfile.pdf)
-
 ## Configuration
 
 Use `config.wash_out...` inside your environment configuration to setup WashOut globally.

data/app/views/wash_with_soap/document/response.builder

@@ -3,7 +3,9 @@ xml.tag! "soap:Envelope", "xmlns:soap" => 'http://schemas.xmlsoap.org/soap/envel
                           "xmlns:xsd" => 'http://www.w3.org/2001/XMLSchema',
                           "xmlns:tns" => @namespace do
   xml.tag! "soap:Body" do
-    xml.tag! "tns:#{@action_spec[:response_tag]}" do
+    key = "tns:#{@operation}#{controller.soap_config.camelize_wsdl ? 'Response' : '_response'}"
+
+    xml.tag! @action_spec[:response_tag] || key do
       wsdl_data xml, result
     end
   end

data/app/views/wash_with_soap/document/wsdl.builder

@@ -20,10 +20,10 @@ xml.definitions 'xmlns' => 'http://schemas.xmlsoap.org/wsdl/',
   end
 
   xml.portType :name => "#{@name}_port" do
-    @map.each do |operation, formats|
+    @map.keys.each do |operation|
       xml.operation :name => operation do
         xml.input :message => "tns:#{operation}"
-        xml.output :message => "tns:#{formats[:response_tag]}"
+        xml.output :message => "tns:#{operation}#{controller.soap_config.camelize_wsdl ? 'Response' : '_response'}"
       end
     end
   end
@@ -59,7 +59,7 @@ xml.definitions 'xmlns' => 'http://schemas.xmlsoap.org/wsdl/',
         xml.part wsdl_occurence(p, false, :name => p.name, :type => p.namespaced_type)
       end
     end
-    xml.message :name => formats[:response_tag] do
+    xml.message :name => "#{operation}#{controller.soap_config.camelize_wsdl ? 'Response' : '_response'}" do
       formats[:out].each do |p|
         xml.part wsdl_occurence(p, false, :name => p.name, :type => p.namespaced_type)
       end

data/app/views/wash_with_soap/rpc/response.builder

@@ -4,7 +4,9 @@ xml.tag! "soap:Envelope", "xmlns:soap" => 'http://schemas.xmlsoap.org/soap/envel
                           "xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance',
                           "xmlns:tns" => @namespace do
   xml.tag! "soap:Body" do
-    xml.tag! "tns:#{@action_spec[:response_tag]}" do
+    key = "tns:#{@operation}#{controller.soap_config.camelize_wsdl ? 'Response' : '_response'}"
+
+    xml.tag! @action_spec[:response_tag] || key do
       wsdl_data xml, result
     end
   end

data/app/views/wash_with_soap/rpc/wsdl.builder

@@ -20,10 +20,10 @@ xml.definitions 'xmlns' => 'http://schemas.xmlsoap.org/wsdl/',
   end
 
   xml.portType :name => "#{@name}_port" do
-    @map.each do |operation, formats|
+    @map.keys.each do |operation|
       xml.operation :name => operation do
         xml.input :message => "tns:#{operation}"
-        xml.output :message => "tns:#{formats[:response_tag]}"
+        xml.output :message => "tns:#{operation}#{controller.soap_config.camelize_wsdl ? 'Response' : '_response'}"
       end
     end
   end
@@ -59,7 +59,7 @@ xml.definitions 'xmlns' => 'http://schemas.xmlsoap.org/wsdl/',
         xml.part wsdl_occurence(p, true, :name => p.name, :type => p.namespaced_type)
       end
     end
-    xml.message :name => formats[:response_tag] do
+    xml.message :name => "#{operation}#{controller.soap_config.camelize_wsdl ? 'Response' : '_response'}" do
       formats[:out].each do |p|
         xml.part wsdl_occurence(p, true, :name => p.name, :type => p.namespaced_type)
       end

data/lib/wash_out/exceptions/programmer_error.rb

@@ -0,0 +1,10 @@
+module WashOut
+  #
+  # An exception reflection unexpected error
+  #
+  # Used internally to remark badly composited definitions of
+  # actions and other violations
+  #
+  class ProgrammerError < Exception
+  end
+end

data/lib/wash_out/exceptions/soap_error.rb

@@ -0,0 +1,19 @@
+module WashOut
+  #
+  # An exception reflecting expected logical error
+  #
+  # Such exception (or its descendants) will be intercepted and rendered
+  # into proper SOAP error XML response.
+  #
+  class SOAPError < Exception
+    attr_accessor :code
+
+    def initialize(message, code=nil)
+      super(message)
+      @code = code
+    end
+  end
+end
+
+# Backward compatibility hack
+class SOAPError < WashOut::SOAPError; end

data/lib/wash_out/middlewares/catcher.rb

@@ -0,0 +1,42 @@
+module WashOut
+  module Middlewares
+    class Catcher
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call env
+      rescue REXML::ParseException => e
+        raise e unless env.has_key?('HTTP_SOAPACTION')
+
+        input = env['rack.input'].respond_to?(:string) ? env['rack.input'].string
+                                                       : env['rack.input'].read
+
+        env['rack.errors'].puts <<-TEXT
+          WashOut::Exception: #{e.continued_exception} for:
+          #{input}
+        TEXT
+
+        [
+          400,
+          {'Content-Type' => 'text/xml'},
+          [self.class.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
+  end
+end

data/lib/wash_out/middlewares/router.rb

@@ -0,0 +1,132 @@
+require 'nori'
+
+module WashOut
+  module Middlewares
+    #
+    # This class is a Rack middleware used to route SOAP requests to a proper
+    # action of a given SOAP controller.
+    #
+    # WashOut engine adds routing helper `wash_out` that registeres this middleware
+    # as a main responder internally.
+    #
+    # @see WashOut::Rails::Engine
+    #
+    class Router
+      def initialize(controller_name)
+        @controller_name = "#{controller_name.to_s}_controller".camelize
+      end
+
+      def parse_soap_action(env)
+        return env['wash_out.soap_action'] if env['wash_out.soap_action']
+
+        # SOAPACTION is expected to come in quotes that have to be stripped
+        soap_action = env['HTTP_SOAPACTION'].to_s.gsub(/^"(.*)"$/, '\1')
+
+        # Clients can sometimes send empty SOAPACTION to avoid duplication
+        # In this cases we have to get it from the body
+        if soap_action.blank?
+          soap_action = nori.parse(soap_body env)[:Envelope][:Body].keys.first.to_s
+        end
+
+        # RUBY18
+        soap_action.force_encoding('UTF-8') if soap_action.respond_to? :force_encoding
+
+        # And finally we have to strip namespace from the action name
+        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 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)
+
+        # Seeking for in-XML substitutions marked by attribute `id`
+        references = self.class.deep_select(env['wash_out.soap_data']) do |k,v|
+          v.is_a?(Hash) && v.has_key?(:@id)
+        end
+
+        # Replacing the found substitutions with nodes having proper `href` attribute
+        unless references.blank?
+          replaces = {}
+          references.each { |r| replaces['#'+r[:@id]] = r }
+
+          env['wash_out.soap_data'] = self.class.deep_replace_href(env['wash_out.soap_data'], replaces)
+        end
+
+        env['wash_out.soap_data']
+      end
+
+      #
+      # Nori parser builder
+      #
+      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
+
+      #
+      # Universal body accessor working with any Rack server
+      #
+      def soap_body(env)
+        env['rack.input'].respond_to?(:string) ? env['rack.input'].string
+                                               : env['rack.input'].read
+      end
+
+      def call(env)
+        @controller = @controller_name.constantize
+
+        parse_soap_action(env)
+        parse_soap_parameters(env)
+
+        action_spec = @controller.soap_actions[env['wash_out.soap_action']]
+
+        if action_spec
+          action = action_spec[:to]
+        else
+          action = '_invalid_action'
+        end
+
+        @controller.action(action).call(env)
+      end
+
+      #
+      # Recursively seeks XML tree for nodes matching given block
+      #
+      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
+
+      #
+      # Recursively replaces nodes in the tree matching the given
+      # map of `href` attributes
+      #
+      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
+end

data/lib/wash_out/param.rb

@@ -13,26 +13,22 @@ module WashOut
     def initialize(soap_config, name, type, multiplied = false)
       type ||= {}
       @soap_config = soap_config
-      @name       = name.to_s
+      @name       = WashOut.normalize(name, soap_config)
       @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
-      else
+      elsif type.is_a?(Hash)
         @type = 'struct'
         @map  = self.class.parse_def(soap_config, type)
+      else
+        raise RuntimeError, "Wrong definition: #{type.inspect}"
       end
     end
 
@@ -40,7 +36,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::Dispatcher::SOAPError, "Required SOAP parameter '#{key}' is missing"
+        raise WashOut::SOAPError, "Required SOAP parameter '#{key}' is missing"
       end
 
       data = data[key]
@@ -84,7 +80,7 @@ module WashOut
             operation.call(data)
           end
         rescue
-          raise WashOut::Dispatcher::SOAPError, "Invalid SOAP parameter '#{key}' format"
+          raise WashOut::SOAPError, "Invalid SOAP parameter '#{key}' format"
         end
       end
     end
@@ -134,33 +130,22 @@ 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
 
-      if definition.is_a?(Class) && definition.ancestors.include?(WashOut::Type)
-        definition = definition.wash_out_param_map
-      end
+      definition = { :value => definition } unless definition.is_a?(Hash)
 
-      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
+      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
-      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 = copy.source_class
       copy
     end
 
@@ -169,7 +154,7 @@ module WashOut
     # Used to load an entire structure.
     def map_struct(data)
       unless data.is_a?(Hash)
-        raise WashOut::Dispatcher::SOAPError, "SOAP message structure is broken"
+        raise WashOut::SOAPError, "SOAP message structure is broken"
       end
 
       data   = data.with_indifferent_access

data/lib/wash_out/rails/active_record.rb

@@ -0,0 +1,27 @@
+module WashOut
+  module Rails
+    module ActiveRecord
+      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(soap_config = nil)
+        WashOut.normalize(name.underscore.gsub('/', '.'), soap_config)
+      end
+    end
+  end
+end