ruby_on_ruby 0.0.1

data/vendor/javascripts/emscripted-ruby/lib/soap/generator.rb

@@ -0,0 +1,268 @@
+# SOAP4R - SOAP XML Instance Generator library.
+# Copyright (C) 2001, 2003, 2005  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/ns'
+require 'soap/soap'
+require 'soap/baseData'
+require 'soap/encodingstyle/handler'
+
+
+module SOAP
+
+
+###
+## CAUTION: MT-unsafe
+#
+class SOAPGenerator
+  include SOAP
+
+  class FormatEncodeError < Error; end
+
+public
+
+  attr_accessor :charset
+  attr_accessor :default_encodingstyle
+  attr_accessor :generate_explicit_type
+  attr_accessor :use_numeric_character_reference
+
+  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
+    @elementformdefault = opt[:elementformdefault]
+    @attributeformdefault = opt[:attributeformdefault]
+    @use_numeric_character_reference = opt[:use_numeric_character_reference]
+    @indentstr = opt[:no_indent] ? '' : '  '
+    @buf = @indent = @curr = nil
+  end
+
+  def generate(obj, io = nil)
+    @buf = io || ''
+    @indent = ''
+
+    prologue
+    @handlers.each do |uri, handler|
+      handler.encode_prologue
+    end
+
+    ns = XSD::NS.new
+    @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.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 = {}
+    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)
+        # xsi:nil="true" can appear even if dumping without explicit type.
+        SOAPGenerator.assign_ns(attrs, ns,
+	  XSD::InstanceNamespace, XSINamespaceTag)
+        if @generate_explicit_type
+          SOAPGenerator.assign_ns(attrs, ns, XSD::Namespace, XSDNamespaceTag)
+        end
+      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 element_qualified?(data)
+        SOAPGenerator.assign_ns(attrs, ns, data.elename.namespace, '')
+      else
+        SOAPGenerator.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 or attrs.empty?
+      @buf << "\n#{ @indent }<#{ elename }>"
+    elsif attrs.size == 1
+      key, value = attrs.shift
+      @buf << %Q[\n#{ @indent }<#{ elename } #{ key }="#{ value }">]
+    else
+      @buf << "\n#{ @indent }<#{ elename } " <<
+        attrs.collect { |key, value|
+          %Q[#{ key }="#{ value }"]
+        }.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
+
+  EncodeMap = {
+    '&' => '&amp;',
+    '<' => '&lt;',
+    '>' => '&gt;',
+    '"' => '&quot;',
+    '\'' => '&apos;',
+    "\r" => '&#xd;'
+  }
+  EncodeCharRegexp = Regexp.new("[#{EncodeMap.keys.join}]")
+  def encode_string(str)
+    if @use_numeric_character_reference and !XSD::Charset.is_us_ascii(str)
+      str.gsub!(EncodeCharRegexp) { |c| EncodeMap[c] }
+      @buf << 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
+      @buf << str.gsub(EncodeCharRegexp) { |c| EncodeMap[c] }
+    end
+  end
+
+  def element_local?(element)
+    element.elename.namespace.nil?
+  end
+
+  def element_qualified?(element)
+    if element.respond_to?(:qualified)
+      if element.qualified.nil?
+        @elementformdefault
+      else
+        element.qualified
+      end
+    else
+      @elementformdefault
+    end
+  end
+
+  def self.assign_ns(attrs, ns, namespace, tag = nil)
+    if namespace.nil?
+      raise FormatEncodeError.new("empty namespace")
+    end
+    unless ns.assigned?(namespace)
+      tag = ns.assign(namespace, tag)
+      if tag == ''
+        attr = 'xmlns'
+      else
+        attr = "xmlns:#{tag}"
+      end
+      attrs[attr] = namespace
+    end
+  end
+
+private
+
+  def prologue
+  end
+
+  def epilogue
+  end
+
+  def find_handler(encodingstyle)
+    unless @handlers.key?(encodingstyle)
+      handler = SOAP::EncodingStyle::Handler.handler(encodingstyle).new(@charset)
+      handler.generate_explicit_type = @generate_explicit_type
+      handler.encode_prologue
+      @handlers[encodingstyle] = handler
+    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/vendor/javascripts/emscripted-ruby/lib/soap/header/handler.rb

@@ -0,0 +1,57 @@
+# SOAP4R - SOAP Header handler item
+# Copyright (C) 2003, 2003  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_reader :mustunderstand
+  attr_reader :encodingstyle
+
+  def initialize(elename)
+    @elename = elename
+    @mustunderstand = false
+    @encodingstyle = 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
+    item = on_outbound
+    if item.nil?
+      nil
+    elsif item.is_a?(::SOAP::SOAPHeaderItem)
+      item.elename = @elename
+      item
+    else
+      item.elename = @elename
+      ::SOAP::SOAPHeaderItem.new(item, @mustunderstand, @encodingstyle)
+    end
+  end
+
+  def on_inbound_headeritem(header)
+    on_inbound(header.element, header.mustunderstand)
+  end
+end
+
+
+end
+end

data/vendor/javascripts/emscripted-ruby/lib/soap/header/handlerset.rb

@@ -0,0 +1,70 @@
+# SOAP4R - SOAP Header handler set
+# Copyright (C) 2003, 2004  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
+    @store.collect { |handler|
+      handler.on_outbound_headeritem
+    }.compact
+  end
+
+  # headers: SOAPHeaderItem enumerable object
+  def on_inbound(headers)
+    headers.each do |name, item|
+      handler = @store.find { |handler|
+        handler.elename == item.element.elename
+      }
+      if handler
+        handler.on_inbound_headeritem(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/vendor/javascripts/emscripted-ruby/lib/soap/header/simplehandler.rb

@@ -0,0 +1,44 @@
+# SOAP4R - SOAP Simple header item handler
+# Copyright (C) 2003-2005  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/vendor/javascripts/emscripted-ruby/lib/soap/httpconfigloader.rb

@@ -0,0 +1,119 @@
+# SOAP4R - HTTP config loader.
+# Copyright (C) 2005  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
+    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 |url, userid, passwd|
+      client.set_basic_auth(url, userid, passwd)
+    end
+  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