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

data/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java

@@ -0,0 +1,23 @@
+package nokogiri.internals;
+
+import javax.xml.namespace.QName;
+import javax.xml.xpath.XPathFunction;
+import javax.xml.xpath.XPathFunctionResolver;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author sergio
+ */
+public class NokogiriXPathFunctionResolver implements XPathFunctionResolver {
+
+    private IRubyObject handler;
+    
+    public NokogiriXPathFunctionResolver(IRubyObject handler) {
+        this.handler = handler;
+    }
+
+    public XPathFunction resolveFunction(QName name, int arity) {
+        return new NokogiriXPathFunction(this.handler, name.getLocalPart(), arity);
+    }
+}

data/ext/java/nokogiri/internals/ParserContext.java

@@ -0,0 +1,235 @@
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
+import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyIO;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.TypeConverter;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.ext.EntityResolver2;
+
+/**
+ * Base class for the various parser contexts.  Handles converting
+ * Ruby objects to InputSource objects.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+public class ParserContext extends RubyObject {
+    protected InputSource source = null;
+
+    /**
+     * Create a file base input source taking into account the current
+     * directory of <code>runtime</code>.
+     */
+    public static InputSource resolveEntity(Ruby runtime,
+                                            String publicId,
+                                            String baseURI,
+                                            String systemId)
+        throws IOException {
+        String path;
+
+        if ((new File(systemId)).isAbsolute()) {
+            path = systemId;
+        } else if (baseURI != null) {
+            path = (new File(baseURI, systemId)).getAbsolutePath();
+        } else {
+            String rubyDir = runtime.getCurrentDirectory();
+            path = (new File(rubyDir, systemId)).getAbsolutePath();
+        }
+
+        InputSource s = new InputSource(new FileInputStream(path));
+        s.setSystemId(systemId);
+        s.setPublicId(publicId);
+        return s;
+    }
+
+    public ParserContext(Ruby runtime) {
+        // default to class 'Object' because this class isn't exposed to Ruby
+        super(runtime, runtime.getObject());
+    }
+
+    public ParserContext(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+    }
+
+    protected InputSource getInputSource() {
+        return source;
+    }
+
+    /**
+     * Set the InputSource from <code>data</code> which may be an IO
+     * object, a String, or a StringIO.
+     */
+    public void setInputSource(ThreadContext context,
+                               IRubyObject data) {
+        Ruby ruby = context.getRuntime();
+
+        if (invoke(context, data, "respond_to?",
+                   ruby.newSymbol("to_io").to_sym()).isTrue()) {
+            /* IO or other object that responds to :to_io */
+            RubyIO io =
+                (RubyIO) TypeConverter.convertToType(data,
+                                                     ruby.getIO(),
+                                                     "to_io");
+            source = new InputSource(io.getInStream());
+        } else {
+            RubyString str;
+            if (invoke(context, data, "respond_to?",
+                          ruby.newSymbol("string").to_sym()).isTrue()) {
+                /* StringIO or other object that responds to :string */
+                str = invoke(context, data, "string").convertToString();
+            } else if (data instanceof RubyString) {
+                str = (RubyString) data;
+            } else {
+                throw ruby.newArgumentError(
+                    "must be kind_of String or respond to :to_io or :string");
+            }
+
+            ByteList bytes = str.getByteList();
+            source = new InputSource(new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length()));
+        }
+    }
+
+    /**
+     * Set the InputSource to read from <code>file</code>, a String filename.
+     */
+    public void setInputSourceFile(ThreadContext context, IRubyObject file) {
+        String filename = rubyStringToString(file);
+
+        try{
+            source = resolveEntity(context.getRuntime(),
+                                   null, null, filename);
+        } catch (Exception e) {
+            throw RaiseException
+                .createNativeRaiseException(context.getRuntime(), e);
+        }
+
+    }
+
+    /**
+     * Set the InputSource from <code>stream</code>.
+     */
+    public void setInputSource(InputStream stream) {
+        source = new InputSource(stream);
+    }
+
+    /**
+     * Wrap Nokogiri parser options in a utility class.  This is
+     * read-only.
+     */
+    public static class Options {
+        protected static final long STRICT = 0;
+        protected static final long RECOVER = 1;
+        protected static final long NOENT = 2;
+        protected static final long DTDLOAD = 4;
+        protected static final long DTDATTR = 8;
+        protected static final long DTDVALID = 16;
+        protected static final long NOERROR = 32;
+        protected static final long NOWARNING = 64;
+        protected static final long PEDANTIC = 128;
+        protected static final long NOBLANKS = 256;
+        protected static final long SAX1 = 512;
+        protected static final long XINCLUDE = 1024;
+        protected static final long NONET = 2048;
+        protected static final long NODICT = 4096;
+        protected static final long NSCLEAN = 8192;
+        protected static final long NOCDATA = 16384;
+        protected static final long NOXINCNODE = 32768;
+
+        public boolean strict;
+        public boolean recover;
+        public boolean noEnt;
+        public boolean dtdLoad;
+        public boolean dtdAttr;
+        public boolean dtdValid;
+        public boolean noError;
+        public boolean noWarning;
+        public boolean pedantic;
+        public boolean noBlanks;
+        public boolean sax1;
+        public boolean xInclude;
+        public boolean noNet;
+        public boolean noDict;
+        public boolean nsClean;
+        public boolean noCdata;
+        public boolean noXIncNode;
+
+        protected static boolean test(long options, long mask) {
+            return ((options & mask) == mask);
+        }
+
+        public Options(long options) {
+            strict = ((options & RECOVER) == STRICT);
+            recover = test(options, RECOVER);
+            noEnt = test(options, NOENT);
+            dtdLoad = test(options, DTDLOAD);
+            dtdAttr = test(options, DTDATTR);
+            dtdValid = test(options, DTDVALID);
+            noError = test(options, NOERROR);
+            noWarning = test(options, NOWARNING);
+            pedantic = test(options, PEDANTIC);
+            noBlanks = test(options, NOBLANKS);
+            sax1 = test(options, SAX1);
+            xInclude = test(options, XINCLUDE);
+            noNet = test(options, NONET);
+            noDict = test(options, NODICT);
+            nsClean = test(options, NSCLEAN);
+            noCdata = test(options, NOCDATA);
+            noXIncNode = test(options, NOXINCNODE);
+        }
+    }
+
+    /**
+     * An entity resolver aware of the fact that the Ruby runtime can
+     * change directory but the JVM cannot.  Thus any file based
+     * entity resolution that uses relative paths must be translated
+     * to be relative to the current directory of the Ruby runtime.
+     */
+    public static class ChdirEntityResolver implements EntityResolver2 {
+        protected Ruby runtime;
+
+        public ChdirEntityResolver(Ruby runtime) {
+            super();
+            this.runtime = runtime;
+        }
+
+        @Override
+        public InputSource getExternalSubset(String name, String baseURI)
+            throws SAXException, IOException {
+            return null;
+        }
+
+        @Override
+        public InputSource resolveEntity(String publicId, String systemId)
+            throws SAXException, IOException {
+            return resolveEntity(null, publicId, null, systemId);
+        }
+
+        @Override
+        public InputSource resolveEntity(String name,
+                                         String publicId,
+                                         String baseURI,
+                                         String systemId)
+            throws SAXException, IOException {
+            return ParserContext
+                .resolveEntity(runtime, publicId, baseURI, systemId);
+        }
+
+    }
+
+}

