DefV-soap4r 1.5.8.2

data/lib/soap/nestedexception.rb

@@ -0,0 +1,42 @@
+# SOAP4R - Nested exception implementation
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+module SOAP
+
+
+module NestedException
+  attr_reader :cause
+  attr_reader :original_backtraace
+
+  def initialize(msg = nil, cause = nil)
+    super(msg)
+    @cause = cause
+    @original_backtrace = nil
+  end
+
+  def set_backtrace(backtrace)
+    if @cause and @cause.respond_to?(:backtrace)
+      @original_backtrace = backtrace
+=begin
+      # for agressive backtrace abstraction: 'here' only should not be good
+      here = @original_backtrace[0]
+      backtrace = Array[*@cause.backtrace]
+      backtrace[0] = "#{backtrace[0]}: #{@cause} (#{@cause.class})"
+      backtrace.unshift(here)
+=end
+      # just join the nested backtrace at the tail of backtrace
+      caused = Array[*@cause.backtrace]
+      caused[0] = "#{caused[0]}: #{@cause} (#{@cause.class}) [NESTED]"
+      backtrace += caused
+    end
+    super(backtrace)
+  end
+end
+
+
+end

data/lib/soap/netHttpClient.rb

@@ -0,0 +1,241 @@
+# SOAP4R - net/http wrapper
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'net/http'
+require 'soap/filter/filterchain'
+
+
+module SOAP
+
+
+class NetHttpClient
+
+  SSLEnabled = begin
+      require 'net/https'
+      true
+    rescue LoadError
+      false
+    end
+
+  attr_reader :proxy
+  attr_accessor :no_proxy
+  attr_accessor :debug_dev
+  attr_accessor :ssl_config		# ignored for now.
+  attr_accessor :protocol_version	# ignored for now.
+  attr_accessor :connect_timeout
+  attr_accessor :send_timeout           # ignored for now.
+  attr_accessor :receive_timeout
+  attr_reader :test_loopback_response
+  attr_reader :request_filter           # ignored for now.
+
+  def initialize(proxy = nil, agent = nil)
+    @proxy = proxy ? URI.parse(proxy) : nil
+    @agent = agent
+    @debug_dev = nil
+    @test_loopback_response = []
+    @request_filter = Filter::FilterChain.new
+    @session_manager = SessionManager.new
+    @no_proxy = @ssl_config = @protocol_version = nil
+    @connect_timeout = @send_timeout = @receive_timeout = nil
+  end
+  
+  def proxy=(proxy)
+    if proxy.nil?
+      @proxy = nil
+    else
+      if proxy.is_a?(URI)
+        @proxy = proxy
+      else
+        @proxy = URI.parse(proxy)
+      end
+      if @proxy.scheme == nil or @proxy.scheme.downcase != 'http' or
+	  @proxy.host == nil or @proxy.port == nil
+	raise ArgumentError.new("unsupported proxy `#{proxy}'")
+      end
+    end
+    reset_all
+    @proxy
+  end
+
+  def set_auth(uri, user_id, passwd)
+    raise NotImplementedError.new("auth is not supported under soap4r + net/http.")
+  end
+
+  def set_basic_auth(uri, user_id, passwd)
+    # net/http does not handle url.
+    @basic_auth = [user_id, passwd]
+    raise NotImplementedError.new("basic_auth is not supported under soap4r + net/http.")
+  end
+
+  def set_cookie_store(filename)
+    raise NotImplementedError.new
+  end
+
+  def save_cookie_store(filename)
+    raise NotImplementedError.new
+  end
+
+  def reset(url)
+    # no persistent connection.  ignored.
+  end
+
+  def reset_all
+    # no persistent connection.  ignored.
+  end
+
+  def post(url, req_body, header = {})
+    post_redirect(url, req_body, header, 10)
+  end
+
+  def get_content(url, header = {})
+    if str = @test_loopback_response.shift
+      return str
+    end
+    unless url.is_a?(URI)
+      url = URI.parse(url)
+    end
+    extra = header.dup
+    extra['User-Agent'] = @agent if @agent
+    res = start(url) { |http|
+	http.get(url.request_uri, extra)
+      }
+    res.body
+  end
+
+private
+
+  def post_redirect(url, req_body, header, redirect_count)
+    if str = @test_loopback_response.shift
+      if @debug_dev
+        @debug_dev << "= Request\n\n"
+        @debug_dev << req_body
+        @debug_dev << "\n\n= Response\n\n"
+        @debug_dev << str
+      end
+      status = 200
+      reason = nil
+      contenttype = 'text/xml'
+      content = str
+      return Response.new(status, reason, contenttype, content)
+      return str
+    end
+    unless url.is_a?(URI)
+      url = URI.parse(url)
+    end
+    extra = header.dup
+    extra['User-Agent'] = @agent if @agent
+    res = start(url) { |http|
+      if @debug_dev
+        @debug_dev << "= Request\n\n"
+        @debug_dev << req_body << "\n"
+      end
+      http.post(url.request_uri, req_body, extra)
+    }
+    case res
+    when Net::HTTPRedirection 
+      if redirect_count > 0
+        post_redirect(res['location'], req_body, header,
+          redirect_count - 1) 
+      else
+       raise ArgumentError.new("Too many redirects")
+      end
+    else
+      Response.from_httpresponse(res)
+    end
+  end
+
+  def start(url)
+    http = create_connection(url)
+    response = nil
+    http.start { |worker|
+      response = yield(worker)
+      worker.finish
+    }
+    if @debug_dev
+      @debug_dev << "\n\n= Response\n\n"
+      @debug_dev << response.body << "\n"
+    end
+    response
+  end
+
+  def create_connection(url)
+    proxy_host = proxy_port = nil
+    unless no_proxy?(url)
+      proxy_host = @proxy.host
+      proxy_port = @proxy.port
+    end
+    http = Net::HTTP::Proxy(proxy_host, proxy_port).new(url.host, url.port)
+    if http.respond_to?(:set_debug_output)
+      http.set_debug_output(@debug_dev)
+    end
+    http.open_timeout = @connect_timeout if @connect_timeout
+    http.read_timeout = @receive_timeout if @receive_timeout
+    case url
+    when URI::HTTPS then
+      if SSLEnabled
+	      http.use_ssl = true
+      else
+	      raise RuntimeError.new("Cannot connect to #{url} (OpenSSL is not installed.)")
+      end
+    when URI::HTTP then
+      # OK
+    else
+      raise RuntimeError.new("Cannot connect to #{url} (Not HTTP.)")
+    end
+    http
+  end
+
+  NO_PROXY_HOSTS = ['localhost']
+
+  def no_proxy?(uri)
+    if !@proxy or NO_PROXY_HOSTS.include?(uri.host)
+      return true
+    end
+    unless @no_proxy
+      return false
+    end
+    @no_proxy.scan(/([^:,]+)(?::(\d+))?/) do |host, port|
+      if /(\A|\.)#{Regexp.quote(host)}\z/i =~ uri.host &&
+          (!port || uri.port == port.to_i)
+        return true
+      end
+    end
+    false
+  end
+
+  class SessionManager
+    attr_accessor :connect_timeout
+    attr_accessor :send_timeout
+    attr_accessor :receive_timeout
+  end
+
+  class Response
+    attr_reader :status
+    attr_reader :reason
+    attr_reader :contenttype
+    attr_reader :content
+
+    def initialize(status, reason, contenttype, content)
+      @status = status
+      @reason = reason
+      @contenttype = contenttype
+      @content = content
+    end
+
+    def self.from_httpresponse(res)
+      status = res.code.to_i
+      reason = res.message
+      contenttype = res['content-type']
+      content = res.body
+      new(status, reason, contenttype, content)
+    end
+  end
+end
+
+
+end

