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

data/ext/java/nokogiri/internals/SchemaErrorHandler.java

@@ -0,0 +1,35 @@
+package nokogiri.internals;
+
+import nokogiri.XmlSyntaxError;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ *
+ * @author sergio
+ */
+public class SchemaErrorHandler implements ErrorHandler{
+    private RubyArray errors;
+    private Ruby ruby;
+
+    public SchemaErrorHandler(Ruby ruby, RubyArray array) {
+        this.ruby = ruby;
+        this.errors = array;
+    }
+
+    public void warning(SAXParseException ex) throws SAXException {
+        this.errors.append(new XmlSyntaxError(ruby, ex));
+    }
+
+    public void error(SAXParseException ex) throws SAXException {
+        this.errors.append(new XmlSyntaxError(ruby, ex));
+    }
+
+    public void fatalError(SAXParseException ex) throws SAXException {
+        throw ex;
+    }
+
+}

data/ext/java/nokogiri/internals/XmlDeclHandler.java

@@ -0,0 +1,10 @@
+package nokogiri.internals;
+
+/**
+ * Interface for receiving xmlDecl information.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+public interface XmlDeclHandler {
+    public void xmlDecl(String version, String encoding, String standalone);
+}

data/ext/java/nokogiri/internals/XmlDomParser.java

@@ -0,0 +1,45 @@
+package nokogiri.internals;
+
+import java.io.IOException;
+
+import nokogiri.XmlDocument;
+
+import org.apache.xerces.parsers.DOMParser;
+import org.apache.xerces.xni.parser.XMLParserConfiguration;
+import org.cyberneko.dtd.DTDConfiguration;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ * Sets up a Xerces/XNI DOM Parser for use with Nokogiri.  Uses
+ * NekoDTD to parse the DTD into a tree of Nodes.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+public class XmlDomParser extends DOMParser {
+    DOMParser dtd;
+
+    public XmlDomParser() {
+        super();
+
+        DTDConfiguration dtdConfig = new DTDConfiguration();
+        dtd = new DOMParser(dtdConfig);
+
+        XMLParserConfiguration config = getXMLParserConfiguration();
+        config.setDTDHandler(dtdConfig);
+        config.setDTDContentModelHandler(dtdConfig);
+    }
+
+    @Override
+    public void parse(InputSource source) throws SAXException, IOException {
+        dtd.reset();
+        super.parse(source);
+        Document doc = getDocument();
+        if (doc == null)
+            throw new RuntimeException("null document");
+
+        doc.setUserData(XmlDocument.DTD_RAW_DOCUMENT, dtd.getDocument(),
+                        null);
+    }
+}

data/ext/java/nokogiri/internals/XmlDomParserContext.java

@@ -0,0 +1,201 @@
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import nokogiri.XmlDocument;
+import nokogiri.XmlSyntaxError;
+
+import org.apache.xerces.parsers.DOMParser;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+/**
+ *
+ * @author sergio
+ */
+public class XmlDomParserContext extends ParserContext {
+    protected static final String FEATURE_LOAD_EXTERNAL_DTD =
+        "http://apache.org/xml/features/nonvalidating/load-external-dtd";
+    protected static final String FEATURE_INCLUDE_IGNORABLE_WHITESPACE =
+        "http://apache.org/xml/features/dom/include-ignorable-whitespace";
+    protected static final String FEATURE_VALIDATION = "http://xml.org/sax/features/validation";
+
+    protected ParserContext.Options options;
+    protected DOMParser parser;
+    protected NokogiriErrorHandler errorHandler;
+    protected String java_encoding;
+    protected IRubyObject ruby_encoding;
+
+    public XmlDomParserContext(Ruby runtime, IRubyObject options) {
+        this(runtime, runtime.getNil(), options);
+    }
+    
+    public XmlDomParserContext(Ruby runtime, IRubyObject encoding, IRubyObject options) {
+        super(runtime);
+        this.options = new ParserContext.Options((Long)options.toJava(Long.class));
+        this.java_encoding = encoding.isNil() ? NokogiriHelpers.guessEncoding(runtime) : (String)encoding.toJava(String.class);
+        ruby_encoding = encoding;
+        initErrorHandler();
+        initParser(runtime);
+    }
+    
+    protected void initErrorHandler() {
+        if (continuesOnError()) {
+            errorHandler = new NokogiriNonStrictErrorHandler();
+        } else {
+            errorHandler = new NokogiriStrictErrorHandler();
+        }
+    }
+
+    protected void initParser(Ruby runtime) {
+        parser = new XmlDomParser();
+        parser.setErrorHandler(errorHandler);
+
+        if (options.noBlanks) {
+            setFeature(FEATURE_INCLUDE_IGNORABLE_WHITESPACE, false);
+        }
+
+        if (options.dtdValid) {
+            setFeature(FEATURE_VALIDATION, true);
+        }
+        // If we turn off loading of external DTDs complete, we don't
+        // getthe publicID.  Instead of turning off completely, we use
+        // an entity resolver that returns empty documents.
+        if (options.dtdLoad) {
+            setFeature(FEATURE_LOAD_EXTERNAL_DTD, true);
+            parser.setEntityResolver(new ChdirEntityResolver(runtime));
+        } else {
+            parser.setEntityResolver(new EntityResolver() {
+                    public InputSource resolveEntity(String arg0, String arg1)
+                        throws SAXException, IOException {
+                        ByteArrayInputStream empty =
+                            new ByteArrayInputStream(new byte[0]);
+                        return new InputSource(empty);
+                    }
+                });
+        }
+    }
+
+    /**
+     * Convenience method that catches and ignores SAXException
+     * (unrecognized and unsupported exceptions).
+     */
+    protected void setFeature(String feature, boolean value) {
+        try {
+            parser.setFeature(feature, value);
+        } catch (SAXException e) {
+            // ignore
+        }
+    }
+
+    /**
+     * Convenience method that catches and ignores SAXException
+     * (unrecognized and unsupported exceptions).
+     */
+    protected void setProperty(String property, Object value) {
+        try {
+            parser.setProperty(property, value);
+        } catch (SAXException e) {
+            // ignore
+        }
+    }
+
+    public void addErrorsIfNecessary(ThreadContext context, XmlDocument doc) {
+        Ruby ruby = context.getRuntime();
+        RubyArray errors = ruby.newArray(this.errorHandler.getErrorsReadyForRuby(context));
+        doc.setInstanceVariable("@errors", errors);
+    }
+
+    public XmlDocument getDocumentWithErrorsOrRaiseException(ThreadContext context, Exception ex) {
+        if(this.continuesOnError()) {
+            XmlDocument doc = this.getNewEmptyDocument(context);
+            this.addErrorsIfNecessary(context, doc);
+            ((RubyArray) doc.getInstanceVariable("@errors")).append(new XmlSyntaxError(context.getRuntime(), ex));
+            return doc;
+        } else {
+            throw new RaiseException(new XmlSyntaxError(context.getRuntime(), ex));
+        }
+    }
+
+    protected XmlDocument getNewEmptyDocument(ThreadContext context) {
+        IRubyObject[] args = new IRubyObject[0];
+        return (XmlDocument) XmlDocument.rbNew(context,
+                    getNokogiriClass(context.getRuntime(), "Nokogiri::XML::Document"),
+                    args);
+    }
+
+    public boolean continuesOnError() {
+        return options.recover;
+    }
+
+    /**
+     * This method is broken out so that HtmlDomParserContext can
+     * override it.
+     */
+    protected XmlDocument wrapDocument(ThreadContext context,
+                                       RubyClass klass,
+                                       Document doc) {
+        XmlDocument xmlDocument = new XmlDocument(context.getRuntime(), klass, doc);
+        xmlDocument.setEncoding(ruby_encoding);
+        return xmlDocument;
+    }
+
+    /**
+     * Must call setInputSource() before this method.
+     */
+    public XmlDocument parse(ThreadContext context,
+                             IRubyObject klass,
+                             IRubyObject url) {
+        try {
+            Document doc = do_parse();
+            XmlDocument xmlDoc = wrapDocument(context, (RubyClass)klass, doc);
+            xmlDoc.setUrl(url);
+            addErrorsIfNecessary(context, xmlDoc);
+            return xmlDoc;
+        } catch (SAXException e) {
+            return getDocumentWithErrorsOrRaiseException(context, e);
+        } catch (IOException e) {
+            return getDocumentWithErrorsOrRaiseException(context, e);
+        }
+    }
+
+    protected Document do_parse() throws SAXException, IOException {
+        parser.parse(getInputSource());
+        if (options.noBlanks) {
+            List<Node> emptyNodes = new ArrayList<Node>();
+            findEmptyTexts(parser.getDocument(), emptyNodes);
+            if (emptyNodes.size() > 0) {
+                for (Node node : emptyNodes) {
+                    node.getParentNode().removeChild(node);
+                }
+            }
+        }
+        return parser.getDocument();
+    }
+    
+    private void findEmptyTexts(Node node, List<Node> emptyNodes) {
+        if (node.getNodeType() == Node.TEXT_NODE && "".equals(node.getTextContent().trim())) {
+            emptyNodes.add(node);
+        } else {
+            NodeList children = node.getChildNodes();
+            for (int i=0; i < children.getLength(); i++) {
+                findEmptyTexts(children.item(i), emptyNodes);
+            }
+        }
+    }
+}

