mumboe-soap4r 1.5.8.2

data/lib/soap/mapping/wsdlliteralregistry.rb

@@ -0,0 +1,248 @@
+# SOAP4R - WSDL literal mapping registry.
+# 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/baseData'
+require 'soap/mapping/mapping'
+require 'soap/mapping/literalregistry'
+require 'soap/mapping/typeMap'
+require 'xsd/codegen/gensupport'
+require 'xsd/namedelements'
+
+
+module SOAP
+module Mapping
+
+
+class WSDLLiteralRegistry < LiteralRegistry
+  attr_reader :definedelements
+  attr_reader :definedtypes
+
+  def initialize(definedtypes = XSD::NamedElements::Empty,
+      definedelements = XSD::NamedElements::Empty)
+    super()
+    @definedtypes = definedtypes
+    @definedelements = definedelements
+  end
+
+  def obj2soap(obj, qname, obj_class = nil)
+    soap_obj = nil
+    if obj.is_a?(SOAPElement)
+      soap_obj = obj
+    elsif eledef = @definedelements[qname]
+      soap_obj = obj2elesoap(obj, eledef)
+    elsif type = @definedtypes[qname]
+      soap_obj = obj2typesoap(obj, type)
+    else
+      soap_obj = any2soap(obj, qname, obj_class)
+    end
+    return soap_obj if soap_obj
+    if @excn_handler_obj2soap
+      soap_obj = @excn_handler_obj2soap.call(obj) { |yield_obj|
+        Mapping.obj2soap(yield_obj, nil, nil, MAPPING_OPT)
+      }
+      return soap_obj if soap_obj
+    end
+    raise MappingError.new("cannot map #{obj.class.name} as #{qname}")
+  end
+
+  # node should be a SOAPElement
+  def soap2obj(node, obj_class = nil)
+    cause = nil
+    begin
+      return any2obj(node, obj_class)
+    rescue MappingError
+      cause = $!
+    end
+    if @excn_handler_soap2obj
+      begin
+        return @excn_handler_soap2obj.call(node) { |yield_node|
+	    Mapping.soap2obj(yield_node, nil, nil, MAPPING_OPT)
+	  }
+      rescue Exception
+      end
+    end
+    if node.respond_to?(:type)
+      raise MappingError.new("cannot map #{node.type.name} to Ruby object", cause)
+    else
+      raise MappingError.new("cannot map #{node.elename.name} to Ruby object", cause)
+    end
+  end
+
+private
+
+  def obj2elesoap(obj, eledef)
+    ele = nil
+    qualified = (eledef.elementform == 'qualified')
+    if obj.is_a?(SOAPNil)
+      ele = obj
+    elsif eledef.type
+      if type = @definedtypes[eledef.type]
+        ele = obj2typesoap(obj, type)
+      elsif type = TypeMap[eledef.type]
+        ele = base2soap(obj, type)
+      else
+        raise MappingError.new("cannot find type #{eledef.type}")
+      end
+    elsif eledef.local_complextype
+      ele = obj2typesoap(obj, eledef.local_complextype)
+    elsif eledef.local_simpletype
+      ele = obj2typesoap(obj, eledef.local_simpletype)
+    else
+      raise MappingError.new('illegal schema?')
+    end
+    ele.elename = eledef.name
+    ele.qualified = qualified
+    ele
+  end
+
+  def obj2typesoap(obj, type)
+    ele = nil
+    if type.is_a?(::WSDL::XMLSchema::SimpleType)
+      ele = simpleobj2soap(obj, type)
+    else # complexType
+      if type.simplecontent
+        ele = simpleobj2soap(obj, type.simplecontent)
+      else
+        ele = complexobj2soap(obj, type)
+      end
+      ele.type = type.name
+      if type.base or Mapping.root_type_hint
+        Mapping.reset_root_type_hint
+        ele.force_typed = true
+      end
+      add_definedattributes2soap(obj, ele, type)
+    end
+    ele
+  end
+
+  def simpleobj2soap(obj, type)
+    type.check_lexical_format(obj)
+    return SOAPNil.new if obj.nil?
+    if type.base
+      ele = base2soap(obj, TypeMap[type.base])
+    elsif type.list
+      value = obj.is_a?(Array) ? obj.join(" ") : obj.to_s
+      ele = base2soap(value, SOAP::SOAPString)
+    else
+      raise MappingError.new("unsupported simpleType: #{type}")
+    end
+    ele
+  end
+
+  def complexobj2soap(obj, type)
+    ele = SOAPElement.new(type.name)
+    complexobj2sequencesoap(obj, ele, type, type.choice?, type.choice?)
+    ele
+  end
+
+  def complexobj2sequencesoap(obj, soap, type, nillable, is_choice)
+    added = false
+    type.elements.each do |child_ele|
+      case child_ele
+      when WSDL::XMLSchema::Any
+        any = Mapping.get_attributes_for_any(obj)
+        SOAPElement.from_objs(any).each do |child|
+          soap.add(child)
+        end
+        ele_added = true
+      when WSDL::XMLSchema::Element
+        ele_added = complexobj2soapchildren(obj, soap, child_ele, nillable)
+      when WSDL::XMLSchema::Sequence
+        ele_added = complexobj2sequencesoap(obj, soap, child_ele, nillable, false)
+      when WSDL::XMLSchema::Choice
+        ele_added = complexobj2sequencesoap(obj, soap, child_ele, true, true)
+      else
+        raise MappingError.new("unknown type: #{child_ele}")
+      end
+      added = true if ele_added
+      break if is_choice and ele_added
+    end
+    added
+  end
+
+  def complexobj2soapchildren(obj, soap, child_ele, nillable = false)
+    if child_ele.map_as_array?
+      complexobj2soapchildren_array(obj, soap, child_ele, nillable)
+    else
+      complexobj2soapchildren_single(obj, soap, child_ele, nillable)
+    end
+  end
+
+  def complexobj2soapchildren_array(obj, soap, child_ele, nillable)
+    child = Mapping.get_attribute(obj, child_ele.name.name)
+    if child.nil? and obj.is_a?(::Array)
+      child = obj
+    end
+    if child.nil?
+      return false if nillable
+      if child_soap = nil2soap(child_ele)
+        soap.add(child_soap)
+        return true
+      else
+        return false
+      end
+    end
+    unless child.respond_to?(:each)
+      return false
+    end
+    child.each do |item|
+      if item.is_a?(SOAPElement)
+        soap.add(item)
+      else
+        child_soap = obj2elesoap(item, child_ele)
+        soap.add(child_soap)
+      end
+    end
+    true
+  end
+
+  def complexobj2soapchildren_single(obj, soap, child_ele, nillable)
+    child = Mapping.get_attribute(obj, child_ele.name.name)
+    case child
+    when NilClass
+      return false if nillable
+      if child_soap = nil2soap(child_ele)
+        soap.add(child_soap)
+        true
+      else
+        false
+      end
+    when SOAPElement
+      soap.add(child)
+      true
+    else
+      child_soap = obj2elesoap(child, child_ele)
+      soap.add(child_soap)
+      true
+    end
+  end
+
+  def nil2soap(ele)
+    if ele.nillable
+      obj2elesoap(nil, ele)     # add an empty element
+    elsif ele.minoccurs == 0
+      nil       # intends no element
+    else
+      warn("nil not allowed: #{ele.name.name}")
+      nil
+    end
+  end
+
+  def add_definedattributes2soap(obj, ele, typedef)
+    if typedef.attributes
+      typedef.attributes.each do |at|
+        value = get_xmlattr_value(obj, at.name)
+        ele.extraattr[at.name] = value unless value.nil?
+      end
+    end
+  end
+end
+
+
+end
+end

