soap4r-ng 2.0.1

data/lib/xsd/xmlparser.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+# XSD4R - XML Instance parser 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/xmlparser/parser'
+
+ module XSD
+  module XMLParser
+
+    def create_parser(host, opt)
+      XSD::XMLParser::Parser.create_parser(host, opt)
+    end
+    module_function :create_parser
+
+    # $1 is necessary.
+    NSParseRegexp = Regexp.new('^xmlns:?(.*)$', nil)
+
+    def filter_ns(ns, attrs)
+      ns_updated = false
+      if attrs.nil? or attrs.empty?
+        return [ns, attrs]
+      end
+      newattrs = {}
+      attrs.each do |key, value|
+        if NSParseRegexp =~ key
+          unless ns_updated
+            ns = ns.clone_ns
+            ns_updated = true
+          end
+          # tag == '' means 'default namespace'
+          # value == '' means 'no default namespace'
+          tag = $1 || ''
+          ns.assign(value, tag)
+        else
+          newattrs[key] = value
+        end
+      end
+      return [ns, newattrs]
+    end
+    module_function :filter_ns
+
+  end
+end
+
+
+# Provide a means to CHOOSE a preferred XML Parser and loading-order, if multiple parser gems are available.
+if ENV.has_key?('SOAP4R_PARSERS')
+  parser_list = ENV['SOAP4R_PARSERS'].to_s.split(',')
+else
+  parser_list = [
+    'oxparser',     ## Uses its own C-Ruby Extension
+    'nokogiri',     ## Depends on LibXML2, LibXSLT, and ZLib
+    'libxmlparser', ## Depends on LibXML2 ; Thread-Safe ; Somewhat Broken re: Namespaces
+    # ----- Pure-Ruby Parsers Below ---- #
+    'ogaparser',    ## Pure-Ruby
+    'rexmlparser',  ## Pure-Ruby, this is the reference implementation.
+  ]
+end
+
+# Try to load XML processor.
+loaded = false
+parser_list.each do |name|
+  begin
+    require "xsd/xmlparser/#{name}"
+    # XXX: for a workaround of rubygems' require inconsistency
+    # XXX: MUST BE REMOVED IN THE FUTURE
+    raise LoadError unless XSD::XMLParser.constants.find { |c|
+      c.to_s.downcase == name
+    }
+    loaded = true
+    break
+  rescue LoadError
+  end
+end
+unless loaded
+  raise RuntimeError.new("XML processor module not found.")
+end

data/lib/xsd/xmlparser/libxmlparser.rb

@@ -0,0 +1,135 @@
+# encoding: UTF-8
+# XSD4R - XMLParser XML parser 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.
+
+### WIP, 2015-June-13:  
+###
+### LibXML drops namespaces on Elements *AND* Attributes, which makes it impossible
+### to correctly associate Namespaces on Namespace-Declared Element Attributes when
+### more than one namespace exists.
+###
+### This issue is evident when you run test/soap/test_cookie.rb
+###
+
+require 'libxml'
+
+module XSD
+module XMLParser
+
+
+class LibXMLParser < XSD::XMLParser::Parser
+  include ::LibXML::XML::SaxParser::Callbacks
+
+  def do_parse(string_or_readable)
+    # string = string_or_readable.respond_to?(:read) ? string_or_readable.read : string_or_readable
+
+    @charset = 'utf-8'
+    string = StringIO.new(string_or_readable)
+    parser = LibXML::XML::SaxParser.io(string)
+    parser.callbacks = self
+    parser.parse
+  end
+
+  ENTITY_REF_MAP = {
+    'lt' => '<',
+    'gt' => '>',
+    'amp' => '&',
+    'quot' => '"',
+    'apos' => '\''
+  }
+
+  #def on_internal_subset(name, external_id, system_id)
+  #  nil
+  #end
+
+  #def on_is_standalone()
+  #  nil
+  #end
+
+  #def on_has_internal_subset()
+  #  nil
+  #end
+
+  #def on_has_external_subset()
+  #  nil
+  #end
+
+  #def on_start_document()
+  #  nil
+  #end
+
+  #def on_end_document()
+  #  nil
+  #end
+
+  def on_start_element_ns (name, attr_hash, prefix, uri, namespaces)
+    prefixed_ns = attr_hash.merge(Hash[namespaces.map{|k,v| ["xmlns:#{k}",v]}])
+    if prefix.nil?
+      start_element(name, prefixed_ns)
+    else
+      start_element("#{prefix}:#{name}", prefixed_ns)
+    end
+  end
+
+  def on_end_element_ns (name, prefix, uri)
+    if prefix.nil?
+      end_element(name)
+    else
+      end_element("#{prefix}:#{name}")
+    end
+  end
+
+  def on_start_element (name, attr_hash)
+    # start_element(name, attr_hash)
+  end
+
+  def on_end_element(name)
+    # end_element(name)
+  end
+
+  def on_reference(name)
+    characters(ENTITY_REF_MAP[name])
+  end
+
+  def on_characters(chars)
+    characters(chars)
+  end
+
+  #def on_processing_instruction(target, data)
+  #  nil
+  #end
+
+  #def on_comment(msg)
+  #  nil
+  #end
+
+  def on_parser_warning(msg)
+    warn(msg)
+  end
+
+  def on_parser_error(msg)
+    raise ParseError.new(msg)
+  end
+
+  def on_parser_fatal_error(msg)
+    raise ParseError.new(msg)
+  end
+
+  def on_cdata_block(cdata)
+    characters(cdata)
+  end
+
+  def on_external_subset(name, external_id, system_id)
+    nil
+  end
+
+  add_factory(self)
+end
+
+
+end
+end

