soap4r-sgonyea 1.5.9

data/lib/soap/processor.rb

@@ -0,0 +1,67 @@
+# encoding: ASCII-8BIT
+# SOAP4R - marshal/unmarshal interface.
+# 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 'soap/soap'
+require 'soap/element'
+require 'soap/parser'
+require 'soap/generator'
+require 'soap/encodingstyle/soapHandler'
+require 'soap/encodingstyle/literalHandler'
+require 'soap/encodingstyle/aspDotNetHandler'
+
+
+module SOAP
+
+
+module Processor
+  @@default_parser_option = {}
+
+  class << self
+  public
+
+    def marshal(env, opt = {}, io = nil)
+      generator = create_generator(opt)
+      marshalled_str = generator.generate(env, io)
+      unless env.external_content.empty?
+	opt[:external_content] = env.external_content
+      end
+      marshalled_str
+    end
+
+    def unmarshal(stream, opt = {})
+      parser = create_parser(opt)
+      parser.parse(stream)
+    end
+
+    def default_parser_option=(rhs)
+      @@default_parser_option = rhs
+    end
+
+    def default_parser_option
+      @@default_parser_option
+    end
+
+  private
+
+    def create_generator(opt)
+      Generator.new(opt)
+    end
+
+    def create_parser(opt)
+      if opt.empty?
+	opt = @@default_parser_option
+      end
+      ::SOAP::Parser.new(opt)
+    end
+  end
+end
+
+
+end

data/lib/soap/property.rb

