nokogiri-fitzsimmons 1.5.5.3-java

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -0,0 +1,215 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2012:
+ *
+ * * {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.io.OutputStream;
+import java.nio.channels.Channels;
+import java.nio.channels.Pipe;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+
+import nokogiri.internals.ParserContext;
+
+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
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+@JRubyClass(name="Nokogiri::XML::SAX::PushParser")
+public class XmlSaxPushParser extends RubyObject {
+    ParserContext.Options options;
+    IRubyObject optionsRuby;
+    IRubyObject saxParser;
+    OutputStream ostream = null;
+    InputStream istream = null;
+    ParserTask parserTask = null;
+    FutureTask<XmlSaxParserContext> futureTask = null;
+    ExecutorService executor = null;
+
+    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);
+        this.saxParser = saxParser;
+        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) {
+        try {
+            initialize_task(context);
+        } catch (IOException e) {
+            throw context.getRuntime().newRuntimeError(e.getMessage());
+        }
+        byte[] data = null;
+        if (chunk instanceof RubyString || chunk.respondsTo("to_str")) {
+            data = chunk.convertToString().getBytes();
+        } else { 
+            try {
+                terminateTask();
+            } catch (IOException e) {
+                throw context.getRuntime().newRuntimeError(e.getMessage());
+            }
+            XmlSyntaxError xmlSyntaxError = 
+                (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SyntaxError"));
+            throw new RaiseException(xmlSyntaxError);
+        }
+
+        int errorCount0 = parserTask.getErrorCount();;
+        
+        try {
+            if (isLast.isTrue()) {
+                IRubyObject document = invoke(context, this, "document");
+                invoke(context, document, "end_document");
+                terminateTask();
+            } else {
+                ostream.write(data);
+                Thread.currentThread().sleep(10);   // gives a reader a chance to work
+            }
+        } catch (IOException e) {
+            throw context.getRuntime().newRuntimeError(e.getMessage());
+        } catch (InterruptedException e) {
+            throw context.getRuntime().newRuntimeError(e.getMessage());
+        }
+
+        if (!options.recover && parserTask.getErrorCount() > errorCount0) {
+            try {
+                terminateTask();
+            } catch (IOException e) {
+                throw context.getRuntime().newRuntimeError(e.getMessage());
+            }
+            throw new RaiseException(parserTask.getLastError(), true);
+        }
+
+        return this;
+    }
+    
+    private void initialize_task(ThreadContext context) throws IOException {
+        if (futureTask == null || ostream == null || istream == null) {
+            Pipe pipe = Pipe.open();
+            Pipe.SinkChannel sink = pipe.sink();
+            ostream = Channels.newOutputStream(sink);
+            Pipe.SourceChannel source = pipe.source();
+            istream = Channels.newInputStream(source);
+
+            parserTask = new ParserTask(context, saxParser);
+            futureTask = new FutureTask<XmlSaxParserContext>(parserTask);
+            executor = Executors.newSingleThreadExecutor();
+            executor.submit(futureTask);
+        }
+    }
+    
+    private synchronized void terminateTask() throws IOException {
+        futureTask.cancel(true);
+        executor.shutdown();
+        ostream.close();
+        istream.close();
+        ostream = null;
+        istream = null;
+    }
+    
+    private class ParserTask implements Callable<XmlSaxParserContext> {
+        private ThreadContext context;
+        private IRubyObject handler;
+        private XmlSaxParserContext parser;
+        
+        private ParserTask(ThreadContext context, IRubyObject handler) {
+            RubyClass klazz = getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SAX::ParserContext");
+            this.context = context;
+            this.handler = handler;
+            this.parser = (XmlSaxParserContext) XmlSaxParserContext.parse_stream(context, klazz, istream);
+        }
+
+        @Override
+        public XmlSaxParserContext call() throws Exception {
+            parser.parse_with(context, handler);
+            return parser;
+        }
+        
+        private synchronized int getErrorCount() {
+            // check for null because thread may not have started yet
+            if (parser.getNokogiriHandler() == null) return 0;
+            else return parser.getNokogiriHandler().getErrorCount();
+        }
+        
+        private synchronized RubyException getLastError() {
+            return (RubyException) parser.getNokogiriHandler().getLastError();
+        }
+    }
+}