data/ext/java/nokogiri/internals/XmlSaxParser.java

@@ -0,0 +1,33 @@
+package nokogiri.internals;
+
+import org.apache.xerces.parsers.SAXParser;
+import org.apache.xerces.xni.Augmentations;
+import org.apache.xerces.xni.XNIException;
+
+/**
+ * Extends SAXParser in order to receive xmlDecl events and pass them
+ * on to a handler.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+public class XmlSaxParser extends SAXParser {
+
+    protected XmlDeclHandler xmlDeclHandler = null;
+
+    public XmlSaxParser() {
+        super();
+    }
+
+    public void setXmlDeclHandler(XmlDeclHandler xmlDeclHandler) {
+        this.xmlDeclHandler = xmlDeclHandler;
+    }
+
+    @Override
+    public void xmlDecl(String version, String encoding, String standalone,
+                        Augmentations augs) throws XNIException {
+        super.xmlDecl(version, encoding, standalone, augs);
+        if (xmlDeclHandler != null) {
+            xmlDeclHandler.xmlDecl(version, encoding, standalone);
+        }
+    }
+}

data/ext/nokogiri/depend

@@ -0,0 +1,32 @@
+html_document.o: html_document.c
+html_element_description.o: html_element_description.c
+html_entity_lookup.o: html_entity_lookup.c
+html_sax_parser_context.o: html_sax_parser_context.c
+nokogiri.o: nokogiri.c
+xml_attr.o: xml_attr.c
+xml_attribute_decl.o: xml_attribute_decl.c
+xml_cdata.o: xml_cdata.c
+xml_comment.o: xml_comment.c
+xml_document.o: xml_document.c
+xml_document_fragment.o: xml_document_fragment.c
+xml_dtd.o: xml_dtd.c
+xml_element_content.o: xml_element_content.c
+xml_element_decl.o: xml_element_decl.c
+xml_encoding_handler.o: xml_encoding_handler.c
+xml_entity_decl.o: xml_entity_decl.c
+xml_entity_reference.o: xml_entity_reference.c
+xml_io.o: xml_io.c
+xml_namespace.o: xml_namespace.c
+xml_node.o: xml_node.c
+xml_node_set.o: xml_node_set.c
+xml_processing_instruction.o: xml_processing_instruction.c
+xml_reader.o: xml_reader.c
+xml_relax_ng.o: xml_relax_ng.c
+xml_sax_parser.o: xml_sax_parser.c
+xml_sax_parser_context.o: xml_sax_parser_context.c
+xml_sax_push_parser.o: xml_sax_push_parser.c
+xml_schema.o: xml_schema.c
+xml_syntax_error.o: xml_syntax_error.c
+xml_text.o: xml_text.c
+xml_xpath_context.o: xml_xpath_context.c
+xslt_stylesheet.o: xslt_stylesheet.c

data/ext/nokogiri/extconf.rb

@@ -17,7 +17,7 @@ end
 $CFLAGS << " #{ENV["CFLAGS"]}"
 $LIBS << " #{ENV["LIBS"]}"
 
-if Config::CONFIG['target_os'] == 'mingw32'
+if Config::CONFIG['target_os'] == 'mingw32' || Config::CONFIG['target_os'] =~ /mswin32/
   $CFLAGS << " -DXP_WIN -DXP_WIN32 -DUSE_INCLUDED_VASPRINTF"
 elsif Config::CONFIG['target_os'] =~ /solaris/
   $CFLAGS << " -DUSE_INCLUDED_VASPRINTF"
@@ -29,58 +29,87 @@ if RbConfig::MAKEFILE_CONFIG['CC'] =~ /mingw/
   $CFLAGS << " -DIN_LIBXML"
 end
 
-$CFLAGS << " -O3 -Wall -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline"
+if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
+  $CFLAGS << " -O3 -Wall -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline"
+end
+
+if Config::CONFIG['target_os'] =~ /mswin32/
+  lib_prefix = 'lib'
+
+  # There's no default include/lib dir on Windows. Let's just add the Ruby ones
+  # and resort on the search path specified by INCLUDE and LIB environment
+  # variables
+  HEADER_DIRS = [INCLUDEDIR]
+  LIB_DIRS = [LIBDIR]
+  XML2_HEADER_DIRS = [File.join(INCLUDEDIR, "libxml2"), INCLUDEDIR]
 
-HEADER_DIRS = [
-  # First search /opt/local for macports
-  '/opt/local/include',
+else
+  lib_prefix = ''
+
+  HEADER_DIRS = [
+    # First search /opt/local for macports
+    '/opt/local/include',
 
-  # Then search /usr/local for people that installed from source
-  '/usr/local/include',
+    # Then search /usr/local for people that installed from source
+    '/usr/local/include',
 
-  # Check the ruby install locations
-  INCLUDEDIR,
+    # Check the ruby install locations
+    INCLUDEDIR,
 
-  # Finally fall back to /usr
-  '/usr/include',
-  '/usr/include/libxml2',
-]
+    # Finally fall back to /usr
+    '/usr/include',
+    '/usr/include/libxml2',
+  ]
 
-LIB_DIRS = [
-  # First search /opt/local for macports
-  '/opt/local/lib',
+  LIB_DIRS = [
+    # First search /opt/local for macports
+    '/opt/local/lib',
 
-  # Then search /usr/local for people that installed from source
-  '/usr/local/lib',
+    # Then search /usr/local for people that installed from source
+    '/usr/local/lib',
 
-  # Check the ruby install locations
-  LIBDIR,
+    # Check the ruby install locations
+    LIBDIR,
 
-  # Finally fall back to /usr
-  '/usr/lib',
-]
+    # Finally fall back to /usr
+    '/usr/lib',
+  ]
+
+  XML2_HEADER_DIRS = [
+    '/opt/local/include/libxml2',
+    '/usr/local/include/libxml2',
+    File.join(INCLUDEDIR, "libxml2")
+  ] + HEADER_DIRS
+end
 
 dir_config('zlib', HEADER_DIRS, LIB_DIRS)
 dir_config('iconv', HEADER_DIRS, LIB_DIRS)
-dir_config('xml2', [
-           '/opt/local/include/libxml2',
-           '/usr/local/include/libxml2',
-           File.join(INCLUDEDIR, "libxml2")] + HEADER_DIRS, LIB_DIRS)
+dir_config('xml2', XML2_HEADER_DIRS, LIB_DIRS)
 dir_config('xslt', HEADER_DIRS, LIB_DIRS)
 
 def asplode(lib)
   abort "-----\n#{lib} is missing.  please visit http://nokogiri.org/tutorials/installing_nokogiri.html for help with installing dependencies.\n-----"
 end
 
-asplode "iconv"    unless find_header('iconv.h')
+# Use this with cross compiling
+# PKG_CONFIG_PATH=/Users/apatterson/git/nokogiri/tmp/cross/lib/pkgconfig/ \
+#   rake cross compile RUBY_CC_VERSION=1.9.1
+pkg_config('libxslt') if RUBY_PLATFORM =~ /mingw/
+
 asplode "libxml2"  unless find_header('libxml/parser.h')
 asplode "libxslt"  unless find_header('libxslt/xslt.h')
 asplode "libexslt" unless find_header('libexslt/exslt.h')
-asplode "zlib"     unless find_library('z', 'gzopen')
-asplode "libxml2"  unless find_library('xml2', 'xmlParseDoc')
-asplode "libxslt"  unless find_library('xslt', 'xsltParseStylesheetDoc')
-asplode "libexslt" unless find_library('exslt', 'exsltFuncRegister')
+asplode "libxml2"  unless find_library("#{lib_prefix}xml2", 'xmlParseDoc')
+asplode "libxslt"  unless find_library("#{lib_prefix}xslt", 'xsltParseStylesheetDoc')
+asplode "libexslt" unless find_library("#{lib_prefix}exslt", 'exsltFuncRegister')
+
+unless have_func('xmlHasFeature')
+  abort "-----\nThe function 'xmlHasFeature' is missing from your installation of libxml2.  Likely this means that your installed version of libxml2 is old enough that nokogiri will not work well.  To get around this problem, please upgrade your installation of libxml2.
+
+Please visit http://nokogiri.org/tutorials/installing_nokogiri.html for more help!"
+end
 
+have_func 'xmlFirstElementChild'
 have_func('xmlRelaxNGSetParserStructuredErrors')
 have_func('xmlRelaxNGSetParserStructuredErrors')
 have_func('xmlRelaxNGSetValidStructuredErrors')