nokogiri-backupify 1.5.0.beta.4

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -0,0 +1,182 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2010:
+ *
+ * * {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.getNokogiriClass;
+import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.channels.ClosedChannelException;
+
+import nokogiri.internals.ParserContext;
+import nokogiri.internals.PushInputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Class for Nokogiri::XML::SAX::PushParser
+ *
+ */
+@JRubyClass(name="Nokogiri::XML::SAX::PushParser")
+public class XmlSaxPushParser extends RubyObject {
+    ParserContext.Options options;
+    IRubyObject optionsRuby;
+    PushInputStream stream;
+    Thread reader;
+    Runner runner;
+
+    public XmlSaxPushParser(Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    @JRubyMethod
+    public IRubyObject initialize_native(final ThreadContext context,
+                                         IRubyObject _saxParser,
+                                         IRubyObject fileName) {
+        optionsRuby = invoke(context,
+                             context.getRuntime().getClassFromPath("Nokogiri::XML::ParseOptions"),
+                             "new");
+        options = new ParserContext.Options(0);
+        stream = new PushInputStream();
+
+        runner = new Runner(context, this, stream);
+        reader = new Thread(runner);
+        reader.start();
+
+        return this;
+    }
+
+    /**
+     * Returns an integer.
+     */
+    @JRubyMethod(name="options")
+    public IRubyObject getOptions(ThreadContext context) {
+        return invoke(context, optionsRuby, "options");
+    }
+
+    /**
+     * <code>val</code> is an integer.
+     */
+    @JRubyMethod(name="options=")
+    public IRubyObject setOptions(ThreadContext context, IRubyObject val) {
+        invoke(context, optionsRuby, "options=", val);
+        options =
+            new ParserContext.Options(val.convertToInteger().getLongValue());
+        return getOptions(context);
+    }
+
+    @JRubyMethod
+    public IRubyObject native_write(ThreadContext context, IRubyObject chunk,
+                                    IRubyObject isLast) {
+        byte[] data = null;
+        if (chunk instanceof RubyString || chunk.respondsTo("to_str")) {
+            data = chunk.convertToString().getBytes();
+        } else {
+            throw new RaiseException(new XmlSyntaxError(context.getRuntime()));
+        }
+
+        int errorCount0 = runner.getErrorCount();
+
+        try {
+            stream.writeAndWaitForRead(data);
+        } catch (ClosedChannelException e) {
+            // ignore
+        } catch (IOException e) {
+            throw context.getRuntime().newRuntimeError(e.toString());
+        }
+
+        if (isLast.isTrue()) {
+            try {
+                stream.close();
+            } catch (IOException e) {
+                // ignore
+            }
+
+            for (;;) {
+                try {
+                    reader.join();
+                    break;
+                } catch (InterruptedException e) {
+                    // continue loop
+                }
+            }
+        }
+
+        if (!options.recover && runner.getErrorCount() > errorCount0) {
+            throw new RaiseException(runner.getLastError(), true);
+        }
+
+        return this;
+    }
+
+    protected static class Runner implements Runnable {
+        protected ThreadContext context;
+        protected IRubyObject handler;
+        protected XmlSaxParserContext parser;
+
+        public Runner(ThreadContext context,
+                      IRubyObject handler,
+                      InputStream stream) {
+            RubyClass klazz = getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SAX::ParserContext");
+
+            this.context = context;
+            this.handler = handler;
+            this.parser = (XmlSaxParserContext)
+                XmlSaxParserContext.parse_stream(context, klazz, stream);
+        }
+
+        public void run() {
+            parser.parse_with(context, handler);
+        }
+
+        public int getErrorCount() {
+            // check for null because thread may nto have started yet
+            if (parser.getNokogiriHandler() == null) return 0;
+            else return parser.getNokogiriHandler().getErrorCount();
+        }
+
+        public RubyException getLastError() {
+            return (RubyException) parser.getNokogiriHandler().getLastError();
+        }
+    }
+}

data/ext/java/nokogiri/XmlSchema.java

@@ -0,0 +1,175 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2010:
+ *
+ * * {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.getNokogiriClass;
+
+import java.io.IOException;
+import java.io.StringReader;
+
+import javax.xml.XMLConstants;
+import javax.xml.transform.Source;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+import javax.xml.validation.Validator;
+
+import nokogiri.internals.SchemaErrorHandler;
+import nokogiri.internals.XmlDomParserContext;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Visibility;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Document;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.SAXException;
+
+/**
+ * Class for Nokogiri::XML::Schema
+ * 
+ * @author sergio
+ */
+@JRubyClass(name="Nokogiri::XML::Schema")
+public class XmlSchema extends RubyObject {
+
+    protected Source source;
+
+    public XmlSchema(Ruby ruby, RubyClass klazz) {
+        super(ruby, klazz);
+    }
+
+    private Schema getSchema(ThreadContext context) {
+
+        Schema schema = null;
+
+        String uri=XMLConstants.W3C_XML_SCHEMA_NS_URI;
+
+        try {
+            schema = SchemaFactory.newInstance(uri).newSchema(source);
+        } catch(SAXException ex) {
+            throw context.getRuntime().newRuntimeError("Could not parse document: "+ex.getMessage());
+        }
+        return schema;
+    }
+
+    protected static XmlSchema createSchemaWithSource(ThreadContext context, RubyClass klazz, Source source) {
+        Ruby ruby = context.getRuntime();
+        XmlSchema schema = null;
+        if( klazz.ancestors(context).include_p(context,
+                getNokogiriClass(ruby, "Nokogiri::XML::RelaxNG")).isTrue()) {
+            schema = new XmlRelaxng(ruby, klazz);
+        } else {
+            schema = new XmlSchema(ruby, klazz);
+        }
+        schema.source = source;
+
+        schema.setInstanceVariable("@errors", ruby.newEmptyArray());
+        return schema;
+    }
+
+    @JRubyMethod(meta=true)
+    public static IRubyObject from_document(ThreadContext context, IRubyObject klazz, IRubyObject document) {
+        XmlDocument doc = ((XmlDocument) ((XmlNode) document).document(context));
+
+        RubyArray errors = (RubyArray) doc.getInstanceVariable("@errors");
+
+        if(!errors.isEmpty()) {
+            throw new RaiseException((XmlSyntaxError) errors.first());
+        }
+
+        DOMSource source = new DOMSource(doc.getDocument());
+
+        IRubyObject uri = doc.url(context);
+        
+        if(!uri.isNil()) {
+            source.setSystemId(uri.convertToString().asJavaString());
+        }
+
+        return createSchemaWithSource(context, (RubyClass) klazz, source);
+    }
+
+    @JRubyMethod(meta=true)
+    public static IRubyObject read_memory(ThreadContext context, IRubyObject klazz, IRubyObject content) {
+        
+        String data = content.convertToString().asJavaString();
+
+        return createSchemaWithSource(context, (RubyClass) klazz,
+                new StreamSource(new StringReader(data)));
+    }
+
+    @JRubyMethod(visibility=Visibility.PRIVATE)
+    public IRubyObject validate_document(ThreadContext context, IRubyObject document) {
+        return validate_document_or_file(context, (XmlDocument)document);
+    }
+    
+    @JRubyMethod(visibility=Visibility.PRIVATE)
+    public IRubyObject validate_file(ThreadContext context, IRubyObject file) {
+        Ruby ruby = context.getRuntime();
+
+        XmlDomParserContext ctx = new XmlDomParserContext(ruby, RubyFixnum.newFixnum(ruby, 1L));
+        ctx.setInputSource(context, file);
+        XmlDocument xmlDocument = ctx.parse(context, getNokogiriClass(ruby, "Nokogiri::XML::Document"), ruby.getNil());
+        return validate_document_or_file(context, xmlDocument);
+    }
+    
+    private IRubyObject validate_document_or_file(ThreadContext context, XmlDocument xmlDocument) {
+        Document doc = xmlDocument.getDocument();
+
+        DOMSource docSource = new DOMSource(doc);
+        Validator validator = getSchema(context).newValidator();
+
+        RubyArray errors = (RubyArray) this.getInstanceVariable("@errors");
+        ErrorHandler errorHandler = new SchemaErrorHandler(context.getRuntime(), errors);
+
+        validator.setErrorHandler(errorHandler);
+
+        try {
+            validator.validate(docSource);
+        } catch(SAXException ex) {
+            errors.append(new XmlSyntaxError(context.getRuntime(), ex));
+        } catch (IOException ex) {
+            throw context.getRuntime().newIOError(ex.getMessage());
+        }
+
+        return errors;
+    }
+}

data/ext/java/nokogiri/XmlSyntaxError.java

@@ -0,0 +1,114 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2010:
+ *
+ * * {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.stringOrNil;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyModule;
+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.SAXParseException;
+
+/**
+ * Class for Nokogiri::XML::SyntaxError
+ *
+ */
+@JRubyClass(name="Nokogiri::XML::SyntaxError", parent="Nokogiri::SyntaxError")
+public class XmlSyntaxError extends RubyException {
+
+    protected Exception exception;
+
+    public static RubyClass getRubyClass(Ruby ruby) {
+        return ((RubyModule) ruby.getModule("Nokogiri").getConstant("XML")).getClass("SyntaxError");
+    }
+
+    public XmlSyntaxError(Ruby ruby){
+        this(ruby, getRubyClass(ruby));
+    }
+
+    public XmlSyntaxError(Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    public XmlSyntaxError(Ruby ruby, Exception ex) {
+        this(ruby);
+        this.exception = ex;
+    }
+
+    public XmlSyntaxError(Ruby ruby, RubyClass rubyClass, Exception ex) {
+        super(ruby, rubyClass, ex.getMessage());
+        this.exception = ex;
+    }
+
+    public static XmlSyntaxError createWarning(Ruby ruby, SAXParseException e) {
+        return new XmlSyntaxError(ruby, e, 1);
+    }
+
+    public static XmlSyntaxError createError(Ruby ruby, SAXParseException e) {
+        return new XmlSyntaxError(ruby, e, 2);
+    }
+
+    public static XmlSyntaxError createFatalError(Ruby ruby, SAXParseException e) {
+        return new XmlSyntaxError(ruby, e, 3);
+    }
+
+    public XmlSyntaxError(Ruby ruby, SAXParseException e, int level) {
+        super(ruby, getRubyClass(ruby), e.getMessage());
+        this.exception = e;
+        setInstanceVariable("@level", ruby.newFixnum(level));
+        setInstanceVariable("@line", ruby.newFixnum(e.getLineNumber()));
+        setInstanceVariable("@column", ruby.newFixnum(e.getColumnNumber()));
+        setInstanceVariable("@file", stringOrNil(ruby, e.getSystemId()));
+    }
+
+    public static RubyException createXPathSyntaxError(Ruby runtime, Exception e) {
+        RubyClass klazz = (RubyClass)
+            runtime.getClassFromPath("Nokogiri::XML::XPath::SyntaxError");
+        return new XmlSyntaxError(runtime, klazz, e);
+    }
+
+    @Override
+    @JRubyMethod(name = "to_s")
+    public IRubyObject to_s(ThreadContext context) {
+        if (exception != null && exception.getMessage() != null)
+            return context.getRuntime().newString(exception.getMessage());
+        else
+            return super.to_s(context);
+            
+    }
+}