soap5r 2.0.0

data/lib/soap/generator.rb

@@ -0,0 +1,299 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP XML Instance Generator 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 'soap/soap'
+require 'soap/ns'
+require 'soap/baseData'
+require 'soap/encodingstyle/handler'
+require 'xsd/codegen/gensupport'
+
+
+module SOAP
+
+
+###
+## CAUTION: MT-unsafe
+#
+class Generator
+  include SOAP
+  include XSD::CodeGen::GenSupport
+
+  class FormatEncodeError < Error; end
+
+public
+
+  attr_accessor :charset
+  attr_accessor :default_encodingstyle
+  attr_accessor :generate_explicit_type
+  attr_accessor :use_numeric_character_reference
+  attr_accessor :use_default_namespace
+
+  def initialize(opt = {})
+    @reftarget = nil
+    @handlers = {}
+    @charset = opt[:charset] || XSD::Charset.xml_encoding_label
+    @default_encodingstyle = opt[:default_encodingstyle] || EncodingNamespace
+    @generate_explicit_type =
+      opt.key?(:generate_explicit_type) ? opt[:generate_explicit_type] : true
+    @use_default_namespace = opt[:use_default_namespace]
+    @attributeformdefault = opt[:attributeformdefault]
+    @use_numeric_character_reference = opt[:use_numeric_character_reference]
+    @indentstr = opt[:no_indent] ? '' : '  '
+    @buf = @indent = @curr = nil
+    @default_ns = opt[:default_ns]
+    @default_ns_tag = opt[:default_ns_tag]
+  end
+
+  def generate(obj, io = nil)
+    @buf = io || ''
+    @indent = ''
+    @encode_char_regexp = get_encode_char_regexp()
+
+    prologue
+    @handlers.each do |uri, handler|
+      handler.encode_prologue
+    end
+
+    ns = SOAP::NS.new
+    if @default_ns
+      @default_ns.each_ns do |default_ns, default_tag|
+        Generator.assign_ns(obj.extraattr, ns, default_ns, default_tag)
+      end
+    end
+    if @default_ns_tag
+      @default_ns_tag.each_ns do |default_ns, default_tag|
+        ns.known_tag[default_ns] = default_tag
+      end
+    end
+    @buf << xmldecl
+    encode_data(ns, obj, nil)
+
+    @handlers.each do |uri, handler|
+      handler.encode_epilogue
+    end
+    epilogue
+
+    @buf
+  end
+
+  def encode_data(ns, obj, parent)
+    if obj.respond_to?(:to_xmlpart)
+      formatted = trim_eol(obj.to_xmlpart)
+      formatted = trim_indent(formatted)
+      formatted = formatted.gsub(/^/, @indent).sub(/\n+\z/, '')
+      @buf << "\n#{formatted}"
+      return
+    elsif obj.is_a?(SOAPEnvelopeElement)
+      encode_element(ns, obj, parent)
+      return
+    end
+    if @reftarget && !obj.precedents.empty?
+      add_reftarget(obj.elename.name, obj)
+      ref = SOAPReference.new(obj)
+      ref.elename = ref.elename.dup_name(obj.elename.name)
+      obj.precedents.clear	# Avoid cyclic delay.
+      obj.encodingstyle = parent.encodingstyle
+      # SOAPReference is encoded here.
+      obj = ref
+    end
+    encodingstyle = obj.encodingstyle
+    # Children's encodingstyle is derived from its parent.
+    encodingstyle ||= parent.encodingstyle if parent
+    obj.encodingstyle = encodingstyle
+    handler = find_handler(encodingstyle || @default_encodingstyle)
+    unless handler
+      raise FormatEncodeError.new("Unknown encodingStyle: #{ encodingstyle }.")
+    end
+    if !obj.elename.name
+      raise FormatEncodeError.new("Element name not defined: #{ obj }.")
+    end
+    handler.encode_data(self, ns, obj, parent)
+    handler.encode_data_end(self, ns, obj, parent)
+  end
+
+  def add_reftarget(name, node)
+    unless @reftarget
+      raise FormatEncodeError.new("Reftarget is not defined.")
+    end
+    @reftarget.add(name, node)
+  end
+
+  def encode_child(ns, child, parent)
+    indent_backup, @indent = @indent, @indent + @indentstr
+    encode_data(ns.clone_ns, child, parent)
+    @indent = indent_backup
+  end
+
+  def encode_element(ns, obj, parent)
+    attrs = obj.extraattr
+    if obj.is_a?(SOAPBody)
+      @reftarget = obj
+      obj.encode(self, ns, attrs) do |child|
+	indent_backup, @indent = @indent, @indent + @indentstr
+        encode_data(ns.clone_ns, child, obj)
+	@indent = indent_backup
+      end
+      @reftarget = nil
+    else
+      if obj.is_a?(SOAPEnvelope)
+        Generator.assign_ns(attrs, ns, XSD::InstanceNamespace)
+        Generator.assign_ns(attrs, ns, XSD::Namespace)
+      end
+      obj.encode(self, ns, attrs) do |child|
+	indent_backup, @indent = @indent, @indent + @indentstr
+        encode_data(ns.clone_ns, child, obj)
+	@indent = indent_backup
+      end
+    end
+  end
+
+  def encode_name(ns, data, attrs)
+    if element_local?(data)
+      data.elename.name
+    else
+      if @use_default_namespace
+        Generator.assign_ns(attrs, ns, data.elename.namespace, '')
+      else
+        Generator.assign_ns(attrs, ns, data.elename.namespace)
+      end
+      ns.name(data.elename)
+    end
+  end
+
+  def encode_name_end(ns, data)
+    if element_local?(data)
+      data.elename.name
+    else
+      ns.name(data.elename)
+    end
+  end
+
+  def encode_tag(elename, attrs = nil)
+    if attrs.nil? or attrs.empty?
+      @buf << "\n#{ @indent }<#{ elename }>"
+      return 
+    end
+    ary = []
+    attrs.each do |key, value|
+      ary << %Q[#{ key }="#{ get_encoded(value.to_s) }"]
+    end
+    case ary.size
+    when 0
+      @buf << "\n#{ @indent }<#{ elename }>"
+    when 1
+      @buf << %Q[\n#{ @indent }<#{ elename } #{ ary[0] }>]
+    else
+      @buf << "\n#{ @indent }<#{ elename } " <<
+        ary.join("\n#{ @indent }#{ @indentstr * 2 }") <<
+	'>'
+    end
+  end
+
+  def encode_tag_end(elename, cr = nil)
+    if cr
+      @buf << "\n#{ @indent }</#{ elename }>"
+    else
+      @buf << "</#{ elename }>"
+    end
+  end
+
+  def encode_rawstring(str)
+    @buf << str
+  end
+
+  def encode_string(str)
+    @buf << get_encoded(str)
+  end
+
+  def element_local?(element)
+    element.elename.namespace.nil?
+  end
+
+  def self.assign_ns(attrs, ns, namespace, tag = nil)
+    if namespace.nil?
+      raise FormatEncodeError.new("empty namespace")
+    end
+    override_default_ns = (tag == '' and namespace != ns.default_namespace)
+    if override_default_ns or !ns.assigned?(namespace)
+      assign_ns!(attrs, ns, namespace, tag)
+    end
+  end
+
+  def self.assign_ns!(attrs, ns, namespace, tag = nil)
+    tag = ns.assign(namespace, tag)
+    if tag == ''
+      attr = 'xmlns'
+    else
+      attr = "xmlns:#{tag}"
+    end
+    attrs[attr] = namespace
+  end
+
+private
+
+  def prologue
+  end
+
+  def epilogue
+  end
+
+  ENCODE_CHAR_REGEXP = {}
+
+  EncodeMap = {
+    '&' => '&amp;',
+    '<' => '&lt;',
+    '>' => '&gt;',
+    '"' => '&quot;',
+    '\'' => '&apos;',
+    "\r" => '&#xd;'
+  }
+
+  def get_encoded(str)
+    if @use_numeric_character_reference and !XSD::Charset.is_us_ascii(str)
+      str.gsub!(@encode_char_regexp) { |c| EncodeMap[c] }
+      str.unpack("U*").collect { |c|
+        if c == 0x9 or c == 0xa or c == 0xd or (c >= 0x20 and c <= 0x7f)
+          c.chr
+        else
+          sprintf("&#x%x;", c)
+        end
+      }.join
+    else
+      str.gsub(@encode_char_regexp) { |c| EncodeMap[c] }
+    end
+  end
+
+  def get_encode_char_regexp
+    ENCODE_CHAR_REGEXP[XSD::Charset.encoding] ||= Regexp.new("[#{EncodeMap.keys.join}]", nil, (RUBY_VERSION.to_f >= 1.9) ? 'n' : XSD::Charset.encoding) # RubyJedi: compatible with Ruby 1.8.6 and above
+  end
+
+  def find_handler(encodingstyle)
+    unless @handlers.key?(encodingstyle)
+      factory = SOAP::EncodingStyle::Handler.handler(encodingstyle)
+      if factory
+        handler = factory.new(@charset)
+        handler.generate_explicit_type = @generate_explicit_type
+        handler.encode_prologue
+        @handlers[encodingstyle] = handler
+      end
+    end
+    @handlers[encodingstyle]
+  end
+
+  def xmldecl
+    if @charset
+      %Q[<?xml version="1.0" encoding="#{ @charset }" ?>]
+    else
+      %Q[<?xml version="1.0" ?>]
+    end
+  end
+end
+
+
+end

data/lib/soap/header/handler.rb

@@ -0,0 +1,62 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP Header handler item
+# 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 'soap/element'
+
+
+module SOAP
+module Header
+
+
+class Handler
+  attr_reader :elename
+  attr_accessor :mustunderstand
+  attr_reader :encodingstyle
+  attr_reader :target_actor
+
+  def initialize(elename)
+    @elename = elename
+    @mustunderstand = false
+    @encodingstyle = nil
+    @target_actor = nil
+  end
+
+  # Should return a SOAP/OM, a SOAPHeaderItem or nil.
+  def on_outbound
+    nil
+  end
+
+  # Given header is a SOAPHeaderItem or nil.
+  def on_inbound(header, mustunderstand = false)
+    # do something.
+  end
+
+  def on_outbound_headeritem(header)
+    arity = self.method(:on_outbound).arity
+    item = (arity == 0) ? on_outbound : on_outbound(header)
+    if item.nil?
+      nil
+    elsif item.is_a?(::SOAP::SOAPHeaderItem)
+      item.elename = @elename
+      item
+    else
+      item.elename = @elename
+      ::SOAP::SOAPHeaderItem.new(item, @mustunderstand, @encodingstyle,
+        @target_actor)
+    end
+  end
+
+  def on_inbound_headeritem(header, item)
+    on_inbound(item.element, item.mustunderstand)
+  end
+end
+
+
+end
+end

data/lib/soap/header/handlerset.rb

@@ -0,0 +1,71 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP Header handler set
+# 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/namedelements'
+
+
+module SOAP
+module Header
+
+
+class HandlerSet
+  def initialize
+    @store = XSD::NamedElements.new
+  end
+
+  def dup
+    obj = HandlerSet.new
+    obj.store = @store.dup
+    obj
+  end
+
+  def add(handler)
+    @store << handler
+  end
+  alias << add
+
+  def delete(handler)
+    @store.delete(handler)
+  end
+
+  def include?(handler)
+    @store.include?(handler)
+  end
+
+  # returns: Array of SOAPHeaderItem
+  def on_outbound(header)
+    @store.collect { |handler|
+      handler.on_outbound_headeritem(header)
+    }.compact
+  end
+
+  # header: SOAPHeaderItem enumerable object
+  def on_inbound(header)
+    header.each do |name, item|
+      handler = @store.find { |handler|
+        handler.elename == item.element.elename
+      }
+      if handler
+        handler.on_inbound_headeritem(header, item)
+      elsif item.mustunderstand
+        raise UnhandledMustUnderstandHeaderError.new(item.element.elename.to_s)
+      end
+    end
+  end
+
+protected
+
+  def store=(store)
+    @store = store
+  end
+end
+
+
+end
+end

data/lib/soap/header/mappinghandler.rb

@@ -0,0 +1,48 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP Mapping header item handler
+# 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 'soap/header/handler'
+require 'soap/mapping/mapping'
+
+
+module SOAP
+module Header
+
+
+class MappingHandler < SOAP::Header::Handler
+  attr_accessor :registry
+
+  def initialize(elename, registry = nil)
+    super(elename)
+    @registry = registry
+  end
+
+  # Should return an Object for mapping
+  def on_mapping_outbound
+    nil
+  end
+
+  # Given header is a mapped Object
+  def on_mapping_inbound(obj, mustunderstand)
+  end
+
+  def on_outbound
+    obj = on_mapping_outbound
+    obj ? SOAP::Mapping.obj2soap(obj, @registry, @elename) : nil
+  end
+
+  def on_inbound(header, mustunderstand)
+    obj = SOAP::Mapping.soap2obj(header, @registry)
+    on_mapping_inbound(obj, mustunderstand)
+  end
+end
+
+
+end
+end

data/lib/soap/header/simplehandler.rb

@@ -0,0 +1,45 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP Simple header item handler
+# 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 'soap/header/handler'
+require 'soap/baseData'
+
+
+module SOAP
+module Header
+
+
+class SimpleHandler < SOAP::Header::Handler
+  def initialize(elename)
+    super(elename)
+  end
+
+  # Should return a Hash, String or nil.
+  def on_simple_outbound
+    nil
+  end
+
+  # Given header is a Hash, String or nil.
+  def on_simple_inbound(header, mustunderstand)
+  end
+
+  def on_outbound
+    h = on_simple_outbound
+    h ? SOAPElement.from_obj(h, elename.namespace) : nil
+  end
+
+  def on_inbound(header, mustunderstand)
+    h = header.respond_to?(:to_obj) ? header.to_obj : header.data
+    on_simple_inbound(h, mustunderstand)
+  end
+end
+
+
+end
+end

data/lib/soap/httpconfigloader.rb

@@ -0,0 +1,140 @@
+# encoding: ASCII-8BIT
+# SOAP4R - HTTP config loader.
+# 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 'soap/property'
+
+
+module SOAP
+
+
+module HTTPConfigLoader
+module_function
+
+  def set_options(client, options)
+    client.proxy = options["proxy"]
+    options.add_hook("proxy") do |key, value|
+      client.proxy = value
+    end
+    client.no_proxy = options["no_proxy"]
+    options.add_hook("no_proxy") do |key, value|
+      client.no_proxy = value
+    end
+    if client.respond_to?(:protocol_version=)
+      client.protocol_version = options["protocol_version"]
+      options.add_hook("protocol_version") do |key, value|
+        client.protocol_version = value
+      end
+    end
+    ssl_config = options["ssl_config"] ||= ::SOAP::Property.new
+    set_ssl_config(client, ssl_config)
+    ssl_config.add_hook(true) do |key, value|
+      set_ssl_config(client, ssl_config)
+    end
+    basic_auth = options["basic_auth"] ||= ::SOAP::Property.new
+    set_basic_auth(client, basic_auth)
+    basic_auth.add_hook do |key, value|
+      set_basic_auth(client, basic_auth)
+    end
+    auth = options["auth"] ||= ::SOAP::Property.new
+    set_auth(client, auth)
+    auth.add_hook do |key, value|
+      set_auth(client, auth)
+    end
+    options.add_hook("connect_timeout") do |key, value|
+      client.connect_timeout = value
+    end
+    options.add_hook("send_timeout") do |key, value|
+      client.send_timeout = value
+    end
+    options.add_hook("receive_timeout") do |key, value|
+      client.receive_timeout = value
+    end
+  end
+
+  def set_basic_auth(client, basic_auth)
+    basic_auth.values.each do |ele|
+      client.set_basic_auth(*authele_to_triplets(ele))
+    end
+  end
+
+  def set_auth(client, auth)
+    auth.values.each do |ele|
+      client.set_auth(*authele_to_triplets(ele))
+    end
+  end
+
+  def authele_to_triplets(ele)
+    if ele.is_a?(::Array)
+      url, userid, passwd = ele
+    else
+      url, userid, passwd = ele[:url], ele[:userid], ele[:password]
+    end
+    return url, userid, passwd
+  end
+
+  def set_ssl_config(client, ssl_config)
+    ssl_config.each do |key, value|
+      cfg = client.ssl_config
+      if cfg.nil?
+        raise NotImplementedError.new("SSL not supported")
+      end
+      case key
+      when 'client_cert'
+        cfg.client_cert = cert_from_file(value)
+      when 'client_key'
+        cfg.client_key = key_from_file(value)
+      when 'client_ca'
+        cfg.client_ca = value
+      when 'ca_path'
+        cfg.set_trust_ca(value)
+      when 'ca_file'
+        cfg.set_trust_ca(value)
+      when 'crl'
+        cfg.set_crl(value)
+      when 'verify_mode'
+        cfg.verify_mode = ssl_config_int(value)
+      when 'verify_depth'
+        cfg.verify_depth = ssl_config_int(value)
+      when 'options'
+        cfg.options = value
+      when 'ciphers'
+        cfg.ciphers = value
+      when 'verify_callback'
+        cfg.verify_callback = value
+      when 'cert_store'
+        cfg.cert_store = value
+      else
+        raise ArgumentError.new("unknown ssl_config property #{key}")
+      end
+    end
+  end
+
+  def ssl_config_int(value)
+    if value.nil? or value.to_s.empty?
+      nil
+    else
+      begin
+        Integer(value)
+      rescue ArgumentError
+        ::SOAP::Property::Util.const_from_name(value.to_s)
+      end
+    end
+  end
+
+  def cert_from_file(filename)
+    OpenSSL::X509::Certificate.new(File.open(filename) { |f| f.read })
+  end
+
+  def key_from_file(filename)
+    OpenSSL::PKey::RSA.new(File.open(filename) { |f| f.read })
+  end
+end
+
+
+end