wash_out 0.10.0.beta.1 → 0.10.0

data/spec/spec_helper.rb

@@ -27,7 +27,11 @@ RSpec.configure do |config|
 
   config.mock_with :rspec
   config.before(:all) do
-    WashOut::Rails::Engine.config.wash_out = WashOut::Rails::Engine.defaults
+    WashOut::Engine.config.wash_out = {
+      snakecase_input: false,
+      camelize_wsdl: false,
+      namespace: false
+    }
   end
 
   config.after(:suite) do
@@ -52,6 +56,8 @@ end
 def mock_controller(options = {}, &block)
   Object.send :remove_const, :ApiController if defined?(ApiController)
   Object.send :const_set, :ApiController, Class.new(ApplicationController) {
+    include RSpec::Matchers
+    
     soap_service options.reverse_merge({
       snakecase_input: true,
       camelize_wsdl: true,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wash_out
 version: !ruby/object:Gem::Version
-  version: 0.10.0.beta.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Boris Staal
@@ -9,20 +9,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-07 00:00:00.000000000 Z
+date: 2016-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nori
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.0
 description: Dead simple Rails 3 SOAP server library
@@ -31,9 +31,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Appraisals
 - CHANGELOG.md
 - Gemfile
@@ -42,22 +42,28 @@ files:
 - README.md
 - Rakefile
 - app/helpers/wash_out_helper.rb
-- app/views/wash_with_soap/document/error.builder
-- app/views/wash_with_soap/document/response.builder
-- app/views/wash_with_soap/document/wsdl.builder
-- app/views/wash_with_soap/rpc/error.builder
-- app/views/wash_with_soap/rpc/response.builder
-- app/views/wash_with_soap/rpc/wsdl.builder
+- app/views/wash_out/document/error.builder
+- app/views/wash_out/document/response.builder
+- app/views/wash_out/document/wsdl.builder
+- app/views/wash_out/rpc/error.builder
+- app/views/wash_out/rpc/response.builder
+- app/views/wash_out/rpc/wsdl.builder
+- gemfiles/rails_3.1.3.gemfile
+- gemfiles/rails_3.2.12.gemfile
+- gemfiles/rails_4.0.0.gemfile
+- gemfiles/rails_4.1.0.gemfile
+- gemfiles/rails_4.2.0.gemfile
 - init.rb
 - lib/wash_out.rb
-- lib/wash_out/exceptions/programmer_error.rb
-- lib/wash_out/exceptions/soap_error.rb
-- lib/wash_out/middlewares/catcher.rb
-- lib/wash_out/middlewares/router.rb
+- lib/wash_out/configurable.rb
+- lib/wash_out/dispatcher.rb
+- lib/wash_out/engine.rb
+- lib/wash_out/middleware.rb
+- lib/wash_out/model.rb
 - lib/wash_out/param.rb
-- lib/wash_out/rails/active_record.rb
-- lib/wash_out/rails/controller.rb
-- lib/wash_out/rails/engine.rb
+- lib/wash_out/router.rb
+- lib/wash_out/soap.rb
+- lib/wash_out/soap_config.rb
 - lib/wash_out/type.rb
 - lib/wash_out/version.rb
 - lib/wash_out/wsse.rb
@@ -85,8 +91,9 @@ files:
 - spec/dummy/public/stylesheets/.gitkeep
 - spec/dummy/script/rails
 - spec/lib/wash_out/dispatcher_spec.rb
+- spec/lib/wash_out/middleware_spec.rb
 - spec/lib/wash_out/param_spec.rb
-- spec/lib/wash_out/rack_spec.rb
+- spec/lib/wash_out/router_spec.rb
 - spec/lib/wash_out/type_spec.rb
 - spec/lib/wash_out_spec.rb
 - spec/spec_helper.rb
@@ -102,17 +109,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Dead simple Rails 3 SOAP server library

data/lib/wash_out/exceptions/programmer_error.rb

@@ -1,10 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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/rails/active_record.rb

@@ -1,27 +0,0 @@
-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

data/lib/wash_out/rails/controller.rb

@@ -1,201 +0,0 @@
-module WashOut
-  module Rails
-    # The WashOut::Rails::Controller module should be included in a controller acting
-    # as a SOAP endpoint. It includes actions for generating WSDL and handling
-    # SOAP requests.
-    module Controller extend ActiveSupport::Concern
-
-      included do
-        helper :wash_out
-
-        around_filter :_catch_soap_errors
-        before_filter :_authenticate_wsse,   :except => [ :_generate_wsdl, :_invalid_action ]
-        before_filter :_map_soap_parameters, :except => [ :_generate_wsdl, :_invalid_action ]
-
-        skip_before_filter :verify_authenticity_token
-
-        cattr_reader   :soap_config
-        cattr_accessor :soap_actions
-
-        self.soap_actions = {}
-      end
-
-      module ClassMethods
-        #
-        # Overrides WashOut settings on a controller level
-        #
-        def soap_config=(options)
-          class_variable_set :@@soap_config, OpenStruct.new(
-            WashOut::Rails::Engine.config.wash_out.merge(options)
-          )
-        end
-
-        #
-        # 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={})
-          exposed_name = if action.is_a?(Symbol)
-            WashOut.normalize(action, soap_config) 
-          else
-            action.to_s
-          end
-
-          self.soap_actions[exposed_name] = options.merge(
-            in:           WashOut::Param.parse_def(soap_config, options[:args]),
-            out:          WashOut::Param.parse_def(soap_config, options[:return]),
-            to:           options[:to] || action.to_s
-          )
-        end
-      end
-
-      #
-      # Render a SOAP error response.
-      #
-      def render_soap_error(message, code=nil)
-        render :template => "wash_with_soap/#{soap_config.wsdl_style}/error", :status => 500,
-               :layout => false,
-               :locals => { :error_message => message, :error_code => (code || 'Server') },
-               :content_type => 'text/xml'
-      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
-        soap_action = request.env['wash_out.soap_action']
-        action_spec = self.class.soap_actions[soap_action]
-
-        xml_data = env['wash_out.soap_data'].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.keys.each do |key|
-            if hash[key].is_a? Hash
-              value = hash[key].delete_if{|k, v| 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 = _load_params(action_spec[:in], xml_data)
-      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_with_soap/#{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 WashOut::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 WashOut::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_with_soap/#{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 WashOut::SOAPError => error
-        render_soap_error(error.message, error.code)
-      end
-    end
-  end
-end