soap2r 1.5.8

data/lib/xsd/datatypes1999.rb

@@ -0,0 +1,20 @@
+# XSD4R - XML Schema Datatype 1999 support
+# 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'
+
+
+module XSD
+  Namespace.replace('http://www.w3.org/1999/XMLSchema')
+  InstanceNamespace.replace('http://www.w3.org/1999/XMLSchema-instance')
+  AnyTypeLiteral.replace('ur-type')
+  AnySimpleTypeLiteral.replace('ur-type')
+  NilLiteral.replace('null')
+  NilValue.replace('1')
+  DateTimeLiteral.replace('timeInstant')
+end

data/lib/xsd/iconvcharset.rb

@@ -0,0 +1,39 @@
+# XSD4R - Charset handling with iconv.
+# 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.
+
+unless ''.respond_to? :encode
+  require 'iconv'
+end
+
+module XSD
+
+
+class IconvCharset
+  if ''.respond_to? :encode
+    def self.safe_iconv(to, from, str)
+      str.encode(to, from, :invalid => :replace, :undef => :replace, :replace => '?')
+    end
+  else
+  def self.safe_iconv(to, from, str)
+    iconv = Iconv.new(to, from)
+    out = ""
+    begin
+      out << iconv.iconv(str)
+    rescue Iconv::IllegalSequence => e
+      out << e.success
+      ch, str = e.failed.split(//, 2)
+      out << '?'
+      warn("Failed to convert #{ch}")
+      retry
+    end
+    return out
+  end
+  end
+end
+
+
+end

data/lib/xsd/mapping.rb

@@ -0,0 +1,68 @@
+# XSD4R - XML Mapping for Ruby
+# 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/parser"
+require 'soap/encodingstyle/literalHandler'
+require "soap/generator"
+require "soap/mapping"
+require "soap/mapping/wsdlliteralregistry"
+
+
+module XSD
+
+
+module Mapping
+  MappingRegistry = SOAP::Mapping::LiteralRegistry.new
+
+  def self.obj2xml(obj, elename = nil, io = nil)
+    Mapper.new(MappingRegistry).obj2xml(obj, elename, io)
+  end
+
+  def self.xml2obj(stream, klass = nil)
+    Mapper.new(MappingRegistry).xml2obj(stream, klass)
+  end
+
+  class Mapper
+    MAPPING_OPT = {
+      :default_encodingstyle => SOAP::LiteralNamespace,
+      :generate_explicit_type => false,
+      :root_type_hint => true
+    }.freeze
+
+    def initialize(registry)
+      @registry = registry
+    end
+
+    def obj2xml(obj, elename = nil, io = nil)
+      opt = MAPPING_OPT.dup
+      unless elename
+        if definition = @registry.elename_schema_definition_from_class(obj.class)
+          elename = definition.elename
+          opt[:root_type_hint] = false
+        end
+      end
+      elename = SOAP::Mapping.to_qname(elename) if elename
+      soap = SOAP::Mapping.obj2soap(obj, @registry, elename, opt)
+      if soap.elename.nil? or soap.elename == XSD::QName::EMPTY
+        soap.elename =
+          XSD::QName.new(nil, SOAP::Mapping.name2elename(obj.class.to_s))
+      end
+      generator = SOAP::Generator.new(opt)
+      generator.generate(soap, io)
+    end
+
+    def xml2obj(stream, klass = nil)
+      parser = SOAP::Parser.new(MAPPING_OPT)
+      soap = parser.parse(stream)
+      SOAP::Mapping.soap2obj(soap, @registry, klass)
+    end
+  end
+end
+
+
+end

data/lib/xsd/namedelements.rb

@@ -0,0 +1,132 @@
+# XSD4R - WSDL named element collection.
+# 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 XSD
+
+
+class NamedElements
+  include Enumerable
+
+  def initialize
+    @elements = []
+    @cache = {}
+  end
+
+  def dup
+    o = NamedElements.new
+    o.elements = @elements.dup
+    o
+  end
+
+  def freeze
+    super
+    @elements.freeze
+    self
+  end
+
+  def empty?
+    size == 0
+  end
+
+  def size
+    @elements.size
+  end
+
+  def [](idx)
+    if idx.is_a?(Numeric)
+      @elements[idx]
+    else
+      @cache[idx] ||= @elements.find { |item| item.name == idx }
+    end
+  end
+
+  def find_name(name)
+    @elements.find { |item| item.name.name == name }
+  end
+
+  def keys
+    collect { |element| element.name }
+  end
+
+  def each
+    @elements.each do |element|
+      yield(element)
+    end
+  end
+
+  def <<(rhs)
+    @elements << rhs
+    self
+  end
+  
+  def delete(rhs)
+    rv = @elements.delete(rhs)
+    @cache.clear
+    rv
+  end
+
+  def +(rhs)
+    o = NamedElements.new
+    o.elements = @elements + rhs.elements
+    @cache.clear
+    o
+  end
+
+  def concat(rhs)
+    @elements.concat(rhs.elements)
+    @cache.clear
+    self
+  end
+
+  def uniq
+    o = NamedElements.new
+    o.elements = uniq_elements
+    o
+  end
+
+  def uniq!
+    @elements.replace(uniq_elements)
+    @cache.clear
+  end
+
+  def find_all
+    o = NamedElements.new
+    each do |ele|
+      o << ele if yield(ele)
+    end
+    o
+  end
+
+  Empty = NamedElements.new.freeze
+
+protected
+
+  def elements=(rhs)
+    @elements = rhs
+  end
+
+  def elements
+    @elements
+  end
+
+private
+
+  def uniq_elements
+    dict = {}
+    elements = []
+    @elements.each do |ele|
+      unless dict.key?(ele.name)
+        dict[ele.name] = ele
+        elements << ele
+      end
+    end
+    elements
+  end
+end
+
+end

data/lib/xsd/ns.rb

@@ -0,0 +1,182 @@
+# XSD4R - XML Schema 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'
+
+
+module XSD
+
+
+class NS
+  Namespace = 'http://www.w3.org/XML/1998/namespace'
+
+  KNOWN_TAG = {
+    XSD::Namespace => 'xsd',
+    XSD::InstanceNamespace => 'xsi',
+  }
+
+  class Assigner
+    attr_reader :known_tag
+
+    def initialize(known_tag)
+      @known_tag = known_tag.dup
+      @count = 0
+    end
+
+    def assign(ns)
+      if @known_tag.key?(ns)
+        return @known_tag[ns]
+      end
+      @count += 1
+      "n#{@count}"
+    end
+  end
+
+  attr_reader :default_namespace
+
+  class FormatError < Error; end
+
+public
+
+  def initialize(tag2ns = nil)
+    @tag2ns = tag2ns || ns_default
+    @ns2tag = @tag2ns.invert
+    @assigner = nil
+    @default_namespace = nil
+  end
+
+  def known_tag
+    @assigner ||= Assigner.new(default_known_tag)
+    @assigner.known_tag
+  end
+
+  def assign(ns, tag = nil)
+    if tag == ''
+      if ns.empty?
+        @default_namespace = nil
+      else
+        @default_namespace = ns
+      end
+      tag
+    else
+      @assigner ||= Assigner.new(default_known_tag)
+      tag ||= @assigner.assign(ns)
+      @ns2tag[ns] = tag
+      @tag2ns[tag] = ns
+      tag
+    end
+  end
+
+  def assigned?(ns)
+    @default_namespace == ns or @ns2tag.key?(ns)
+  end
+
+  def assigned_as_tagged?(ns)
+    @ns2tag.key?(ns)
+  end
+
+  def assigned_tag?(tag)
+    @tag2ns.key?(tag)
+  end
+
+  def clone_ns
+    cloned = self.class.new(@tag2ns.dup)
+    cloned.assigner = @assigner
+    cloned.assign(@default_namespace, '') if @default_namespace
+    cloned
+  end
+
+  def name(qname)
+    if qname.namespace == @default_namespace
+      qname.name
+    elsif tag = @ns2tag[qname.namespace]
+      "#{tag}:#{qname.name}"
+    else
+      raise FormatError.new("namespace: #{qname.namespace} not defined yet")
+    end
+  end
+
+  # no default namespace
+  def name_attr(qname)
+    if tag = @ns2tag[qname.namespace]
+      "#{tag}:#{qname.name}"
+    else
+      raise FormatError.new("namespace: #{qname.namespace} not defined yet")
+    end
+  end
+
+  def compare(ns, name, rhs)
+    if (ns == @default_namespace)
+      return true if (name == rhs)
+    end
+    @tag2ns.each do |assigned_tag, assigned_ns|
+      if assigned_ns == ns && "#{assigned_tag}:#{name}" == rhs
+	return true
+      end
+    end
+    false
+  end
+
+  # $1 and $2 are necessary.
+  ParseRegexp = Regexp.new('\A([^:]+)(?::(.+))?\z', nil, 'NONE')
+
+  def parse(str, local = false)
+    if ParseRegexp =~ str
+      if (name = $2) and (ns = @tag2ns[$1])
+        return XSD::QName.new(ns, name)
+      end
+    end
+    XSD::QName.new(local ? nil : @default_namespace, str)
+  end
+
+  # For local attribute key parsing
+  #   <foo xmlns="urn:a" xmlns:n1="urn:a" bar="1" n1:baz="2" />
+  #     =>
+  #   {}bar, {urn:a}baz
+  def parse_local(elem)
+    ParseRegexp =~ elem
+    if $2
+      ns = @tag2ns[$1]
+      name = $2
+      if !ns
+	raise FormatError.new("unknown namespace qualifier: #{$1}")
+      end
+    elsif $1
+      ns = nil
+      name = $1
+    else
+      raise FormatError.new("illegal element format: #{elem}")
+    end
+    XSD::QName.new(ns, name)
+  end
+
+  def each_ns
+    @ns2tag.each do |ns, tag|
+      yield(ns, tag)
+    end
+  end
+
+protected
+
+  def assigner=(assigner)
+    @assigner = assigner
+  end
+
+private
+
+  def ns_default
+    {'xml' => Namespace}
+  end
+
+  def default_known_tag
+    KNOWN_TAG
+  end
+end
+
+
+end

data/lib/xsd/qname.rb

@@ -0,0 +1,79 @@
+# XSD4R - XML QName definition.
+# 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 XSD
+
+
+class QName
+  attr_reader :namespace
+  attr_reader :name
+  attr_accessor :source
+
+  def initialize(namespace = nil, name = nil)
+    @namespace = namespace
+    @name = name
+    @source = nil
+  end
+
+  def dup_name(name)
+    XSD::QName.new(@namespace, name)
+  end
+
+  def dump(predefined_ns = nil)
+    ns = predefined_ns
+    ns ||= @namespace.nil? ? 'nil' : @namespace.dump
+    name = @name.nil? ? 'nil' : @name.dump
+    "XSD::QName.new(#{ns}, #{name})"
+  end
+
+  def match(rhs)
+    if rhs.namespace and (rhs.namespace != @namespace)
+      return false
+    end
+    if rhs.name and (rhs.name != @name)
+      return false
+    end
+    true
+  end
+
+  def ==(rhs)
+    !rhs.nil? and @namespace == rhs.namespace and @name == rhs.name
+  end
+
+  def ===(rhs)
+    (self == rhs)
+  end
+
+  def eql?(rhs)
+    (self == rhs)
+  end
+
+  def hash
+    @namespace.hash ^ @name.hash
+  end
+  
+  def to_s
+    "{#{ namespace }}#{ name }"
+  end
+
+  def inspect
+    sprintf("#<%s:0x%x %s>", self.class.name, __id__,
+      "{#{ namespace }}#{ name }")
+  end
+
+  NormalizedNameRegexp = /^\{([^}]*)\}(.*)$/
+  def parse(str)
+    NormalizedNameRegexp =~ str
+    self.new($1, $2)
+  end
+
+  EMPTY = QName.new.freeze
+end
+
+
+end