soap5r 2.0.0

data/lib/soap/mimemessage.rb

@@ -0,0 +1,243 @@
+# encoding: ASCII-8BIT
+# SOAP4R - MIME Message implementation.
+# Copyright (C) 2002  Jamie Herre.
+
+# 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 'soap/attachment'
+
+
+module SOAP
+
+
+# Classes for MIME message handling.  Should be put somewhere else!
+# Tried using the 'tmail' module but found that I needed something
+# lighter in weight.
+
+
+class MIMEMessage
+  class MIMEMessageError < StandardError; end
+
+  MultipartContentType = 'multipart/\w+'
+
+  class Header
+    attr_accessor :str, :key, :root
+
+    def initialize
+      @attrs = {}
+    end
+
+    def [](key)
+      @attrs[key]
+    end
+
+    def []=(key, value)
+      @attrs[key] = value
+    end
+
+    def to_s
+      @key + ": " + @str
+    end
+  end
+
+  class Headers < Hash
+    def self.parse(str)
+      new.parse(str)
+    end
+
+    def parse(str)
+      header_cache = nil
+      str = str.lines if str.respond_to?(:lines) # RubyJedi: compatible with Ruby 1.8.6 and above      
+      str.each do |line|
+	case line
+	when /^\A[^\: \t]+:\s*.+$/
+	  parse_line(header_cache) if header_cache
+	  header_cache = line.sub(/\r?\n\z/, '')
+	when /^\A\s+(.*)$/
+	  # a continuous line at the beginning line crashes here.
+	  header_cache << line
+	else
+	  raise RuntimeError.new("unexpected header: #{line.inspect}")
+	end
+      end
+      parse_line(header_cache) if header_cache
+      self
+    end
+
+    def parse_line(line)
+      if /^\A([^\: \t]+):\s*(.+)\z/ =~ line
+    	header = parse_rhs($2.strip)
+	header.key = $1.strip
+	self[header.key.downcase] = header
+      else
+	raise RuntimeError.new("unexpected header line: #{line.inspect}")
+      end
+    end
+
+    def parse_rhs(str)
+      a = str.split(/;+\s+/)
+      header = Header.new
+      header.str = str
+      header.root = a.shift
+      a.each do |pair|
+	if pair =~ /(\w+)\s*=\s*"?([^"]+)"?/
+	  header[$1.downcase] = $2
+	else
+	  raise RuntimeError.new("unexpected header component: #{pair.inspect}")
+	end
+      end
+      header
+    end
+
+    def add(key, value)
+      if key != nil and value != nil
+	header = parse_rhs(value)
+	header.key = key
+	self[key.downcase] = header
+      end
+    end
+
+    def to_s
+      self.values.collect { |hdr|
+	hdr.to_s
+      }.join("\r\n")
+    end
+  end
+
+  class Part
+    attr_accessor :headers, :body
+
+    def initialize
+      @headers = Headers.new
+      @headers.add("Content-Transfer-Encoding", "8bit")
+      @body = nil
+      @contentid = nil
+    end
+
+    def self.parse(str)
+      new.parse(str)
+    end
+
+    def parse(str)
+      headers, body = str.split(/\r\n\r\n/, 2)
+      if headers != nil and body != nil
+	@headers = Headers.parse(headers)
+	@body = body.sub(/\r\n\z/, '')
+      else
+	raise RuntimeError.new("unexpected part: #{str.inspect}")
+      end
+      self
+    end
+
+    def contentid
+      if @contentid == nil and @headers.key?('content-id')
+	@contentid = @headers['content-id'].str
+	@contentid = $1 if @contentid =~ /^<(.+)>$/
+      end
+      @contentid
+    end
+
+    alias content body
+
+    def to_s
+      @headers.to_s + "\r\n\r\n" + @body
+    end
+  end
+
+  def initialize
+    @parts = []
+    @headers = Headers.new
+    @root = nil
+    @boundary = nil
+  end
+
+  def self.parse(head, str)
+    new.parse(head, str)
+  end
+
+  attr_reader :parts, :headers
+
+  def close
+    @headers.add(
+      "Content-Type",
+      "multipart/related; type=\"text/xml\"; boundary=\"#{boundary}\"; start=\"#{@parts[0].contentid}\""
+    )
+  end
+
+  def parse(head, str)
+    @headers = Headers.parse(head + "\r\n" + "From: jfh\r\n")
+    boundary = @headers['content-type']['boundary']
+    if boundary != nil
+      parts = str.split(/--#{Regexp.quote(boundary)}\s*(?:\r\n|--\r\n)/)
+      part = parts.shift	# preamble must be ignored.
+      @parts = parts.collect { |part| Part.parse(part) }
+    else
+      @parts = [Part.parse(str)]
+    end
+    if @parts.length < 1
+      raise MIMEMessageError.new("This message contains no valid parts!")
+    end
+    self
+  end
+
+  def root
+    if @root == nil
+      start = @headers['content-type']['start']
+      @root = (start && @parts.find { |prt| prt.contentid == start }) ||
+	@parts[0]
+    end
+    @root
+  end
+
+  def boundary
+    if @boundary == nil
+      @boundary = "----=Part_" + __id__.to_s + rand.to_s
+    end
+    @boundary
+  end
+
+  def add_part(content)
+    part = Part.new
+    part.headers.add("Content-Type",
+      "text/xml; charset=" + XSD::Charset.xml_encoding_label)
+    part.headers.add("Content-ID", Attachment.contentid(part))
+    part.body = content
+    @parts.unshift(part)
+  end
+
+  def add_attachment(attach)
+    part = Part.new
+    part.headers.add("Content-Type", attach.contenttype)
+    part.headers.add("Content-ID", attach.mime_contentid)
+    part.body = attach.content
+    @parts.unshift(part)
+  end
+
+  def has_parts?
+    (@parts.length > 0)
+  end
+
+  def headers_str
+    @headers.to_s
+  end
+
+  def content_str
+    str = ''
+    @parts.each do |prt|
+      str << "--" + boundary + "\r\n"
+      str << prt.to_s + "\r\n"
+    end
+    str << '--' + boundary + "--\r\n"
+    str
+  end
+
+  def to_s
+    str = headers_str + "\r\n\r\n" + conent_str
+  end
+end
+
+
+end

data/lib/soap/nestedexception.rb

@@ -0,0 +1,43 @@
+# encoding: ASCII-8BIT
+# 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 defined?(@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,242 @@
+# encoding: ASCII-8BIT
+# 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
+      if SSLEnabled
+	http.use_ssl = true
+      else
+	raise RuntimeError.new("Cannot connect to #{url} (OpenSSL is not installed.)")
+      end
+    when URI::HTTP
+      # 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,39 @@
+# encoding: ASCII-8BIT
+# 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
+
+## Rubyjedi: Provide these (deprecated) constants for backward compatibility with older ActionWebService
+SOAPNamespaceTag = 'env'
+XSDNamespaceTag  = 'xsd'
+XSINamespaceTag  = 'xsi'
+
+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