@@ -0,0 +1,340 @@
+# encoding: ASCII-8BIT
+# soap/property.rb: SOAP4R - Property 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
+
+
+# Property stream format:
+#
+#   line separator is \r?\n.  1 line per a property.
+#   line which begins with '#' is a comment line.  empty line is ignored, too.
+#   key/value separator is ':' or '='.
+#   '\' as escape character.  but line separator cannot be escaped.
+#   \s at the head/tail of key/value are trimmed.
+#
+#   '[' + key + ']' indicates property section.  for example,
+#
+#     [aaa.bbb]
+#     ccc = ddd
+#     eee.fff = ggg
+#     []
+#     aaa.hhh = iii
+#
+#   is the same as;
+#
+#     aaa.bbb.ccc = ddd
+#     aaa.bbb.eee.fff = ggg
+#     aaa.hhh = iii
+#
+class Property
+  FrozenError = (RUBY_VERSION >= "1.9.0") ? RuntimeError : TypeError
+
+  include Enumerable
+
+  module Util
+    def const_from_name(fqname)
+      fqname.split("::").inject(Kernel) { |klass, name| klass.const_get(name) }
+    end
+    module_function :const_from_name
+
+    def require_from_name(fqname)
+      require File.join(fqname.split("::").collect { |ele| ele.downcase })
+    end
+    module_function :require_from_name
+  end
+
+  def self.load(stream)
+    new.load(stream)
+  end
+
+  def self.loadproperty(propname)
+    new.loadproperty(propname)
+  end
+
+  def initialize
+    @store = Hash.new
+    @hook = Hash.new
+    @self_hook = Array.new
+    @locked = false
+  end
+
+  KEY_REGSRC = '([^=:\\\\]*(?:\\\\.[^=:\\\\]*)*)'
+  DEF_REGSRC = '\\s*' + KEY_REGSRC + '\\s*[=:]\\s*(.*)'
+  #COMMENT_REGEXP = Regexp.new('^(?:#.*|)$', nil, 'u')
+  #CATDEF_REGEXP = Regexp.new("^\\[\\s*#{KEY_REGSRC}\\s*\\]$", nil, 'u')
+  #LINE_REGEXP = Regexp.new("^#{DEF_REGSRC}$", nil, 'u')
+
+  COMMENT_REGEXP = Regexp.new('^(?:#.*|)$') # RubyJedi: Attempt at 1.9 Compatibility // , nil, 'u')
+  CATDEF_REGEXP = Regexp.new("^\\[\\s*#{KEY_REGSRC}\\s*\\]$") # RubyJedi: Attempt at 1.9 Compatibility // , nil, 'u')
+  LINE_REGEXP = Regexp.new("^#{DEF_REGSRC}$") # RubyJedi: Attempt at 1.9 Compatibility // , nil, 'u')
+  
+  def load(stream)
+    key_prefix = ""
+    stream = stream.lines if stream.respond_to?(:lines) # RubyJedi: compatible with Ruby 1.8.6 and above
+    stream.each_with_index do |line, lineno|
+      line.sub!(/\r?\n\z/u, '')
+      case line
+      when COMMENT_REGEXP
+	next
+      when CATDEF_REGEXP
+	key_prefix = $1.strip
+      when LINE_REGEXP
+	key, value = $1.strip, $2.strip
+	key = "#{key_prefix}.#{key}" unless key_prefix.empty?
+	key, value = loadstr(key), loadstr(value)
+	self[key] = value
+      else
+	raise TypeError.new(
+	  "property format error at line #{lineno + 1}: `#{line}'")
+      end
+    end
+    self
+  end
+
+  # find property from $:.
+  def loadproperty(propname)
+    return loadpropertyfile(propname) if File.file?(propname)
+    $:.each do |path|
+      if File.file?(file = File.join(path, propname))
+        return loadpropertyfile(file)
+      end
+    end
+    nil
+  end
+
+  # name: a Symbol, String or an Array
+  def [](name)
+    referent(name_to_a(name))
+  end
+
+  # name: a Symbol, String or an Array
+  # value: an Object
+  def []=(name, value)
+    name_pair = name_to_a(name).freeze
+    hooks = assign(name_pair, value)
+    hooks.each do |hook|
+      hook.call(name_pair, value)
+    end
+    value
+  end
+
+  # value: an Object
+  # key is generated by property
+  def <<(value)
+    self[generate_new_key] = value
+  end
+
+  # name: a Symbol, String or an Array; nil means hook to the root
+  # cascade: true/false; for cascading hook of sub key
+  # hook: block which will be called with 2 args, name and value
+  def add_hook(name = nil, cascade = false, &hook)
+    if name == nil or name == true or name == false
+      cascade = name
+      assign_self_hook(cascade, &hook)
+    else
+      assign_hook(name_to_a(name), cascade, &hook)
+    end
+  end
+
+  def each
+    @store.each do |key, value|
+      yield(key, value)
+    end
+  end
+
+  def empty?
+    @store.empty?
+  end
+
+  def keys
+    @store.keys
+  end
+
+  def values
+    @store.values
+  end
+
+  def lock(cascade = false)
+    if cascade
+      each_key do |key|
+	key.lock(cascade)
+      end
+    end
+    @locked = true
+    self
+  end
+
+  def unlock(cascade = false)
+    @locked = false
+    if cascade
+      each_key do |key|
+	key.unlock(cascade)
+      end
+    end
+    self
+  end
+
+  def locked?
+    @locked
+  end
+
+protected
+
+  def deref_key(key)
+    check_lock(key)
+    ref = @store[key] ||= self.class.new
+    unless propkey?(ref)
+      raise ArgumentError.new("key `#{key}' already defined as a value")
+    end
+    ref
+  end
+
+  def local_referent(key)
+    check_lock(key)
+    if propkey?(@store[key]) and @store[key].locked?
+      raise FrozenError.new("cannot split any key from locked property")
+    end
+    @store[key]
+  end
+
+  def local_assign(key, value)
+    check_lock(key)
+    if @locked
+      if propkey?(value)
+	raise FrozenError.new("cannot add any key to locked property")
+      elsif propkey?(@store[key])
+	raise FrozenError.new("cannot override any key in locked property")
+      end
+    end
+    @store[key] = value
+  end
+
+  def local_hook(key, direct)
+    hooks = []
+    (@self_hook + (@hook[key] || NO_HOOK)).each do |hook, cascade|
+      hooks << hook if direct or cascade
+    end
+    hooks
+  end
+
+  def local_assign_hook(key, cascade, &hook)
+    check_lock(key)
+    @store[key] ||= nil
+    (@hook[key] ||= []) << [hook, cascade]
+  end
+
+private
+
+  NO_HOOK = [].freeze
+
+  def referent(ary)
+    ary[0..-2].inject(self) { |ref, name|
+      ref.deref_key(to_key(name))
+    }.local_referent(to_key(ary.last))
+  end
+
+  def assign(ary, value)
+    ref = self
+    hook = NO_HOOK
+    ary[0..-2].each do |name|
+      key = to_key(name)
+      hook += ref.local_hook(key, false)
+      ref = ref.deref_key(key)
+    end
+    last_key = to_key(ary.last)
+    ref.local_assign(last_key, value)
+    hook + ref.local_hook(last_key, true)
+  end
+
+  def assign_hook(ary, cascade, &hook)
+    ary[0..-2].inject(self) { |ref, name|
+      ref.deref_key(to_key(name))
+    }.local_assign_hook(to_key(ary.last), cascade, &hook)
+  end
+
+  def assign_self_hook(cascade, &hook)
+    check_lock(nil)
+    @self_hook << [hook, cascade]
+  end
+
+  def each_key
+    self.each do |key, value|
+      if propkey?(value)
+	yield(value)
+      end
+    end
+  end
+
+  def check_lock(key)
+    if @locked and (key.nil? or !@store.key?(key))
+      raise FrozenError.new("cannot add any key to locked property")
+    end
+  end
+
+  def propkey?(value)
+    value.is_a?(::SOAP::Property)
+  end
+
+  def name_to_a(name)
+    case name
+    when Symbol
+      [name]
+    when String
+      name.scan(/[^.\\]+(?:\\.[^.\\])*/u)	# split with unescaped '.'
+    when Array
+      name
+    else
+      raise ArgumentError.new("Unknown name #{name}(#{name.class})")
+    end
+  end
+
+  def to_key(name)
+    name.to_s.downcase
+  end
+
+  def generate_new_key
+    if @store.empty?
+      "0"
+    else
+      (key_max + 1).to_s
+    end
+  end
+
+  def key_max
+    (@store.keys.max { |l, r| l.to_s.to_i <=> r.to_s.to_i }).to_s.to_i
+  end
+
+  def loadpropertyfile(file)
+    puts "find property at #{file}" if $DEBUG
+    File.open(file) do |f|
+      load(f)
+    end
+  end
+
+  def loadstr(str)
+    str.gsub(/\\./u) { |c| eval("\"#{c}\"") }
+  end
+end
+
+
+end
+
+
+# for ruby/1.6.
+#unless Enumerable.instance_methods.include?(:inject)
+#  module Enumerable
+#    def inject(init)
+#      result = init
+#      each do |item|
+#	result = yield(result, item)
+#      end
+#      result
+#    end
+#  end
+#end

