nokogiri 1.5.0.beta.3 → 1.5.0.beta.4

data/ext/java/nokogiri/XmlSaxParserContext.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2010:
+ * Copyright (c) 2008 - 2011:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -65,6 +65,7 @@ import org.xml.sax.SAXParseException;
  * Base class for the SAX parsers.
  *
  * @author Patrick Mahoney <pat@polycrystal.org>
+ * @author Yoko Harada <yokolet@gmail.com>
  */
 @JRubyClass(name="Nokogiri::XML::SAX::ParserContext")
 public class XmlSaxParserContext extends ParserContext {
@@ -82,14 +83,27 @@ public class XmlSaxParserContext extends ParserContext {
 
     public XmlSaxParserContext(final Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
-        replaceEntities = ruby.getTrue();
+    }
+        
+    protected void initialize(Ruby runtime) {
+        replaceEntities = runtime.getTrue();
         try {
             parser = createParser();
         } catch (SAXException se) {
-            throw RaiseException.createNativeRaiseException(ruby, se);
+            throw RaiseException.createNativeRaiseException(runtime, se);
         }
     }
 
+    /**
+     * Create and return a copy of this object.
+     *
+     * @return a clone of this object
+     */
+    @Override
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
+
     protected AbstractSAXParser createParser() throws SAXException {
         XmlSaxParser parser = new XmlSaxParser();
         parser.setFeature(FEATURE_NAMESPACE_PREFIXES, true);
@@ -105,8 +119,8 @@ public class XmlSaxParserContext extends ParserContext {
     public static IRubyObject parse_memory(ThreadContext context,
                                            IRubyObject klazz,
                                            IRubyObject data) {
-        XmlSaxParserContext ctx = new XmlSaxParserContext(context.getRuntime(),
-                                                          (RubyClass) klazz);
+        XmlSaxParserContext ctx = (XmlSaxParserContext) NokogiriService.XML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass) klazz);
+        ctx.initialize(context.getRuntime());
         ctx.setInputSource(context, data);
         return ctx;
     }
@@ -119,8 +133,8 @@ public class XmlSaxParserContext extends ParserContext {
     public static IRubyObject parse_file(ThreadContext context,
                                          IRubyObject klazz,
                                          IRubyObject data) {
-        XmlSaxParserContext ctx = new XmlSaxParserContext(context.getRuntime(),
-                                                          (RubyClass) klazz);
+        XmlSaxParserContext ctx = (XmlSaxParserContext) NokogiriService.XML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass) klazz);
+        ctx.initialize(context.getRuntime());
         ctx.setInputSourceFile(context, data);
         return ctx;
     }
@@ -137,8 +151,8 @@ public class XmlSaxParserContext extends ParserContext {
                                        IRubyObject data,
                                        IRubyObject enc) {
         //int encoding = (int)enc.convertToInteger().getLongValue();
-        XmlSaxParserContext ctx = new XmlSaxParserContext(context.getRuntime(),
-                                                          (RubyClass) klazz);
+        XmlSaxParserContext ctx = (XmlSaxParserContext) NokogiriService.XML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass) klazz);
+        ctx.initialize(context.getRuntime());
         ctx.setInputSource(context, data);
         return ctx;
     }
