nokogiri 1.5.0.beta.4 → 1.5.0

data/ext/java/nokogiri/HtmlSaxParserContext.java

@@ -1,259 +0,0 @@
-/**
- * (The MIT License)
- *
- * Copyright (c) 2008 - 2011:
- *
- * * {Aaron Patterson}[http://tenderlovemaking.com]
- * * {Mike Dalessio}[http://mike.daless.io]
- * * {Charles Nutter}[http://blog.headius.com]
- * * {Sergio Arbeo}[http://www.serabe.com]
- * * {Patrick Mahoney}[http://polycrystal.org]
- * * {Yoko Harada}[http://yokolet.blogspot.com]
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * 'Software'), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-package nokogiri;
-
-import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
-
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.nio.charset.Charset;
-import java.nio.charset.IllegalCharsetNameException;
-import java.util.EnumSet;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import nokogiri.internals.NokogiriHandler;
-
-import org.apache.xerces.parsers.AbstractSAXParser;
-import org.cyberneko.html.parsers.SAXParser;
-import org.jruby.Ruby;
-import org.jruby.RubyClass;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyString;
-import org.jruby.anno.JRubyClass;
-import org.jruby.anno.JRubyMethod;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.xml.sax.SAXException;
-
-/**
- * Class for Nokogiri::HTML::SAX::ParserContext.
- *
- * @author serabe
- * @author Patrick Mahoney <pat@polycrystal.org>
- * @author Yoko Harada <yokolet@gmail.com>
- */
-
-@JRubyClass(name="Nokogiri::HTML::SAX::ParserContext", parent="Nokogiri::XML::SAX::ParserContext")
-public class HtmlSaxParserContext extends XmlSaxParserContext {
-
-    public HtmlSaxParserContext(Ruby ruby, RubyClass rubyClass) {
-        super(ruby, rubyClass);
-    }
-    
-    @Override
-    protected AbstractSAXParser createParser() throws SAXException {
-        SAXParser parser = new SAXParser();
-
-        try{
-            parser.setProperty(
-                "http://cyberneko.org/html/properties/names/elems", "lower");
-            parser.setProperty(
-                "http://cyberneko.org/html/properties/names/attrs", "lower");
-            return parser;
-        } catch(SAXException ex) {
-            throw new SAXException(
-                "Problem while creating HTML SAX Parser: " + ex.toString());
-        }
-    }
-
-    @JRubyMethod(name="memory", meta=true)
-    public static IRubyObject parse_memory(ThreadContext context,
-                                           IRubyObject klazz,
-                                           IRubyObject data,
-                                           IRubyObject encoding) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
-        ctx.initialize(context.getRuntime());
-        String javaEncoding = findEncoding(context, encoding);
-        if (javaEncoding != null) {
-            String input = applyEncoding(rubyStringToString(data), javaEncoding);
-            ByteArrayInputStream istream = new ByteArrayInputStream(input.getBytes());
-            ctx.setInputSource(istream);
-            ctx.getInputSource().setEncoding(javaEncoding);
-        }
-        return ctx;
-    }
-    
-    public static enum EncodingType {
-        NONE(0, "NONE"),
-        UTF_8(1, "UTF-8"),
-        UTF16LE(2, "UTF16LE"),
-        UTF16BE(3, "UTF16BE"),
-        UCS4LE(4, "UCS4LE"),
-        UCS4BE(5, "UCS4BE"),
-        EBCDIC(6, "EBCDIC"),
-        UCS4_2143(7, "ICS4-2143"),
-        UCS4_3412(8, "UCS4-3412"),
-        UCS2(9, "UCS2"),
-        ISO_8859_1(10, "ISO-8859-1"),
-        ISO_8859_2(11, "ISO-8859-2"),
-        ISO_8859_3(12, "ISO-8859-3"),
-        ISO_8859_4(13, "ISO-8859-4"),
-        ISO_8859_5(14, "ISO-8859-5"),
-        ISO_8859_6(15, "ISO-8859-6"),
-        ISO_8859_7(16, "ISO-8859-7"),
-        ISO_8859_8(17, "ISO-8859-8"),
-        ISO_8859_9(18, "ISO-8859-9"),
-        ISO_2022_JP(19, "ISO-2022-JP"),
-        SHIFT_JIS(20, "SHIFT-JIS"),
-        EUC_JP(21, "EUC-JP"),
-        ASCII(22, "ASCII");
-        
-        private final int value;
-        private final String name;
-        EncodingType(int value, String name) {
-            this.value = value;
-            this.name = name;
-        }
-        
-        public int getValue() {
-            return value;
-        }
-        
-        public String toString() {
-            return name;
-        }
-    }
-    
-    private static String findName(int value) {
-        EnumSet<EncodingType> set = EnumSet.allOf(EncodingType.class);
-        for (EncodingType type : set) {
-            if (type.getValue() == value) return type.toString();
-        }
-        return null;
-    }
-    
-    private static String findEncoding(ThreadContext context, IRubyObject encoding) {
-        String rubyEncoding = null;
-        if (encoding instanceof RubyString) {
-            rubyEncoding = rubyStringToString(encoding);
-        } else if (encoding instanceof RubyFixnum) {
-            int value = (Integer)encoding.toJava(Integer.class);
-            rubyEncoding = findName(value);
-        }
-        if (rubyEncoding == null) return null;
-        try {
-            Charset charset = Charset.forName(rubyEncoding);
-            return charset.displayName();
-        } catch (IllegalCharsetNameException e) {
-            throw context.getRuntime().newEncodingCompatibilityError(
-                    rubyEncoding + "is not supported in Java.");
-        } catch (IllegalArgumentException e) {
-            throw context.getRuntime().newInvalidEncoding(
-                    "encoding should not be nil");
-        }
-    }
-    
-    private static String applyEncoding(String input, String enc) {
-        String str = input.toLowerCase();
-        int start_pos = 0;
-        int end_pos = 0;
-        if (input.contains("meta") && input.contains("charset")) {
-            Pattern p = Pattern.compile("charset(()|\\s)=(()|\\s)([a-z]|-|_|\\d)+");
-            Matcher m = p.matcher(str);
-            while (m.find()) {
-                start_pos = m.start();
-                end_pos = m.end();
-            }
-        }
-        if (start_pos != end_pos) {
-            String substr = input.substring(start_pos, end_pos);
-            input = input.replace(substr, "charset=" + enc);
-        }
-        return input;
-    }
-
-    @JRubyMethod(name="file", meta=true)
-    public static IRubyObject parse_file(ThreadContext context,
-                                         IRubyObject klazz,
-                                         IRubyObject data,
-                                         IRubyObject encoding) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
-        ctx.initialize(context.getRuntime());
-        ctx.setInputSourceFile(context, data);
-        String javaEncoding = findEncoding(context, encoding);
-        if (javaEncoding != null) {
-            ctx.getInputSource().setEncoding(javaEncoding);
-        }
-        return ctx;
-    }
-
-    @JRubyMethod(name="io", meta=true)
-    public static IRubyObject parse_io(ThreadContext context,
-                                       IRubyObject klazz,
-                                       IRubyObject data,
-                                       IRubyObject encoding) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
-        ctx.initialize(context.getRuntime());
-        ctx.setInputSource(context, data);
-        String javaEncoding = findEncoding(context, encoding);
-        if (javaEncoding != null) {
-            ctx.getInputSource().setEncoding(javaEncoding);
-        }
-        return ctx;
-    }
-
-    /**
-     * Create a new parser context that will read from a raw input
-     * stream. Not a JRuby method.  Meant to be run in a separate
-     * thread by XmlSaxPushParser.
-     */
-    public static IRubyObject parse_stream(ThreadContext context,
-                                           IRubyObject klazz,
-                                           InputStream stream) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
-        ctx.initialize(context.getRuntime());
-        ctx.setInputSource(stream);
-        return ctx;
-    }
-
-    @Override
-    protected void preParse(ThreadContext context,
-                             IRubyObject handlerRuby,
-                             NokogiriHandler handler) {
-        // final String path = "Nokogiri::XML::FragmentHandler";
-        // final String docFrag =
-        //     "http://cyberneko.org/html/features/balance-tags/document-fragment";
-        // RubyObjectAdapter adapter = JavaEmbedUtils.newObjectAdapter();
-        // IRubyObject doc = adapter.getInstanceVariable(handlerRuby, "@document");
-        // RubyModule mod =
-        //     context.getRuntime().getClassFromPath(path);
-        // try {
-        //     if (doc != null && !doc.isNil() && adapter.isKindOf(doc, mod))
-        //         parser.setFeature(docFrag, true);
-        // } catch (Exception e) {
-        //     // ignore
-        // }
-    }
-
-}

