nokogiri 1.5.0.beta.1-java → 1.5.0.beta.2-java

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -0,0 +1,146 @@
+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;
+
+@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,142 @@
+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;
+
+/**
+ *
+ * @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,84 @@
+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.xml.sax.SAXParseException;
+
+@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);
+    }
+
+    // public static RubyException getXPathSyntaxError(ThreadContext context, Exception ex) {
+    //     Ruby ruby = context.getRuntime();
+    //     RubyClass klazz = (RubyClass) ruby.getClassFromPath("Nokogiri::XML::XPath::SyntaxError");
+    //     return new XmlSyntaxError(ruby, klazz, ex);
+    // }
+
+    //TODO: Return correct message, domain, etc.
+
+//     @JRubyMethod
+//     @Override
+//     public IRubyObject message(ThreadContext context) {
+//         if(this.exception != null) {
+//             return context.getRuntime().newString(this.exception.toString());
+//         } else {
+//             return context.getRuntime().newString("no message");
+//         }
+//     }
+
+}

data/ext/java/nokogiri/XmlText.java

@@ -0,0 +1,96 @@
+package nokogiri;
+
+import static nokogiri.internals.NokogiriHelpers.isXmlEscaped;
+import static nokogiri.internals.NokogiriHelpers.stringOrNil;
+import nokogiri.internals.NokogiriHelpers;
+import nokogiri.internals.SaveContext;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+@JRubyClass(name="Nokogiri::XML::Text", parent="Nokogiri::XML::CharacterData")
+public class XmlText extends XmlNode {
+    public XmlText(Ruby ruby, RubyClass rubyClass, Node node) {
+        super(ruby, rubyClass, node);
+    }
+
+    public XmlText(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+    }
+
+    @Override
+    protected void init(ThreadContext context, IRubyObject[] args) {
+        if (args.length < 2) {
+            throw getRuntime().newArgumentError(args.length, 2);
+        }
+
+        content = args[0];
+        IRubyObject xNode = args[1];
+
+        XmlNode xmlNode = asXmlNode(context, xNode);
+        XmlDocument xmlDoc = (XmlDocument)xmlNode.document(context);
+        doc = xmlDoc;
+        Document document = xmlDoc.getDocument();
+        // text node content should not be encoded when it is created by Text node.
+        // while content should be encoded when it is created by Element node.
+        Node node = document.createTextNode((String)content.toJava(String.class));
+        setNode(node);
+    }
+    
+    @Override
+    protected IRubyObject getNodeName(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), "text");
+    }
+    
+    @Override
+    @JRubyMethod(name = {"content", "text", "inner_text"})
+    public IRubyObject content(ThreadContext context) {
+        if (content == null || content.isNil()) {
+            return stringOrNil(context.getRuntime(), node.getTextContent());
+        } else {
+            return content;
+        }
+    }
+
+    @Override
+    public void saveContent(ThreadContext context, SaveContext ctx) {
+        String textContent = node.getTextContent();
+        
+        if (!isXmlEscaped(textContent)) {        
+            textContent = NokogiriHelpers.encodeJavaString(textContent);
+        }
+        if (getEncoding(context, ctx) == null) {
+            textContent = encodeStringToHtmlEntity(textContent);
+        }
+        ctx.append(textContent);
+    }
+    
+    private String getEncoding(ThreadContext context, SaveContext ctx) {
+        String encoding  = ctx.getEncoding();
+        if (encoding != null) return encoding;
+        XmlDocument xmlDocument = (XmlDocument)document(context);
+        IRubyObject ruby_encoding = xmlDocument.encoding(context);
+        if (!ruby_encoding.isNil()) {
+            encoding = (String)ruby_encoding.toJava(String.class);
+        }
+        return encoding;
+    }
+    
+    private String encodeStringToHtmlEntity(String text) {
+        int last = 126; // = U+007E. No need to encode under U+007E.
+        StringBuffer sb = new StringBuffer();
+        for (int i=0; i<text.length(); i++) {
+            int codePoint = text.codePointAt(i);
+            if (codePoint > last) sb.append("&#x" + Integer.toHexString(codePoint) + ";");
+            else sb.append(text.charAt(i));
+        }
+        return new String(sb);
+    }
+}