data/lib/soap/marshal.rb

@@ -0,0 +1,59 @@
+# SOAP4R - Marshalling/Unmarshalling Ruby's object using SOAP Encoding.
+# 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/mapping"
+require "soap/processor"
+
+
+module SOAP
+
+
+module Marshal
+  # Trying xsd:dateTime data to be recovered as aTime.
+  MarshalMappingRegistry = Mapping::EncodedRegistry.new(
+    :allow_original_mapping => true)
+  MarshalMappingRegistry.add(
+    Time,
+    ::SOAP::SOAPDateTime,
+    ::SOAP::Mapping::EncodedRegistry::DateTimeFactory
+  )
+
+  class << self
+  public
+    def dump(obj, io = nil)
+      marshal(obj, MarshalMappingRegistry, io)
+    end
+
+    def load(stream)
+      unmarshal(stream, MarshalMappingRegistry)
+    end
+
+    def marshal(obj, mapping_registry = MarshalMappingRegistry, io = nil)
+      elename = Mapping.name2elename(obj.class.to_s)
+      soap_obj = Mapping.obj2soap(obj, mapping_registry)
+      body = SOAPBody.new
+      body.add(elename, soap_obj)
+      env = SOAPEnvelope.new(nil, body)
+      SOAP::Processor.marshal(env, {}, io)
+    end
+
+    def unmarshal(stream, mapping_registry = MarshalMappingRegistry)
+      env = SOAP::Processor.unmarshal(stream)
+      if env.nil?
+	raise ArgumentError.new("Illegal SOAP marshal format.")
+      end
+      Mapping.soap2obj(env.body.root_node, mapping_registry)
+    end
+  end
+end
+
+
+end
+
+
+SOAPMarshal = SOAP::Marshal

data/lib/soap/mimemessage.rb

@@ -0,0 +1,241 @@
+# 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.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