data/lib/soap/ns.rb

@@ -0,0 +1,34 @@
+# SOAP4R - SOAP Namespace library
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/datatypes'
+require 'xsd/ns'
+require 'soap/soap'
+
+
+module SOAP
+
+
+class NS < XSD::NS
+  KNOWN_TAG = XSD::NS::KNOWN_TAG.dup.update(
+    SOAP::EnvelopeNamespace => 'env'
+  )
+
+  def initialize(tag2ns = nil)
+    super(tag2ns)
+  end
+
+private
+
+  def default_known_tag
+    KNOWN_TAG
+  end
+end
+
+
+end

data/lib/soap/parser.rb

@@ -0,0 +1,252 @@
+# SOAP4R - SOAP XML Instance Parser library.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/xmlparser'
+require 'soap/soap'
+require 'soap/ns'
+require 'soap/baseData'
+require 'soap/encodingstyle/handler'
+
+
+module SOAP
+
+
+class Parser
+  include SOAP
+
+  class ParseError < Error; end
+  class FormatDecodeError < ParseError; end
+  class UnexpectedElementError < ParseError; end
+
+private
+
+  class ParseFrame
+    attr_reader :node
+    attr_reader :name
+    attr_reader :ns
+    attr_reader :encodingstyle
+    attr_reader :handler
+
+    class NodeContainer
+      def initialize(node)
+	@node = node
+      end
+
+      def node
+	@node
+      end
+
+      def replace_node(node)
+	@node = node
+      end
+    end
+
+  public
+
+    def initialize(ns, name, node, encodingstyle, handler)
+      @ns = ns
+      @name = name
+      @node = NodeContainer.new(node)
+      @encodingstyle = encodingstyle
+      @handler = handler
+    end
+
+    # to avoid memory consumption
+    def update(ns, name, node, encodingstyle, handler)
+      @ns = ns
+      @name = name
+      @node.replace_node(node)
+      @encodingstyle = encodingstyle
+      @handler = handler
+      self
+    end
+  end
+
+public
+
+  attr_accessor :envelopenamespace
+  attr_accessor :default_encodingstyle
+  attr_accessor :decode_typemap
+  attr_accessor :allow_unqualified_element
+
+  def initialize(opt = {})
+    @opt = opt
+    @parser = XSD::XMLParser.create_parser(self, opt)
+    @parsestack = nil
+    @recycleframe = nil
+    @lastnode = nil
+    @handlers = {}
+    @envelopenamespace = opt[:envelopenamespace] || EnvelopeNamespace
+    @default_encodingstyle = opt[:default_encodingstyle] || EncodingNamespace
+    @decode_typemap = opt[:decode_typemap] || nil
+    @allow_unqualified_element = opt[:allow_unqualified_element] || false
+  end
+
+  def charset
+    @parser.charset
+  end
+
+  def parse(string_or_readable)
+    @parsestack = []
+    @lastnode = nil
+
+    @handlers.each do |uri, handler|
+      handler.decode_prologue
+    end
+
+    @parser.do_parse(string_or_readable)
+
+    unless @parsestack.empty?
+      raise FormatDecodeError.new("Unbalanced tag in XML.")
+    end
+
+    @handlers.each do |uri, handler|
+      handler.decode_epilogue
+    end
+
+    @lastnode
+  end
+
+  def start_element(name, raw_attrs)
+    lastframe = @parsestack.last
+    ns = parent = parent_encodingstyle = nil
+    if lastframe
+      ns = lastframe.ns
+      parent = lastframe.node
+      parent_encodingstyle = lastframe.encodingstyle
+    else
+      ns = SOAP::NS.new
+      parent = ParseFrame::NodeContainer.new(nil)
+      parent_encodingstyle = nil
+    end
+    # ns might be the same
+    ns, raw_attrs = XSD::XMLParser.filter_ns(ns, raw_attrs)
+    attrs = decode_attrs(ns, raw_attrs)
+    encodingstyle = attrs[AttrEncodingStyleName]
+    # Children's encodingstyle is derived from its parent.
+    if encodingstyle.nil?
+      if parent.node.is_a?(SOAPHeader)
+        encodingstyle = LiteralNamespace
+      else
+        encodingstyle = parent_encodingstyle || @default_encodingstyle
+      end
+    end
+    handler = find_handler(encodingstyle)
+    unless handler
+      raise FormatDecodeError.new("Unknown encodingStyle: #{ encodingstyle }.")
+    end
+    node = decode_tag(ns, name, attrs, parent, handler)
+    if @recycleframe
+      @parsestack << @recycleframe.update(ns, name, node, encodingstyle, handler)
+      @recycleframe = nil
+    else
+      @parsestack << ParseFrame.new(ns, name, node, encodingstyle, handler)
+    end
+  end
+
+  def characters(text)
+    # Ignore Text outside of SOAP Envelope.
+    if lastframe = @parsestack.last
+      # Need not to be cloned because character does not have attr.
+      decode_text(lastframe.ns, text, lastframe.handler)
+    end
+  end
+
+  def end_element(name)
+    lastframe = @parsestack.pop
+    unless name == lastframe.name
+      raise UnexpectedElementError.new("Closing element name '#{ name }' does not match with opening element '#{ lastframe.name }'.")
+    end
+    decode_tag_end(lastframe.ns, lastframe.node, lastframe.handler)
+    @lastnode = lastframe.node.node
+    @recycleframe = lastframe
+  end
+
+private
+
+  def decode_tag(ns, name, attrs, parent, handler)
+    ele = ns.parse(name)
+    # Envelope based parsing.
+    if ((ele.namespace == @envelopenamespace) ||
+	(@allow_unqualified_element && ele.namespace.nil?))
+      o = decode_soap_envelope(ns, ele, attrs, parent)
+      return o if o
+    end
+    # Encoding based parsing.
+    return handler.decode_tag(ns, ele, attrs, parent)
+  end
+
+  def decode_tag_end(ns, node, handler)
+    return handler.decode_tag_end(ns, node)
+  end
+
+  def decode_attrs(ns, attrs)
+    extraattr = {}
+    attrs.each do |key, value|
+      qname = ns.parse_local(key)
+      extraattr[qname] = value
+    end
+    extraattr
+  end
+
+  def decode_text(ns, text, handler)
+    handler.decode_text(ns, text)
+  end
+
+  def decode_soap_envelope(ns, ele, attrs, parent)
+    o = nil
+    if ele.name == EleEnvelope
+      o = SOAPEnvelope.new
+      if ext = @opt[:external_content]
+	ext.each do |k, v|
+	  o.external_content[k] = v
+	end
+      end
+    elsif ele.name == EleHeader
+      return nil unless parent.node.is_a?(SOAPEnvelope)
+      o = SOAPHeader.new
+      parent.node.header = o
+    elsif ele.name == EleBody
+      return nil unless parent.node.is_a?(SOAPEnvelope)
+      o = SOAPBody.new
+      parent.node.body = o
+    elsif ele.name == EleFault
+      if parent.node.is_a?(SOAPBody)
+        o = SOAPFault.new
+        parent.node.fault = o
+      elsif parent.node.is_a?(SOAPEnvelope)
+        # live.com server returns SOAPFault as a direct child of SOAPEnvelope.
+        # support it even if it's not spec compliant.
+        warn("Fault must be a child of Body.")
+        body = SOAPBody.new
+        parent.node.body = body
+        o = SOAPFault.new
+        body.fault = o
+      else
+        return nil
+      end
+    end
+    o.extraattr.update(attrs) if o
+    o
+  end
+
+  def find_handler(encodingstyle)
+    unless @handlers.key?(encodingstyle)
+      handler_factory = SOAP::EncodingStyle::Handler.handler(encodingstyle) ||
+	SOAP::EncodingStyle::Handler.handler(EncodingNamespace)
+      handler = handler_factory.new(@parser.charset)
+      handler.decode_typemap = @decode_typemap
+      handler.decode_prologue
+      @handlers[encodingstyle] = handler
+    end
+    @handlers[encodingstyle]
+  end
+end
+
+
+end