nokogiri 1.5.0.beta.1 → 1.5.0.beta.2

data/ext/java/nokogiri/HtmlElementDescription.java

@@ -0,0 +1,111 @@
+package nokogiri;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.cyberneko.html.HTMLElements;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+@JRubyClass(name="Nokogiri::HTML::ElementDescription")
+public class HtmlElementDescription extends RubyObject {
+
+    /**
+     * Stores memoized hash of element -> list of valid subelements.
+     */
+    static protected Map<Short, List<String>> subElements;
+    static {
+        Map<Short, List<String>> _subElements =
+            new HashMap<Short, List<String>>();
+        subElements = Collections.synchronizedMap(_subElements);
+    }
+
+    protected HTMLElements.Element element;
+
+    public HtmlElementDescription(Ruby runtime, RubyClass rubyClass) {
+        super(runtime, rubyClass);
+    }
+
+    /**
+     * Lookup the list of sub elements of <code>code</code>.  If not
+     * already stored, iterate through all elements to find valid
+     * subelements; save this list and return it.
+     */
+    protected static List<String> findSubElements(HTMLElements.Element elem) {
+        List<String> subs = subElements.get(elem.code);
+
+        if (subs == null) {
+            subs = new ArrayList<String>();
+
+            /*
+             * A bit of a hack.  NekoHtml source code shows that
+             * UNKNOWN is the highest value element.  We cannot access
+             * the list of elements directly because it's protected.
+             */
+            for (short c = 0; c < HTMLElements.UNKNOWN; c++) {
+                HTMLElements.Element maybe_sub =
+                    HTMLElements.getElement(c);
+                if (maybe_sub.isParent(elem)) {
+                    subs.add(maybe_sub.name);
+                }
+            }
+
+            subElements.put(elem.code, subs);
+        }
+
+        return subs;
+    }
+
+    @JRubyMethod(name="[]", meta=true)
+    public static IRubyObject get(ThreadContext context,
+                                  IRubyObject klazz, IRubyObject name) {
+
+        HTMLElements.Element elem = HTMLElements.getElement(name.toString());
+        if (elem == HTMLElements.NO_SUCH_ELEMENT)
+            return context.getRuntime().getNil();
+
+        HtmlElementDescription desc =
+            new HtmlElementDescription(context.getRuntime(), (RubyClass)klazz);
+        desc.element = elem;
+        return desc;
+    }
+
+    @JRubyMethod()
+    public IRubyObject name(ThreadContext context) {
+        return context.getRuntime().newString(element.name.toLowerCase());
+    }
+
+    @JRubyMethod(name="inline?")
+    public IRubyObject inline_eh(ThreadContext context) {
+        return context.getRuntime().newBoolean(element.isInline());
+    }
+
+    @JRubyMethod(name="empty?")
+    public IRubyObject empty_eh(ThreadContext context) {
+        return context.getRuntime().newBoolean(element.isEmpty());
+    }
+
+    @JRubyMethod()
+    public IRubyObject sub_elements(ThreadContext context) {
+        Ruby ruby = context.getRuntime();
+        List<String> subs = findSubElements(element);
+        IRubyObject[] ary = new IRubyObject[subs.size()];
+        for (int i = 0; i < subs.size(); ++i) {
+            ary[i] = ruby.newString(subs.get(i));
+        }
+
+        return ruby.newArray(ary);
+    }
+
+}

data/ext/java/nokogiri/HtmlEntityLookup.java

@@ -0,0 +1,45 @@
+package nokogiri;
+
+import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
+
+import org.cyberneko.html.HTMLEntities;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+@JRubyClass(name="Nokogiri::HTML::EntityLookup")
+public class HtmlEntityLookup extends RubyObject {
+
+    public HtmlEntityLookup(Ruby runtime, RubyClass rubyClass) {
+        super(runtime, rubyClass);
+    }
+
+    /**
+     * Looks up an HTML entity <code>key</code>.
+     *
+     * The description is a bit lacking.
+     */
+    @JRubyMethod()
+    public IRubyObject get(ThreadContext context, IRubyObject key) {
+        Ruby ruby = context.getRuntime();
+        String name = key.toString();
+        int val = HTMLEntities.get(name);
+        if (val == -1) return ruby.getNil();
+
+        IRubyObject edClass =
+            ruby.getClassFromPath("Nokogiri::HTML::EntityDescription");
+        IRubyObject edObj = invoke(context, edClass, "new",
+                                   ruby.newFixnum(val), ruby.newString(name),
+                                   ruby.newString(name + " entity"));
+
+        return edObj;
+    }
+
+}