data/ext/java/nokogiri/NokogiriService.java

@@ -1,535 +0,0 @@
-/**
- * (The MIT License)
- *
- * Copyright (c) 2008 - 2011:
- *
- * * {Aaron Patterson}[http://tenderlovemaking.com]
- * * {Mike Dalessio}[http://mike.daless.io]
- * * {Charles Nutter}[http://blog.headius.com]
- * * {Sergio Arbeo}[http://www.serabe.com]
- * * {Patrick Mahoney}[http://polycrystal.org]
- * * {Yoko Harada}[http://yokolet.blogspot.com]
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * 'Software'), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-package nokogiri;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.jruby.Ruby;
-import org.jruby.RubyArray;
-import org.jruby.RubyClass;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyModule;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.runtime.load.BasicLibraryService;
-
-/**
- * Class to provide Nokogiri. This class is used to make "require 'nokogiri'" work
- * in JRuby. Also, this class holds a Ruby type cache and allocators of Ruby types.
- * 
- * @author headius
- * @author Yoko Harada <yokolet@gmail.com>
- */
-public class NokogiriService implements BasicLibraryService {
-    public static final String nokogiriClassCacheGvarName = "$NOKOGIRI_CLASS_CACHE";
-    public static Map<String, RubyClass> nokogiriClassCache;
-
-    public boolean basicLoad(Ruby ruby) {
-        init(ruby);
-        createNokogiriClassCahce(ruby);
-        return true;
-    }
-    
-    private static void createNokogiriClassCahce(Ruby ruby) {
-        nokogiriClassCache = Collections.synchronizedMap(new HashMap<String, RubyClass>());
-        nokogiriClassCache.put("Nokogiri::EncodingHandler", (RubyClass)ruby.getClassFromPath("Nokogiri::EncodingHandler"));
-        nokogiriClassCache.put("Nokogiri::HTML::Document", (RubyClass)ruby.getClassFromPath("Nokogiri::HTML::Document"));
-        nokogiriClassCache.put("Nokogiri::HTML::ElementDescription", (RubyClass)ruby.getClassFromPath("Nokogiri::HTML::ElementDescription"));
-        nokogiriClassCache.put("Nokogiri::XML::Attr", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Attr"));
-        nokogiriClassCache.put("Nokogiri::XML::Document", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Document"));
-        nokogiriClassCache.put("Nokogiri::XML::DocumentFragment", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::DocumentFragment"));
-        nokogiriClassCache.put("Nokogiri::XML::DTD", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::DTD"));
-        nokogiriClassCache.put("Nokogiri::XML::Text", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Text"));
-        nokogiriClassCache.put("Nokogiri::XML::Comment", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Comment"));
-        nokogiriClassCache.put("Nokogiri::XML::Element", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Element"));
-        nokogiriClassCache.put("Nokogiri::XML::ElementContent", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::ElementContent"));
-        nokogiriClassCache.put("Nokogiri::XML::ElementDecl", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::ElementDecl"));
-        nokogiriClassCache.put("Nokogiri::XML::EntityDecl", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::EntityDecl"));
-        nokogiriClassCache.put("Nokogiri::XML::CDATA", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::CDATA"));
-        nokogiriClassCache.put("Nokogiri::XML::Node", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Node"));
-        nokogiriClassCache.put("Nokogiri::XML::NodeSet", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::NodeSet"));
-        nokogiriClassCache.put("Nokogiri::XML::Namespace", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Namespace"));
-        nokogiriClassCache.put("Nokogiri::XML::SyntaxError", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::SyntaxError"));
-        nokogiriClassCache.put("Nokogiri::XML::RelaxNG", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::RelaxNG"));
-        nokogiriClassCache.put("Nokogiri::XML::Schema", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::Schema"));
-        nokogiriClassCache.put("Nokogiri::XML::AttributeDecl", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::AttributeDecl"));
-        nokogiriClassCache.put("Nokogiri::XML::SAX::ParserContext", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::SAX::ParserContext"));
-    }
-
-    private void init(Ruby ruby) {
-        RubyModule nokogiri = ruby.defineModule("Nokogiri");
-        RubyModule xmlModule = nokogiri.defineModuleUnder("XML");
-        RubyModule xmlSaxModule = xmlModule.defineModuleUnder("SAX");
-        RubyModule htmlModule = nokogiri.defineModuleUnder("HTML");
-        RubyModule htmlSaxModule = htmlModule.defineModuleUnder("SAX");
-        RubyModule xsltModule = nokogiri.defineModuleUnder("XSLT");
-
-        createNokogiriModule(ruby, nokogiri);
-        createSyntaxErrors(ruby, nokogiri, xmlModule);
-        RubyClass xmlNode = createXmlModule(ruby, xmlModule);
-        createHtmlModule(ruby, htmlModule);
-        createDocuments(ruby, xmlModule, htmlModule, xmlNode);
-        createSaxModule(ruby, xmlSaxModule, htmlSaxModule);
-        createXsltModule(ruby, xsltModule);
-    }
-    
-    private void createNokogiriModule(Ruby ruby, RubyModule nokogiri) {;
-        RubyClass encHandler = nokogiri.defineClassUnder("EncodingHandler", ruby.getObject(), ENCODING_HANDLER_ALLOCATOR);
-        encHandler.defineAnnotatedMethods(EncodingHandler.class);
-    }
-    
-    private void createSyntaxErrors(Ruby ruby, RubyModule nokogiri, RubyModule xmlModule) {
-        RubyClass syntaxError = nokogiri.defineClassUnder("SyntaxError", ruby.getStandardError(), ruby.getStandardError().getAllocator());
-        RubyClass xmlSyntaxError = xmlModule.defineClassUnder("SyntaxError", syntaxError, XML_SYNTAXERROR_ALLOCATOR);
-        xmlSyntaxError.defineAnnotatedMethods(XmlSyntaxError.class);
-    }
-    
-    private RubyClass createXmlModule(Ruby ruby, RubyModule xmlModule) {
-        RubyClass node = xmlModule.defineClassUnder("Node", ruby.getObject(), XML_NODE_ALLOCATOR);
-        node.defineAnnotatedMethods(XmlNode.class);
-        
-        RubyClass attr = xmlModule.defineClassUnder("Attr", node, XML_ATTR_ALLOCATOR);
-        attr.defineAnnotatedMethods(XmlAttr.class);
-        
-        RubyClass attrDecl = xmlModule.defineClassUnder("AttributeDecl", node, XML_ATTRIBUTE_DECL_ALLOCATOR);
-        attrDecl.defineAnnotatedMethods(XmlAttributeDecl.class);
-        
-        RubyClass characterData = xmlModule.defineClassUnder("CharacterData", node, null);
-        
-        RubyClass comment = xmlModule.defineClassUnder("Comment", characterData, XML_COMMENT_ALLOCATOR);
-        comment.defineAnnotatedMethods(XmlComment.class);
-        
-        RubyClass text = xmlModule.defineClassUnder("Text", characterData, XML_TEXT_ALLOCATOR);
-        text.defineAnnotatedMethods(XmlText.class);
-        
-        RubyModule cdata = xmlModule.defineClassUnder("CDATA", text, XML_CDATA_ALLOCATOR);
-        cdata.defineAnnotatedMethods(XmlCdata.class);
-        
-        RubyClass dtd = xmlModule.defineClassUnder("DTD", node, XML_DTD_ALLOCATOR);
-        dtd.defineAnnotatedMethods(XmlDtd.class);
-
-        RubyClass documentFragment = xmlModule.defineClassUnder("DocumentFragment", node, XML_DOCUMENT_FRAGMENT_ALLOCATOR);
-        documentFragment.defineAnnotatedMethods(XmlDocumentFragment.class);
-        
-        RubyClass element = xmlModule.defineClassUnder("Element", node, XML_ELEMENT_ALLOCATOR);
-        element.defineAnnotatedMethods(XmlElement.class);
-        
-        RubyClass elementContent = xmlModule.defineClassUnder("ElementContent", ruby.getObject(), XML_ELEMENT_CONTENT_ALLOCATOR);
-        elementContent.defineAnnotatedMethods(XmlElementContent.class);
-        
-        RubyClass elementDecl = xmlModule.defineClassUnder("ElementDecl", node, XML_ELEMENT_DECL_ALLOCATOR);
-        elementDecl.defineAnnotatedMethods(XmlElementDecl.class);
-        
-        RubyClass entityDecl = xmlModule.defineClassUnder("EntityDecl", node, XML_ENTITY_DECL_ALLOCATOR);
-        entityDecl.defineAnnotatedMethods(XmlEntityDecl.class);
-        entityDecl.defineConstant("INTERNAL_GENERAL", RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_GENERAL));
-        entityDecl.defineConstant("EXTERNAL_GENERAL_PARSED", RubyFixnum.newFixnum(ruby, XmlEntityDecl.EXTERNAL_GENERAL_PARSED));
-        entityDecl.defineConstant("EXTERNAL_GENERAL_UNPARSED", RubyFixnum.newFixnum(ruby, XmlEntityDecl.EXTERNAL_GENERAL_UNPARSED));
-        entityDecl.defineConstant("INTERNAL_PARAMETER", RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_PARAMETER));
-        entityDecl.defineConstant("EXTERNAL_PARAMETER", RubyFixnum.newFixnum(ruby, XmlEntityDecl.EXTERNAL_PARAMETER));
-        entityDecl.defineConstant("INTERNAL_PREDEFINED", RubyFixnum.newFixnum(ruby, XmlEntityDecl.INTERNAL_PREDEFINED));
-        
-        RubyClass entref = xmlModule.defineClassUnder("EntityReference", node, XML_ENTITY_REFERENCE_ALLOCATOR);
-        entref.defineAnnotatedMethods(XmlEntityReference.class);
-        
-        RubyClass namespace = xmlModule.defineClassUnder("Namespace", ruby.getObject(), XML_NAMESPACE_ALLOCATOR);
-        namespace.defineAnnotatedMethods(XmlNamespace.class);
-        
-        RubyClass nodeSet = xmlModule.defineClassUnder("NodeSet", ruby.getObject(), XML_NODESET_ALLOCATOR);
-        nodeSet.defineAnnotatedMethods(XmlNodeSet.class);
-        
-        RubyClass pi = xmlModule.defineClassUnder("ProcessingInstruction", node, XML_PROCESSING_INSTRUCTION_ALLOCATOR);
-        pi.defineAnnotatedMethods(XmlProcessingInstruction.class);
-        
-        RubyClass reader = xmlModule.defineClassUnder("Reader", ruby.getObject(), XML_READER_ALLOCATOR);
-        reader.defineAnnotatedMethods(XmlReader.class);
-        
-        RubyClass schema = xmlModule.defineClassUnder("Schema", ruby.getObject(), XML_SCHEMA_ALLOCATOR);
-        schema.defineAnnotatedMethods(XmlSchema.class);
-
-        RubyClass relaxng = xmlModule.defineClassUnder("RelaxNG", schema, XML_RELAXNG_ALLOCATOR);
-        relaxng.defineAnnotatedMethods(XmlRelaxng.class);
-        
-        RubyClass xpathContext = xmlModule.defineClassUnder("XPathContext", ruby.getObject(), XML_XPATHCONTEXT_ALLOCATOR);
-        xpathContext.defineAnnotatedMethods(XmlXpathContext.class);
-        
-        return node;
-    }
-
-    private void createHtmlModule(Ruby ruby, RubyModule htmlModule) {
-        RubyClass htmlElemDesc = htmlModule.defineClassUnder("ElementDescription", ruby.getObject(), HTML_ELEMENT_DESCRIPTION_ALLOCATOR);
-        htmlElemDesc.defineAnnotatedMethods(HtmlElementDescription.class);
-        
-        RubyClass htmlEntityLookup = htmlModule.defineClassUnder("EntityLookup", ruby.getObject(), HTML_ENTITY_LOOKUP_ALLOCATOR);
-        htmlEntityLookup.defineAnnotatedMethods(HtmlEntityLookup.class);
-    }
-    
-    private void createDocuments(Ruby ruby, RubyModule xmlModule, RubyModule htmlModule, RubyClass node) {
-        RubyClass xmlDocument = xmlModule.defineClassUnder("Document", node, XML_DOCUMENT_ALLOCATOR);
-        xmlDocument.defineAnnotatedMethods(XmlDocument.class);
-        
-        //RubyModule htmlDoc = html.defineOrGetClassUnder("Document", document);
-        RubyModule htmlDocument = htmlModule.defineClassUnder("Document", xmlDocument, HTML_DOCUMENT_ALLOCATOR);
-        htmlDocument.defineAnnotatedMethods(HtmlDocument.class);
-    }
-    
-    private void createSaxModule(Ruby ruby, RubyModule xmlSaxModule, RubyModule htmlSaxModule) {
-        RubyClass xmlSaxParserContext = xmlSaxModule.defineClassUnder("ParserContext", ruby.getObject(), XML_SAXPARSER_CONTEXT_ALLOCATOR);
-        xmlSaxParserContext.defineAnnotatedMethods(XmlSaxParserContext.class);
-        
-        RubyClass xmlSaxPushParser = xmlSaxModule.defineClassUnder("PushParser", ruby.getObject(), XML_SAXPUSHPARSER_ALLOCATOR);
-        xmlSaxPushParser.defineAnnotatedMethods(XmlSaxPushParser.class);
-        
-        RubyClass htmlSaxParserContext = htmlSaxModule.defineClassUnder("ParserContext", xmlSaxParserContext, HTML_SAXPARSER_CONTEXT_ALLOCATOR);
-        htmlSaxParserContext.defineAnnotatedMethods(HtmlSaxParserContext.class);
-    }
-    
-    private void createXsltModule(Ruby ruby, RubyModule xsltModule) {
-        RubyClass stylesheet = xsltModule.defineClassUnder("Stylesheet", ruby.getObject(), XSLT_STYLESHEET_ALLOCATOR);
-        stylesheet.defineAnnotatedMethods(XsltStylesheet.class);
-        xsltModule.defineAnnotatedMethod(XsltStylesheet.class, "register");
-    }
-
-    private static ObjectAllocator ENCODING_HANDLER_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new EncodingHandler(runtime, klazz, "");
-        }
-    };
-
-    public static final ObjectAllocator HTML_DOCUMENT_ALLOCATOR = new ObjectAllocator() {
-        private HtmlDocument htmlDocument = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (htmlDocument == null) htmlDocument = new HtmlDocument(runtime, klazz);
-            try {
-                HtmlDocument clone = (HtmlDocument) htmlDocument.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new HtmlDocument(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator HTML_SAXPARSER_CONTEXT_ALLOCATOR = new ObjectAllocator() {
-        private HtmlSaxParserContext htmlSaxParserContext = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (htmlSaxParserContext == null) htmlSaxParserContext = new HtmlSaxParserContext(runtime, klazz);
-            try {
-                HtmlSaxParserContext clone = (HtmlSaxParserContext) htmlSaxParserContext.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new HtmlSaxParserContext(runtime, klazz);
-            }
-        }
-    };
-
-    private static ObjectAllocator HTML_ELEMENT_DESCRIPTION_ALLOCATOR =
-        new ObjectAllocator() {
-            public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-                return new HtmlElementDescription(runtime, klazz);
-            }
-        };
-
-    private static ObjectAllocator HTML_ENTITY_LOOKUP_ALLOCATOR =
-        new ObjectAllocator() {
-            public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-                return new HtmlEntityLookup(runtime, klazz);
-            }
-        };
-
-    public static final ObjectAllocator XML_ATTR_ALLOCATOR = new ObjectAllocator() {
-        private XmlAttr xmlAttr = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlAttr == null) xmlAttr = new XmlAttr(runtime, klazz);
-            try {
-                XmlAttr clone = (XmlAttr) xmlAttr.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlAttr(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_CDATA_ALLOCATOR = new ObjectAllocator() {
-        private XmlCdata xmlCdata = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlCdata == null) xmlCdata = new XmlCdata(runtime, klazz);
-            try {
-                XmlCdata clone = (XmlCdata) xmlCdata.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlCdata(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_COMMENT_ALLOCATOR = new ObjectAllocator() {
-        private XmlComment xmlComment = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlComment == null) xmlComment = new XmlComment(runtime, klazz);
-            try {
-                XmlComment clone = (XmlComment) xmlComment.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlComment(runtime, klazz);
-            }
-        }
-    };
-
-    private static ObjectAllocator XML_PROCESSING_INSTRUCTION_ALLOCATOR =
-        new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            throw runtime.newNotImplementedError("not implemented");
-        }
-    };
-
-    public static final ObjectAllocator XML_DOCUMENT_ALLOCATOR = new ObjectAllocator() {
-        private XmlDocument xmlDocument = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlDocument == null) xmlDocument = new XmlDocument(runtime, klazz);
-            try {
-                XmlDocument clone = (XmlDocument) xmlDocument.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlDocument(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_DOCUMENT_FRAGMENT_ALLOCATOR = new ObjectAllocator() {
-        private XmlDocumentFragment xmlDocumentFragment = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlDocumentFragment == null) xmlDocumentFragment = new XmlDocumentFragment(runtime, klazz);
-            try {
-                XmlDocumentFragment clone = (XmlDocumentFragment)xmlDocumentFragment.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlDocumentFragment(runtime, klazz);
-            }
-        }
-    };
-
-    private static ObjectAllocator XML_DTD_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XmlDtd(runtime, klazz);
-        }
-    };
-
-    public static final ObjectAllocator XML_ELEMENT_ALLOCATOR = new ObjectAllocator() {
-        private XmlElement xmlElement = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlElement == null) xmlElement = new XmlElement(runtime, klazz);
-            try {
-                XmlElement clone = (XmlElement)xmlElement.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlElement(runtime, klazz);
-            }
-        }
-    };
-
-    private static ObjectAllocator XML_ENTITY_REFERENCE_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XmlEntityReference(runtime, klazz);
-        }
-    };
-
-    public static final ObjectAllocator XML_NAMESPACE_ALLOCATOR = new ObjectAllocator() {
-        private XmlNamespace xmlNamespace = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlNamespace == null) xmlNamespace = new XmlNamespace(runtime, klazz);
-            try {
-                XmlNamespace clone = (XmlNamespace) xmlNamespace.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlNamespace(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_NODE_ALLOCATOR = new ObjectAllocator() {
-        private XmlNode xmlNode = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlNode == null) xmlNode = new XmlNode(runtime, klazz);
-            try {
-                XmlNode clone  = (XmlNode) xmlNode.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlNode(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_NODESET_ALLOCATOR = new ObjectAllocator() {
-        private XmlNodeSet xmlNodeSet = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlNodeSet == null) xmlNodeSet = new XmlNodeSet(runtime, klazz);
-            try {
-                XmlNodeSet clone  = (XmlNodeSet) xmlNodeSet.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlNodeSet(runtime, klazz, RubyArray.newEmptyArray(runtime));
-            }
-        }
-    };
-
-    private static ObjectAllocator XML_READER_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XmlReader(runtime, klazz);
-        }
-    };
-
-    private static ObjectAllocator XML_ATTRIBUTE_DECL_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XmlAttributeDecl(runtime, klazz);
-        }
-    };
-
-    private static ObjectAllocator XML_ELEMENT_DECL_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XmlElementDecl(runtime, klazz);
-        }
-    };
-
-    private static ObjectAllocator XML_ENTITY_DECL_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XmlEntityDecl(runtime, klazz);
-        }
-    };
-
-    private static ObjectAllocator XML_ELEMENT_CONTENT_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            throw runtime.newNotImplementedError("not implemented");
-        }
-    };
-
-    public static final ObjectAllocator XML_RELAXNG_ALLOCATOR = new ObjectAllocator() {
-        private XmlRelaxng xmlRelaxng = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlRelaxng == null) xmlRelaxng = new XmlRelaxng(runtime, klazz);
-            try {
-                XmlRelaxng clone  = (XmlRelaxng) xmlRelaxng.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlRelaxng(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_SAXPARSER_CONTEXT_ALLOCATOR = new ObjectAllocator() {
-        private XmlSaxParserContext xmlSaxParserContext = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlSaxParserContext == null) xmlSaxParserContext = new XmlSaxParserContext(runtime, klazz);
-            try {
-                XmlSaxParserContext clone = (XmlSaxParserContext) xmlSaxParserContext.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlSaxParserContext(runtime, klazz);
-            }
-        }
-    };
-
-    private static ObjectAllocator XML_SAXPUSHPARSER_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XmlSaxPushParser(runtime, klazz);
-        }
-    };
-
-    public static final ObjectAllocator XML_SCHEMA_ALLOCATOR = new ObjectAllocator() {
-        private XmlSchema xmlSchema = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlSchema == null) xmlSchema = new XmlSchema(runtime, klazz);
-            try {
-                XmlSchema clone  = (XmlSchema) xmlSchema.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlSchema(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_SYNTAXERROR_ALLOCATOR = new ObjectAllocator() {
-        private XmlSyntaxError xmlSyntaxError = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlSyntaxError == null) xmlSyntaxError = new XmlSyntaxError(runtime, klazz);
-            try {
-                XmlSyntaxError clone  = (XmlSyntaxError) xmlSyntaxError.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlSyntaxError(runtime, klazz);
-            }
-        }
-    };
-
-    public static final ObjectAllocator XML_TEXT_ALLOCATOR = new ObjectAllocator() {
-        private XmlText xmlText = null;
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            if (xmlText == null) xmlText = new XmlText(runtime, klazz);
-            try {
-                XmlText clone  = (XmlText) xmlText.clone();
-                clone.setMetaClass(klazz);
-                return clone;
-            } catch (CloneNotSupportedException e) {
-                return new XmlText(runtime, klazz);
-            }
-        }
-    };
-
-    private static ObjectAllocator XML_XPATHCONTEXT_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            throw runtime.newNotImplementedError("not implemented");
-        }
-    };
-
-    private static ObjectAllocator XSLT_STYLESHEET_ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new XsltStylesheet(runtime, klazz);
-        }
-    };
-}