data/ext/java/nokogiri/internals/PushInputStream.java

@@ -0,0 +1,381 @@
+package nokogiri.internals;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.nio.channels.ClosedChannelException;
+import java.lang.Math;
+import java.lang.Thread;
+import java.util.ArrayList;
+
+
+/**
+ * Implements a "push" InputStream.  An owner thread create an
+ * InputStream and passes it to a second thread.  The owner thread
+ * calls PushInputStream.write() to write data to the stream.  The
+ * second thread calls PushInputStream.read() and other InputStream
+ * methods.
+ *
+ * You should ensure that only one thread write to, and only one
+ * thread reads to, this stream, though nothing enforces this
+ * strictly.
+ */
+public class PushInputStream extends InputStream {
+    /**
+     * Current position in the stream relative to the start of the
+     * buffer.
+     */
+    protected int pos;
+
+    /**
+     * Current mark position, or -1 if there is no mark.
+     */
+    protected int mark;
+
+    protected int readlimit;
+
+    /**
+     * State is open or closed.
+     */
+    protected boolean isOpen;
+
+    protected Buffer buffer;
+
+    public PushInputStream() {
+        pos = 0;
+        mark = -1;
+        readlimit = -1;
+        isOpen = true;
+
+        buffer = new Buffer(512);
+    }
+
+    protected synchronized void ensureOpen() throws IOException {
+        if (!isOpen) {
+            throw new ClosedChannelException();
+        }
+    }
+
+    /**
+     * Write data that can be read from the stream.
+     */
+    public synchronized void write(byte[] b) {
+        if (buffer == null) System.out.println("BUFFER IS NULL");
+        if (b == null) System.out.println("BYTE ARRAY IS NILL");
+        buffer.put(b);
+        notifyAll();            // notify readers waiting
+    }
+
+    /**
+     * Write data and then wait until all the data has been read
+     * (waits until the thread reading from this stream is blocked in
+     * a read()).
+     */
+    public synchronized void writeAndWaitForRead(byte[] b) throws IOException {
+        ensureOpen();
+        write(b);
+        for (;;) {
+            try {
+                wait();
+                break;
+            } catch (InterruptedException e) {
+                // continue waiting
+            }
+        }
+    }
+
+    /*
+     *------------------------------------------------------------
+     * InputStream methods
+     *------------------------------------------------------------
+     */
+
+    /**
+     * @see InputStream.available()
+     */
+    @Override
+    public synchronized int available() throws IOException {
+        ensureOpen();
+        return buffer.size() - pos;
+    }
+
+    int nClose = 0;
+    /**
+     * @see InputStream.close()
+     */
+    @Override
+    public synchronized void close() throws IOException {
+        if (!isOpen) return;
+        isOpen = false;
+        buffer = null;
+        notifyAll();
+    }
+
+    /**
+     * @see InputStream.mark()
+     */
+    @Override
+    public synchronized void mark(int readlimit) {
+        this.mark = pos;
+        this.readlimit = readlimit;
+    }
+
+    /**
+     * Mark the current position in this stream.  Supported by
+     * PushInputStream.
+     *
+     * @see InputStream.markSupported()
+     */
+    @Override
+    public synchronized boolean markSupported() {
+        return true;
+    }
+
+    /**
+     * @see InputStream.read()
+     */
+    @Override
+    public synchronized int read() throws IOException {
+        ensureOpen();
+        byte[] b = new byte[1];
+        read(b, 0, 1);
+        return (int) b[0];
+    }
+
+    /**
+     * @see InputStream.read(byte[])
+     */
+    @Override
+    public synchronized int read(byte[] b) throws IOException {
+        ensureOpen();
+        return read(b, 0, b.length);
+    }
+
+    protected synchronized boolean markIsValid() {
+        return (mark >= 0 && pos < mark+readlimit);
+    }
+
+    /**
+     * @see InputStream.read(byte[], int, int)
+     */
+    @Override
+    public synchronized int read(byte[] b, int off, int len) throws IOException {
+        while (isOpen && available() == 0) {
+            /* block until data available */
+            try {
+                notifyAll();    // notify writers waiting
+                wait();
+            } catch (InterruptedException e) {
+                // continue waiting
+            }
+        }
+
+        if (!isOpen) {
+            return -1;
+        }
+
+        int readLen = Math.min(available(), len);
+
+        buffer.get(pos, readLen, b, off);
+        pos += readLen;
+
+        int reduce;
+
+        if (markIsValid()) {
+            reduce = mark;
+        } else {
+            reduce = pos;
+        }
+
+        buffer.truncateFromStart(buffer.size - reduce);
+        pos -= reduce;
+        mark -= reduce;
+        if (mark < 0) mark = -1; // don't wrap mark around?
+
+        return readLen;
+    }
+
+    /**
+     * @see InputStream.reset()
+     */
+    @Override
+    public synchronized void reset() throws IOException {
+        ensureOpen();
+        if (markIsValid())
+            pos = mark;
+    }
+
+    /**
+     * @see InputStream.skip()
+     */
+    @Override
+    public synchronized long skip(long n) throws IOException {
+        ensureOpen();
+        pos += n;
+        return n;
+    }
+
+    /*
+     *------------------------------------------------------------
+     * Data Buffer
+     *------------------------------------------------------------
+     */
+
+    public static class Block {
+        protected byte[] data;
+
+        public Block(int size) {
+            data = new byte[size];
+        }
+
+        public void copyIn(byte[] src, int srcPos, int destPos, int length) {
+            System.arraycopy(src, srcPos, data, destPos, length);
+        }
+
+        public void copyOut(int srcPos, byte[] dest, int destPos, int length) {
+            System.arraycopy(data, srcPos, dest, destPos, length);
+        }
+    }
+
+    public static class BlockList extends ArrayList<Block> {
+        public BlockList() {
+            super();
+        }
+
+        @Override
+        public void removeRange(int fromIndex, int toIndex) {
+            super.removeRange(fromIndex, toIndex);
+        }
+    }
+
+    public static class Buffer {
+        protected int blockSize;
+        protected BlockList blocks;
+
+        /**
+         * Offset (position) to the first logical byte in the buffer.
+         */
+        protected int offset;
+
+        /**
+         * Logical size of the buffer.
+         */
+        protected int size;
+
+        public Buffer(int blockSize) {
+            this.blockSize = blockSize;
+            this.blocks = new BlockList();
+            this.offset = 0;
+            this.size = 0;
+        }
+
+        public int size() {
+            return size;
+        }
+
+        protected class Segment {
+            /**
+             * Block index.
+             */
+            protected int block;
+
+            /**
+             * Offset into the block.
+             */
+            protected int off;
+
+            /**
+             * Length of segment.
+             */
+            protected int len;
+
+            /**
+             * Calculate the block number and block offset given a position.
+             */
+            protected Segment(int pos) {
+                int absPos = offset + pos;
+                block = (int) (absPos / blockSize);
+                off = (int) (absPos % blockSize);
+                len = -1;
+            }
+        }
+
+        protected Segment[] accessList(int pos, int size) {
+            Segment start = new Segment(pos);
+            Segment end = new Segment(pos + size);
+            int nBlocks = end.block - start.block + 1;
+            Segment[] segs = new Segment[nBlocks];
+
+            start.len = Math.min(size, blockSize - start.off);
+            segs[0] = start;
+            int currPos = pos + start.len;
+            int currSize = start.len;
+            for (int i = 1; i < nBlocks; i++) {
+                Segment seg = new Segment(currPos);
+                seg.len = Math.min(blockSize, size - currSize);
+                segs[i] = seg;
+                currPos += seg.len;
+                currSize += seg.len;
+            }
+
+            return segs;
+        }
+
+        protected void ensureCapacity(int pos) {
+            Segment seg = new Segment(pos-1);
+
+            while (blocks.size() < (seg.block + 1))
+                blocks.add(new Block(blockSize));
+        }
+
+        public void put(byte b) {
+            byte[] buf = new byte[1];
+            buf[0] = b;
+            put(buf);
+        }
+
+        public void put(byte[] b) {
+            ensureCapacity(size + b.length);
+            Segment[] segs = accessList(size, b.length);
+
+            int off = 0;
+            for (int i = 0; i < segs.length; i++) {
+                Block block = blocks.get(segs[i].block);
+                block.copyIn(b, off, segs[i].off, segs[i].len);
+            }
+
+            size += b.length;
+        }
+
+        public byte[] get(int pos, int len) {
+            byte[] b = new byte[len];
+            get(pos, len, b, 0);
+            return b;
+        }
+
+        /**
+         * Throws IndexOutOfBoundsException.
+         */
+        public void get(int pos, int len, byte[] b, int off) {
+            Segment[] segs = accessList(pos, len);
+            for (int i = 0; i < segs.length; i++) {
+                Block block = blocks.get(segs[i].block);
+                block.copyOut(segs[i].off, b, off, segs[i].len);
+            }
+        }
+
+        /**
+         * Truncate the buffer to <code>newSize</code> by removing
+         * data from the start of the buffer.
+         */
+        public void truncateFromStart(int newSize) {
+            if (newSize > size || newSize < 0)
+                throw new RuntimeException("invalid size");
+
+            Segment newStart = new Segment(size - newSize);
+            blocks.removeRange(0, newStart.block);
+
+            size = newSize;
+            offset = newStart.off;
+        }
+    }
+}