data/ext/java/nokogiri/HtmlSaxParserContext.java

@@ -0,0 +1,218 @@
+package nokogiri;
+
+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;
+
+@JRubyClass(name="Nokogiri::HTML::SAX::ParserContext", parent="Nokogiri::XML::SAX::ParserContext")
+public class HtmlSaxParserContext extends XmlSaxParserContext {
+    private SAXParser parser;
+
+    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 =
+            new HtmlSaxParserContext(context.getRuntime(), (RubyClass) klazz);
+        String javaEncoding = findEncoding(context, encoding);
+        if (javaEncoding != null) {
+            String input = applyEncoding((String) data.toJava(String.class), 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 = (String)encoding.toJava(String.class);
+        } 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 =
+            new HtmlSaxParserContext(context.getRuntime(), (RubyClass) klazz);
+        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 =
+            new HtmlSaxParserContext(context.getRuntime(), (RubyClass) klazz);
+        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 =
+            new HtmlSaxParserContext(context.getRuntime(), (RubyClass)klazz);
+        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

@@ -0,0 +1,370 @@
+package nokogiri;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+/**
+ *
+ * @author headius
+ */
+public class NokogiriService implements BasicLibraryService {
+    public static final String nokogiriClassCacheGvarName = "$NOKOGIRI_CLASS_CACHE";
+
+    public boolean basicLoad(Ruby ruby) {
+        init(ruby);
+        createNokogiriClassCahce(ruby);
+        return true;
+    }
+    
+    private void createNokogiriClassCahce(Ruby ruby) {
+        RubyHash nokogiriClassCache = RubyHash.newHash(ruby);
+        nokogiriClassCache.put("Nokogiri::EncodingHandler", (RubyClass)ruby.getClassFromPath("Nokogiri::EncodingHandler"));
+        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::RelaxNG", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::RelaxNG"));
+        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::AttributeDecl", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::AttributeDecl"));
+        nokogiriClassCache.put("Nokogiri::XML::SAX::ParserContext", (RubyClass)ruby.getClassFromPath("Nokogiri::XML::SAX::ParserContext"));
+
+        ruby.getGlobalVariables().set(nokogiriClassCacheGvarName, nokogiriClassCache);
+    }
+
+    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_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_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);
+    }
+
+    private static ObjectAllocator ENCODING_HANDLER_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new EncodingHandler(runtime, klazz, "");
+        }
+    };
+
+    private static ObjectAllocator HTML_DOCUMENT_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new HtmlDocument(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator HTML_SAXPARSER_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            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);
+            }
+        };
+
+    private static ObjectAllocator XML_ATTR_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz){
+            return new XmlAttr(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator XML_CDATA_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new XmlCdata(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator XML_COMMENT_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            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");
+        }
+    };
+
+    private static ObjectAllocator XML_DOCUMENT_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            throw runtime.newNotImplementedError("not implemented");
+        }
+    };
+
+    private static ObjectAllocator XML_DOCUMENT_FRAGMENT_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            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);
+        }
+    };
+
+    private static ObjectAllocator XML_ELEMENT_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            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);
+        }
+    };
+
+    private static ObjectAllocator XML_NAMESPACE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new XmlNamespace(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator XML_NODE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new XmlNode(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator XML_NODESET_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            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");
+        }
+    };
+
+    private static ObjectAllocator XML_RELAXNG_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new XmlRelaxng(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator XML_SAXPARSER_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            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);
+        }
+    };
+
+    private static ObjectAllocator XML_SCHEMA_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new XmlSchema(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator XML_SYNTAXERROR_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new XmlSyntaxError(runtime, klazz);
+        }
+    };
+
+    private static ObjectAllocator XML_TEXT_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            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);
+        }
+    };
+}