data/lib/xsd/xmlparser/nokogiriparser.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+# XSD4R - Nokogiri XML parser library.
+# Copyright (C) 2015 Laurence A. Lee <rubyjedi@gmail.com>
+
+# This program is copyrighted free software by Laurence A. Lee.  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 'nokogiri'
+
+module XSD
+module XMLParser
+
+class NokogiriParser < XSD::XMLParser::Parser
+  def do_parse(string_or_readable)
+    handler = NokoDocHandler.new(self)
+    parser = Nokogiri::XML::SAX::Parser.new(handler)    
+    parser.parse(string_or_readable)
+  end
+
+  add_factory(self)
+end
+
+
+class NokoDocHandler < Nokogiri::XML::SAX::Document
+  def initialize(owner)
+    @owner = (owner)
+  end
+
+  def start_element(name,attrs)
+    attr_hash = Hash.new
+    attrs.each do |kv_array|
+      attr_hash[kv_array[0]] = kv_array[1]
+    end
+    @owner.send(:start_element, name, attr_hash)
+  end
+  
+  def end_element(name)
+    @owner.send(:end_element, name)
+  end
+
+
+  def cdata_block(t)
+    @owner.send(:characters, t)
+  end
+  
+  def characters(t)
+    @owner.send(:characters, t)
+  end
+  
+  def comment(t)
+    @owner.send(:characters,t)
+  end
+end
+
+
+end
+end

data/lib/xsd/xmlparser/ogaparser.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+# OgaParser XML parser library.
+# Copyright (C) 2015 Laurence A. Lee <rubyjedi@gmail.com>.
+
+# This program is copyrighted free software by Laurence A. Lee.  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 'pp'
+require 'oga'
+
+
+module XSD
+module XMLParser
+
+class OgaParser < XSD::XMLParser::Parser
+
+  def do_parse(string_or_readable)
+    # Oga::XML::SaxParser.new(self, string_or_readable)    
+    Oga.sax_parse_xml(self, string_or_readable)
+  end
+
+
+  def on_element(namespace, name, attrs)
+    start_element(node_name(namespace, name), attrs)
+  end
+
+  def after_element(namespace, name)
+    end_element(node_name(namespace, name))
+  end
+
+
+  def on_cdata(t)
+    characters(t)
+  end
+  
+  def on_comment(t)
+    characters(t)
+  end
+
+  def on_text(t)
+    characters(t)
+  end
+
+  
+  def on_xml_decl(attr_hash)
+    # attr_hash['version'] = '1.0'; attr_hash['encoding'] = 'utf-8' (usually)
+    # $stderr.puts "XML Document #{attr_hash['version']} in #{attr_hash['encoding']} encoding." 
+  end
+
+
+  private
+
+  def node_name(namespace, name)
+    namespace ? "#{namespace}:#{name}" : name.to_s
+  end
+
+  add_factory(self)
+
+end
+
+end
+end