data/ext/java/nokogiri/XmlSchema.java

@@ -0,0 +1,324 @@
+/**
+ * (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.getNokogiriClass;
+import static nokogiri.internals.NokogiriHelpers.adjustSystemIdIfNecessary;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+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.w3c.dom.ls.LSInput;
+import org.w3c.dom.ls.LSResourceResolver;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.SAXException;
+
+/**
+ * Class for Nokogiri::XML::Schema
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+@JRubyClass(name="Nokogiri::XML::Schema")
+public class XmlSchema extends RubyObject {
+    private Validator validator;
+
+    public XmlSchema(Ruby ruby, RubyClass klazz) {
+        super(ruby, klazz);
+    }
+    
+    /**
+     * Create and return a copy of this object.
+     *
+     * @return a clone of this object
+     */
+    @Override
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
+
+    private Schema getSchema(Source source, String currentDir, String scriptFileName) throws SAXException {
+        SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+        SchemaResourceResolver resourceResolver = new SchemaResourceResolver(currentDir, scriptFileName, null);
+        schemaFactory.setResourceResolver(resourceResolver); 
+        return schemaFactory.newSchema(source);
+    }
+    
+    private void setValidator(Validator validator) {
+        this.validator = validator;
+    }
+
+    static XmlSchema createSchemaInstance(ThreadContext context, RubyClass klazz, Source source) {
+        Ruby runtime = context.getRuntime();
+        XmlSchema xmlSchema = (XmlSchema) NokogiriService.XML_SCHEMA_ALLOCATOR.allocate(runtime, klazz);
+        xmlSchema.setInstanceVariable("@errors", runtime.newEmptyArray());
+        
+        try {
+            Schema schema = xmlSchema.getSchema(source, context.getRuntime().getCurrentDirectory(), context.getRuntime().getInstanceConfig().getScriptFileName());
+            xmlSchema.setValidator(schema.newValidator());
+            return xmlSchema;
+        } catch (SAXException ex) {
+            throw context.getRuntime().newRuntimeError("Could not parse document: " + ex.getMessage());
+        }
+    }
+
+    /*
+     * call-seq:
+     *  from_document(doc)
+     *
+     * Create a new Schema from the Nokogiri::XML::Document +doc+
+     */
+    @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 getSchema(context, (RubyClass)klazz, source);
+    }
+    
+    private static IRubyObject getSchema(ThreadContext context, RubyClass klazz, Source source) {
+        String moduleName = klazz.getName();
+        if ("Nokogiri::XML::Schema".equals(moduleName)) {
+            return XmlSchema.createSchemaInstance(context, klazz, source);
+        } else if ("Nokogiri::XML::RelaxNG".equals(moduleName)) {
+            return XmlRelaxng.createSchemaInstance(context, klazz, source);
+        }
+        return context.getRuntime().getNil();
+    }
+
+    @JRubyMethod(meta=true)
+    public static IRubyObject read_memory(ThreadContext context, IRubyObject klazz, IRubyObject content) {
+        String data = content.convertToString().asJavaString();
+        return getSchema(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, context.getRuntime().getNil());
+        XmlDocument xmlDocument = ctx.parse(context, getNokogiriClass(ruby, "Nokogiri::XML::Document"), ruby.getNil());
+        return validate_document_or_file(context, xmlDocument);
+    }
+    
+    IRubyObject validate_document_or_file(ThreadContext context, XmlDocument xmlDocument) {
+        RubyArray errors = (RubyArray) this.getInstanceVariable("@errors");
+        ErrorHandler errorHandler = new SchemaErrorHandler(context.getRuntime(), errors);
+        setErrorHandler(errorHandler);
+
+        try {
+            validate(xmlDocument.getDocument());
+        } catch(SAXException ex) {
+            XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SyntaxError"));
+            xmlSyntaxError.setException(ex);
+            errors.append(xmlSyntaxError);
+        } catch (IOException ex) {
+            throw context.getRuntime().newIOError(ex.getMessage());
+        }
+
+        return errors;
+    }
+    
+    protected void setErrorHandler(ErrorHandler errorHandler) {
+        validator.setErrorHandler(errorHandler);
+    }
+    
+    protected void validate(Document document) throws SAXException, IOException {
+        DOMSource docSource = new DOMSource(document);
+        validator.validate(docSource);
+    }
+    
+    private class SchemaResourceResolver implements LSResourceResolver {
+        SchemaLSInput lsInput = new SchemaLSInput();
+        String currentDir;
+        String scriptFileName;
+        //String defaultURI;
+        
+        SchemaResourceResolver(String currentDir, String scriptFileName, Object input) {
+            this.currentDir = currentDir;
+            this.scriptFileName = scriptFileName;
+            if (input == null) return;
+            if (input instanceof String) {
+                lsInput.setStringData((String)input);
+            } else if (input instanceof Reader) {
+                lsInput.setCharacterStream((Reader)input);
+            } else if (input instanceof InputStream) {
+                lsInput.setByteStream((InputStream)input);
+            }
+        }
+
+        @Override
+        public LSInput resolveResource(String type, String namespaceURI, String publicId, String systemId, String baseURI) {
+            String adjusted = adjustSystemIdIfNecessary(currentDir, scriptFileName, baseURI, systemId);
+            lsInput.setPublicId(publicId);
+            lsInput.setSystemId(adjusted);
+            lsInput.setBaseURI(baseURI);
+            return lsInput;
+        }
+    }
+    
+    private class SchemaLSInput implements LSInput {
+        protected String fPublicId;
+        protected String fSystemId;
+        protected String fBaseSystemId;
+        protected InputStream fByteStream;
+        protected Reader fCharStream;
+        protected String fData;
+        protected String fEncoding;
+        protected boolean fCertifiedText = false;
+        
+        @Override
+        public String getBaseURI() {
+            return fBaseSystemId;
+        }
+
+        @Override
+        public InputStream getByteStream() {
+            return fByteStream;
+        }
+
+        @Override
+        public boolean getCertifiedText() {
+            return fCertifiedText;
+        }
+
+        @Override
+        public Reader getCharacterStream() {
+            return fCharStream;
+        }
+
+        @Override
+        public String getEncoding() {
+            return fEncoding;
+        }
+
+        @Override
+        public String getPublicId() {
+            return fPublicId;
+        }
+
+        @Override
+        public String getStringData() {
+            return fData;
+        }
+
+        @Override
+        public String getSystemId() {
+            return fSystemId;
+        }
+
+        @Override
+        public void setBaseURI(String baseURI) {
+            fBaseSystemId = baseURI;
+        }
+
+        @Override
+        public void setByteStream(InputStream byteStream) {
+            fByteStream = byteStream;   
+        }
+
+        @Override
+        public void setCertifiedText(boolean certified) {
+            fCertifiedText = certified;
+        }
+
+        @Override
+        public void setCharacterStream(Reader charStream) {
+            fCharStream = charStream;
+        }
+
+        @Override
+        public void setEncoding(String encoding) {
+            fEncoding = encoding;
+        }
+
+        @Override
+        public void setPublicId(String pubId) {
+            fPublicId = pubId;
+        }
+
+        @Override
+        public void setStringData(String stringData) {
+            fData = stringData;
+        }
+
+        @Override
+        public void setSystemId(String sysId) {
+            fSystemId = sysId;
+        }
+        
+    }
+}