data/lib/soap/proxy.rb

@@ -0,0 +1,15 @@
+# encoding: ASCII-8BIT
+# SOAP4R - Proxy 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/rpc/proxy'
+
+
+module SOAP
+  SOAPProxy = RPC::Proxy
+end

data/lib/soap/rpc/cgistub.rb

@@ -0,0 +1,248 @@
+# encoding: ASCII-8BIT
+# SOAP4R - CGI/mod_ruby stub 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/streamHandler'
+require 'webrick/httpresponse'
+require 'webrick/httpstatus'
+require 'logger'
+require 'soap/rpc/soaplet'
+
+
+module SOAP
+module RPC
+
+
+###
+# SYNOPSIS
+#   CGIStub.new
+#
+# DESCRIPTION
+#   To be written...
+#
+class CGIStub < Logger::Application
+  include SOAP
+  include WEBrick
+
+  class SOAPRequest
+    attr_reader :body
+
+    def [](var); end
+
+    def meta_vars; end
+
+    EMPTY_COOKIES = [].freeze
+    def cookies; EMPTY_COOKIES; end
+
+    def user; end
+  end
+
+  class SOAPStdinRequest < SOAPRequest
+    attr_reader :body
+
+    def initialize(stream)
+      size = ENV['CONTENT_LENGTH'].to_i || 0
+      @body = stream.read(size)
+    end
+
+    def [](var)
+      ENV[var.gsub(/-/, '_').upcase]
+    end
+
+    def meta_vars
+      {
+        'HTTP_SOAPACTION' => ENV['HTTP_SOAPAction']
+      }
+    end
+
+    def cookies
+      if cookie = ENV['HTTP_Cookie'] || ENV['Cookie']
+        [WEBrick::Cookie.parse(cookie)]
+      else
+        EMPTY_COOKIES
+      end
+    end
+
+    def user
+      ENV['REMOTE_USER']
+    end
+  end
+
+  class SOAPFCGIRequest < SOAPRequest
+    attr_reader :body
+
+    def initialize(request)
+      @request = request
+      @body = @request.in.read
+    end
+
+    def [](var)
+      @request.env[var.gsub(/-/, '_').upcase]
+    end
+
+    def meta_vars
+      {
+        'HTTP_SOAPACTION' => @request.env['HTTP_SOAPAction']
+      }
+    end
+
+    def cookies
+      if cookie = @request.env['HTTP_Cookie'] || @request.env['Cookie']
+        [WEBrick::Cookie.parse(cookie)]
+      else
+        EMPTY_COOKIES
+      end
+    end
+
+    def user
+      @request.env['REMOTE_USER']
+    end
+  end
+
+  def initialize(appname, default_namespace)
+    super(appname)
+    set_log(STDERR)
+    self.level = ERROR
+    @default_namespace = default_namespace
+    @remote_host = ENV['REMOTE_HOST'] || ENV['REMOTE_ADDR'] || 'unknown'
+    @router = ::SOAP::RPC::Router.new(self.class.name)
+    @soaplet = ::SOAP::RPC::SOAPlet.new(@router)
+    on_init
+  end
+  
+  def on_init
+    # do extra initialization in a derived class if needed.
+  end
+
+  def mapping_registry
+    @router.mapping_registry
+  end
+
+  def mapping_registry=(mapping_registry)
+    @router.mapping_registry = mapping_registry
+  end
+
+  def literal_mapping_registry
+    @router.literal_mapping_registry
+  end
+
+  def literal_mapping_registry=(literal_mapping_registry)
+    @router.literal_mapping_registry = literal_mapping_registry
+  end
+
+  def generate_explicit_type
+    @router.generate_explicit_type
+  end
+
+  def generate_explicit_type=(generate_explicit_type)
+    @router.generate_explicit_type = generate_explicit_type
+  end
+
+  # servant entry interface
+
+  def add_rpc_servant(obj, namespace = @default_namespace)
+    @router.add_rpc_servant(obj, namespace)
+  end
+  alias add_servant add_rpc_servant
+
+  def add_headerhandler(obj)
+    @router.add_headerhandler(obj)
+  end
+  alias add_rpc_headerhandler add_headerhandler
+
+  def filterchain
+    @router.filterchain
+  end
+
+  # method entry interface
+
+  def add_rpc_method(obj, name, *param)
+    add_rpc_method_with_namespace_as(@default_namespace, obj, name, name, *param)
+  end
+  alias add_method add_rpc_method
+
+  def add_rpc_method_as(obj, name, name_as, *param)
+    add_rpc_method_with_namespace_as(@default_namespace, obj, name, name_as, *param)
+  end
+  alias add_method_as add_rpc_method_as
+
+  def add_rpc_method_with_namespace(namespace, obj, name, *param)
+    add_rpc_method_with_namespace_as(namespace, obj, name, name, *param)
+  end
+  alias add_method_with_namespace add_rpc_method_with_namespace
+
+  def add_rpc_method_with_namespace_as(namespace, obj, name, name_as, *param)
+    qname = XSD::QName.new(namespace, name_as)
+    soapaction = nil
+    param_def = SOAPMethod.derive_rpc_param_def(obj, name, *param)
+    @router.add_rpc_operation(obj, qname, soapaction, name, param_def)
+  end
+  alias add_method_with_namespace_as add_rpc_method_with_namespace_as
+
+  def add_rpc_operation(receiver, qname, soapaction, name, param_def, opt = {})
+    @router.add_rpc_operation(receiver, qname, soapaction, name, param_def, opt)
+  end
+
+  def add_document_operation(receiver, soapaction, name, param_def, opt = {})
+    @router.add_document_operation(receiver, soapaction, name, param_def, opt)
+  end
+
+  def set_fcgi_request(request)
+    @fcgi = request
+  end
+
+private
+
+  HTTPVersion = WEBrick::HTTPVersion.new('1.0')       # dummy; ignored
+
+  def run
+    res = WEBrick::HTTPResponse.new({:HTTPVersion => HTTPVersion})
+    begin
+      @log.info { "received a request from '#{ @remote_host }'" }
+      if @fcgi
+        req = SOAPFCGIRequest.new(@fcgi)
+      else
+        req = SOAPStdinRequest.new($stdin)
+      end
+      @soaplet.do_POST(req, res)
+    rescue HTTPStatus::EOFError, HTTPStatus::RequestTimeout => ex
+      res.set_error(ex)
+    rescue HTTPStatus::Error => ex
+      res.set_error(ex)
+    rescue HTTPStatus::Status => ex
+      res.status = ex.code
+    rescue StandardError, NameError => ex # for Ruby 1.6
+      res.set_error(ex, true)
+    ensure
+      if defined?(MOD_RUBY)
+        r = Apache.request
+        r.status = res.status
+        r.content_type = res.content_type
+        r.send_http_header
+        buf = res.body
+      else
+        buf = ''
+        res.send_response(buf)
+        buf.sub!(/^[^\r]+\r\n/, '')       # Trim status line.
+      end
+      @log.debug { "SOAP CGI Response:\n#{ buf }" }
+      if @fcgi
+        @fcgi.out.print buf
+        @fcgi.finish
+        @fcgi = nil
+      else
+        print buf
+      end
+    end
+    0
+  end
+end
+
+
+end
+end