data/lib/xsd/xmlparser/oxparser.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+# XSD4R - OXParser XML parser library.
+# Copyright (C) 2015 Laurence A. Lee <rubyjedi@gmail.com>.
+
+# This program is copyrighted free software by Laurence A. Lee.  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 'ox'
+
+
+module XSD
+module XMLParser
+
+class OxParser < XSD::XMLParser::Parser
+  def do_parse(string_or_readable)
+    @element_stack = []
+    begin
+      require 'htmlentities' # Used to unescape html-escaped chars, if available
+      @decoder = ::HTMLEntities.new(:expanded)
+    rescue LoadError
+      @decoder = nil
+    end
+
+    string = string_or_readable.respond_to?(:read) ? string_or_readable.read : StringIO.new(string_or_readable)
+    if @decoder.nil?
+      # Use the built-in conversion with Ox.
+      ::Ox.sax_parse(self, string, {:symbolize=> false, :convert_special=> true, :skip=> :skip_return} )
+    else
+      # Use HTMLEntities Decoder.  Leave the special-character conversion alone and let HTMLEntities decode it for us.
+      ::Ox.sax_parse(self, string, {})
+    end
+  end
+
+
+  alias_method :base_start_element, :start_element
+  def start_element(n)
+    # $stderr.puts "OxParser.start_element INVOKED [#{n}]"
+    @element_stack.push n.to_s # Push the Element Name
+    @element_stack.push Hash.new
+  end
+
+  alias_method :base_end_element, :end_element
+  def end_element(n)
+    # $stderr.puts "OxParser.end_element INVOKED [#{n}]"
+    if @element_stack[-2].to_s == n.to_s
+      attr_hash = @element_stack.pop
+      attr_key  = @element_stack.pop
+    else
+      $stderr.puts "!!!! OxParser.end_element FAILED TO FIND STACK PAIR [#{n}] IN STACK [#{PP.pp(@element_stack,'')}]"
+    end
+    base_end_element(n.to_s)
+  end
+
+
+  def text(t)
+    @decoder.nil? ? characters(t) : characters(@decoder.decode(t))
+  end
+
+  def cdata(t)
+    ## CAUTION:  Ox Parser removes leading/trailing whitespace or blank lines. ##
+    ## This behavior is evident if you run the regression test:
+    ##
+    ##    SOAP4R_PARSERS=oxparser bundle exec rake test:single test/soap/test_response_as_xml.rb
+    ##
+    @decoder.nil? ? characters(t) : characters(@decoder.decode(t))
+  end
+  
+  def comment(t)
+    @decoder.nil? ? characters(t) : characters(@decoder.decode(t))
+  end
+
+
+  def instruct(n)
+    # Do nothing. This is the outer "XML" tag.
+  end
+
+  def end_instruct(n)
+    # Do nothing.
+  end
+
+
+  def attr(key,val)
+    return if @element_stack[-1].nil?
+
+    attr_hash = @element_stack[-1]
+    attr_hash[key.to_s] = val
+  end
+  
+  def attrs_done
+    attr_hash = @element_stack[-1]
+    name = @element_stack[-2]
+
+    base_start_element(name, attr_hash) unless attr_hash.nil?
+  end
+
+  add_factory(self)
+end
+
+end
+end

data/lib/xsd/xmlparser/parser.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+# XSD4R - XML Instance parser 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/qname'
+require 'xsd/ns'
+require 'xsd/charset'
+
+
+module XSD
+module XMLParser
+
+
+class Parser
+  class ParseError < Error; end
+  class FormatDecodeError < ParseError; end
+  class UnknownElementError < FormatDecodeError; end
+  class UnknownAttributeError < FormatDecodeError; end
+  class UnexpectedElementError < FormatDecodeError; end
+  class ElementConstraintError < FormatDecodeError; end
+  class ParserError < ParseError; end
+
+  @@parser_factory = nil
+
+  def self.factory
+    @@parser_factory
+  end
+
+  def self.create_parser(host, opt = {})
+    unless @@parser_factory
+      raise ParserError.new("illegal XML parser configuration")
+    end
+    @@parser_factory.new(host, opt)
+  end
+
+  def self.add_factory(factory)
+    if $DEBUG
+      puts "Set #{ factory } as XML processor."
+    end
+    @@parser_factory = factory
+  end
+
+public
+
+  attr_accessor :charset
+
+  def initialize(host, opt = {})
+    @host = host
+    @charset = opt[:charset] || nil
+  end
+
+  def parse(string_or_readable)
+    @textbuf = ''
+    prologue
+    do_parse(string_or_readable)
+    epilogue
+  end
+
+private
+
+  def do_parse(string_or_readable)
+    raise ParserError.new(
+      'Method do_parse must be defined in derived class.')
+  end
+
+  def start_element(name, attrs)
+    @host.start_element(name, attrs)
+  end
+
+  def characters(text)
+    @host.characters(text)
+  end
+
+  def end_element(name)
+    @host.end_element(name)
+  end
+
+  def prologue
+  end
+
+  def epilogue
+  end
+
+  def xmldecl_encoding=(charset)
+    if @charset.nil?
+      @charset = charset
+    else
+      # Definition in a stream (like HTTP) has a priority.
+      p "encoding definition: #{ charset } is ignored." if $DEBUG
+    end
+  end
+end
+
+
+end
+end