@@ -151,8 +165,8 @@ public class XmlSaxParserContext extends ParserContext {
     public static IRubyObject parse_stream(ThreadContext context,
                                            IRubyObject klazz,
                                            InputStream stream) {
-        XmlSaxParserContext ctx =
-            new XmlSaxParserContext(context.getRuntime(), (RubyClass)klazz);
+        XmlSaxParserContext ctx = (XmlSaxParserContext) NokogiriService.XML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass) klazz);
+        ctx.initialize(context.getRuntime());
         ctx.setInputSource(stream);
         return ctx;
     }

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2010:
+ * Copyright (c) 2008 - 2011:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -56,6 +56,8 @@ 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 {
@@ -112,7 +114,8 @@ public class XmlSaxPushParser extends RubyObject {
         if (chunk instanceof RubyString || chunk.respondsTo("to_str")) {
             data = chunk.convertToString().getBytes();
         } else {
-            throw new RaiseException(new XmlSyntaxError(context.getRuntime()));
+            XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SyntaxError"));
+            throw new RaiseException(xmlSyntaxError);
         }
 
         int errorCount0 = runner.getErrorCount();
@@ -161,8 +164,7 @@ public class XmlSaxPushParser extends RubyObject {
 
             this.context = context;
             this.handler = handler;
-            this.parser = (XmlSaxParserContext)
-                XmlSaxParserContext.parse_stream(context, klazz, stream);
+            this.parser = (XmlSaxParserContext) XmlSaxParserContext.parse_stream(context, klazz, stream);
         }
 
         public void run() {

data/ext/java/nokogiri/XmlSchema.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2010:
+ * Copyright (c) 2008 - 2011:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -35,6 +35,8 @@ package nokogiri;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
 import java.io.StringReader;
 
 import javax.xml.XMLConstants;
@@ -60,6 +62,8 @@ 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;
 
@@ -67,52 +71,63 @@ 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 {
-
-    protected Source source;
+    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(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;
+    private Schema getSchema(Source source, String currentDir) throws SAXException {
+        SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
+        SchemaResourceResolver resourceResolver = new SchemaResourceResolver(currentDir, null);
+        schemaFactory.setResourceResolver(resourceResolver); 
+        return schemaFactory.newSchema(source);
+    }
+    
+    private void setValidator(Validator validator) {
+        this.validator = validator;
     }
 
-    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);
+    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());
+            xmlSchema.setValidator(schema.newValidator());
+            return xmlSchema;
+        } catch (SAXException ex) {
+            throw context.getRuntime().newRuntimeError("Could not parse document: " + ex.getMessage());
         }
-        schema.source = source;
-
-        schema.setInstanceVariable("@errors", ruby.newEmptyArray());
-        return schema;
     }
 
+    /*
+     * 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()) {
+        if (!errors.isEmpty()) {
             throw new RaiseException((XmlSyntaxError) errors.first());
         }
 
@@ -120,20 +135,27 @@ public class XmlSchema extends RubyObject {
 
         IRubyObject uri = doc.url(context);
         
-        if(!uri.isNil()) {
+        if (!uri.isNil()) {
             source.setSystemId(uri.convertToString().asJavaString());
         }
-
-        return createSchemaWithSource(context, (RubyClass) klazz, source);
+        
+        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 createSchemaWithSource(context, (RubyClass) klazz,
-                new StreamSource(new StringReader(data)));
+        return getSchema(context, (RubyClass) klazz, new StreamSource(new StringReader(data)));
     }
 
     @JRubyMethod(visibility=Visibility.PRIVATE)
@@ -151,25 +173,147 @@ public class XmlSchema extends RubyObject {
         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();
-
+    IRubyObject validate_document_or_file(ThreadContext context, XmlDocument xmlDocument) {
         RubyArray errors = (RubyArray) this.getInstanceVariable("@errors");
         ErrorHandler errorHandler = new SchemaErrorHandler(context.getRuntime(), errors);
-
-        validator.setErrorHandler(errorHandler);
+        setErrorHandler(errorHandler);
 
         try {
-            validator.validate(docSource);
+            validate(xmlDocument.getDocument());
         } catch(SAXException ex) {
-            errors.append(new XmlSyntaxError(context.getRuntime(), 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 defaultURI;
+        
+        SchemaResourceResolver(String currentDir, Object input) {
+            defaultURI = currentDir + "/nokogiri_default_fake.xsd";
+            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) {
+            lsInput.setPublicId(publicId);
+            lsInput.setSystemId(systemId);
+            lsInput.setBaseURI(baseURI != null ? baseURI : defaultURI);
+            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;
+        }
+        
+    }
 }

data/ext/java/nokogiri/XmlSyntaxError.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2010:
+ * Copyright (c) 2008 - 2011:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -32,12 +32,12 @@
 
 package nokogiri;
 
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 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;
@@ -47,58 +47,64 @@ import org.xml.sax.SAXParseException;
 /**
  * Class for Nokogiri::XML::SyntaxError
  *
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
  */
 @JRubyClass(name="Nokogiri::XML::SyntaxError", parent="Nokogiri::SyntaxError")
 public class XmlSyntaxError extends RubyException {
+    private Exception exception;
 
-    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 runtime, RubyClass klazz) {
+        super(runtime, klazz);
     }
-
-    public XmlSyntaxError(Ruby ruby, RubyClass rubyClass) {
-        super(ruby, rubyClass);
+    
+    /**
+     * Create and return a copy of this object.
+     *
+     * @return a clone of this object
+     */
+    @Override
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
     }
 
-    public XmlSyntaxError(Ruby ruby, Exception ex) {
-        this(ruby);
+    public XmlSyntaxError(Ruby runtime, RubyClass rubyClass, Exception ex) {
+        super(runtime, rubyClass, ex.getMessage());
         this.exception = ex;
     }
 
-    public XmlSyntaxError(Ruby ruby, RubyClass rubyClass, Exception ex) {
-        super(ruby, rubyClass, ex.getMessage());
-        this.exception = ex;
+    public static XmlSyntaxError createWarning(Ruby runtime, SAXParseException e) {
+        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
+        xmlSyntaxError.setException(runtime, e, 1);
+        return xmlSyntaxError;
     }
 
-    public static XmlSyntaxError createWarning(Ruby ruby, SAXParseException e) {
-        return new XmlSyntaxError(ruby, e, 1);
+    public static XmlSyntaxError createError(Ruby runtime, SAXParseException e) {
+        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
+        xmlSyntaxError.setException(runtime, e, 2);
+        return xmlSyntaxError;
     }
 
-    public static XmlSyntaxError createError(Ruby ruby, SAXParseException e) {
-        return new XmlSyntaxError(ruby, e, 2);
+    public static XmlSyntaxError createFatalError(Ruby runtime, SAXParseException e) {
+        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
+        xmlSyntaxError.setException(runtime, e, 3);
+        return xmlSyntaxError;
     }
-
-    public static XmlSyntaxError createFatalError(Ruby ruby, SAXParseException e) {
-        return new XmlSyntaxError(ruby, e, 3);
+    
+    public void setException(Exception exception) {
+        this.exception = exception;
     }
-
-    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 void setException(Ruby runtime, Exception exception, int level) {
+        this.exception = exception;
+        setInstanceVariable("@level", runtime.newFixnum(level));
+        setInstanceVariable("@line", runtime.newFixnum(((SAXParseException)exception).getLineNumber()));
+        setInstanceVariable("@column", runtime.newFixnum(((SAXParseException)exception).getColumnNumber()));
+        setInstanceVariable("@file", stringOrNil(runtime, ((SAXParseException)exception).getSystemId()));
     }
 
     public static RubyException createXPathSyntaxError(Ruby runtime, Exception e) {
-        RubyClass klazz = (RubyClass)
-            runtime.getClassFromPath("Nokogiri::XML::XPath::SyntaxError");
+        RubyClass klazz = (RubyClass)runtime.getClassFromPath("Nokogiri::XML::XPath::SyntaxError");
         return new XmlSyntaxError(runtime, klazz, e);
     }
 
@@ -108,7 +114,6 @@ public class XmlSyntaxError extends RubyException {
         if (exception != null && exception.getMessage() != null)
             return context.getRuntime().newString(exception.getMessage());
         else
-            return super.to_s(context);
-            
+            return super.to_s(context);  
     }
 }