Nokogiri_precompiled_aarch64_dedshit 1.14.5

data/ext/java/nokogiri/internals/NokogiriBlockingQueueInputStream.java

@@ -0,0 +1,178 @@
+/**
+ *
+ */
+package nokogiri.internals;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import nokogiri.XmlSaxPushParser;
+
+/**
+ * A smart input stream that signals the caller when a chunk of data is consumed
+ * from the stream. The main use of this stream is to synchronize the
+ * {@link XmlSaxPushParser} and the {@link XmlSaxParser} which runs in a
+ * different thread.
+ *
+ * @author John Shahid <jvshahid@gmail.com>
+ */
+public class NokogiriBlockingQueueInputStream extends InputStream
+{
+  private final LinkedBlockingQueue<Task>  queue;
+  protected Task                           currentTask;
+  protected ByteArrayInputStream           currentStream;
+  protected int                            position;
+  protected boolean                        closed = false;
+
+  public static final ByteArrayInputStream END    = new ByteArrayInputStream(new byte[0]);
+
+  private static class Task extends FutureTask<Void>
+  {
+    private final ByteArrayInputStream stream;
+
+    public
+    Task(ByteArrayInputStream stream)
+    {
+      super(new Callable<Void>() {
+        @Override
+        public Void call() throws Exception {
+          // TODO Auto-generated method stub
+          return null;
+        }
+      });
+      this.stream = stream;
+    }
+
+    public ByteArrayInputStream
+    getStream()
+    {
+      return stream;
+    }
+
+    @Override
+    public void
+    run()
+    {
+      // don't do anything
+    }
+
+    @Override
+    public boolean
+    runAndReset()
+    {
+      // don't do anything
+      return true;
+    }
+
+    @Override
+    public void
+    set(Void v)
+    {
+      super.set(v);
+    }
+  }
+
+  public
+  NokogiriBlockingQueueInputStream()
+  {
+    queue = new LinkedBlockingQueue<Task>();
+  }
+
+  /**
+   * This method shouldn't be called unless the parser has finished parsing or
+   * threw an exception while doing so, otherwise, there'll be the protential
+   * that the read method will block indefinitely.
+   */
+  @Override
+  public synchronized void
+  close()
+  {
+    closed = true;
+    List<Task> tasks = new LinkedList<Task>();
+    queue.drainTo(tasks);
+    tasks.add(currentTask);
+    for (Task task : tasks) {
+      task.set(null);
+    }
+  }
+
+  /**
+   * Add @param stream to the end of the queue of data that will be returned by
+   * {@link #read()} and its variants. The method will @return a future whose
+   * {@link Future#get()} will block until the data in @param stream is read.
+   *
+   * Passing the special stream {@link #END} to this method, will cause
+   * {@link #read()} to return an eof indicator (i.e. -1) to the caller, after
+   * all the data inserted before {@link #END} is processed.
+   *
+   * @return
+   */
+  public synchronized Future<Void>
+  addChunk(ByteArrayInputStream stream) throws ClosedStreamException
+  {
+    if (closed) {
+      throw new ClosedStreamException("Cannot add a chunk to a closed stream");
+    }
+    Task task = new Task(stream);
+    queue.add(task);
+    return task;
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see java.io.InputStream#read()
+   */
+  @Override
+  public int
+  read() throws IOException
+  {
+    if (currentTask == null || currentStream.available() == 0)
+      if (getNextTask() == -1) {
+        return -1;
+      }
+    return currentStream.read();
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see java.io.InputStream#read(byte[], int, int)
+   */
+  @Override
+  public int
+  read(byte[] bytes, int off, int len)
+  {
+    if (currentTask == null || currentStream.available() == 0) {
+      if (getNextTask() == -1) {
+        currentTask.set(null);
+        return -1;
+      }
+    }
+    return currentStream.read(bytes, off, len);
+  }
+
+  protected int
+  getNextTask()
+  {
+    while (true) {
+      try {
+        if (currentTask != null) {
+          currentTask.set(null);
+        }
+        currentTask = queue.take();
+        currentStream = currentTask.getStream();
+        return currentStream.available() == 0 ? -1 : currentStream.available();
+      } catch (InterruptedException ex) {
+        // keep retrying to read
+      }
+    }
+  }
+}

data/ext/java/nokogiri/internals/NokogiriDomParser.java

@@ -0,0 +1,99 @@
+package nokogiri.internals;
+
+import java.io.IOException;
+
+import nokogiri.XmlDocument;
+
+import org.apache.xerces.parsers.DOMParser;
+import org.apache.xerces.parsers.XIncludeParserConfiguration;
+import org.apache.xerces.xni.parser.XMLParserConfiguration;
+import org.cyberneko.dtd.DTDConfiguration;
+import org.w3c.dom.Document;
+import org.xml.sax.Attributes;
+import org.xml.sax.ContentHandler;
+import org.xml.sax.InputSource;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+
+/**
+ * Sets up a Xerces/XNI DOM Parser for use with Nokogiri.  Uses
+ * NekoDTD to parse the DTD into a tree of Nodes.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+public class NokogiriDomParser extends DOMParser
+{
+  protected DOMParser dtd;
+  protected boolean xInclude;
+  protected XMLParserConfiguration config;
+
+  public
+  NokogiriDomParser(XMLParserConfiguration config)
+  {
+    super(config);
+    this.config = config;
+    initialize();
+  }
+
+  public
+  NokogiriDomParser(ParserContext.Options options)
+  {
+    xInclude = options.xInclude;
+    initialize();
+  }
+
+  protected void
+  initialize()
+  {
+    if (config == null) {
+      if (xInclude) {
+        config = new XIncludeParserConfiguration();
+      } else {
+        config = getXMLParserConfiguration();
+      }
+    }
+
+    DTDConfiguration dtdConfig = new DTDConfiguration();
+    dtd = new DOMParser(dtdConfig);
+
+    config.setDTDHandler(dtdConfig);
+    config.setDTDContentModelHandler(dtdConfig);
+  }
+
+  @Override
+  public void
+  parse(InputSource source) throws SAXException, IOException
+  {
+    dtd.reset();
+    if (xInclude) {
+      setEntityResolver(new NokogiriXInlcudeEntityResolver(source));
+    }
+    super.parse(source);
+    Document doc = getDocument();
+    if (doc == null) {
+      throw new RuntimeException("null document");
+    }
+
+    doc.setUserData(XmlDocument.DTD_RAW_DOCUMENT, dtd.getDocument(), null);
+  }
+
+  private static class NokogiriXInlcudeEntityResolver implements org.xml.sax.EntityResolver
+  {
+    InputSource source;
+    private
+    NokogiriXInlcudeEntityResolver(InputSource source)
+    {
+      this.source = source;
+    }
+
+    @Override
+    public InputSource
+    resolveEntity(String publicId, String systemId)
+    throws SAXException, IOException
+    {
+      if (systemId != null) { source.setSystemId(systemId); }
+      if (publicId != null) { source.setPublicId(publicId); }
+      return source;
+    }
+  }
+}

data/ext/java/nokogiri/internals/NokogiriEntityResolver.java

@@ -0,0 +1,140 @@
+package nokogiri.internals;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+
+import nokogiri.internals.ParserContext.Options;
+
+import org.jruby.Ruby;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.ext.EntityResolver2;
+
+/**
+ * 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 class NokogiriEntityResolver implements EntityResolver2
+{
+  protected final Ruby runtime;
+  private final NokogiriErrorHandler handler;
+  private final Options options;
+
+  public
+  NokogiriEntityResolver(Ruby runtime, NokogiriErrorHandler handler, Options options)
+  {
+    super();
+    this.runtime = runtime;
+    this.handler = handler;
+    this.options = options;
+  }
+
+  @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(runtime, null, publicId, null, systemId);
+  }
+
+  @Override
+  public InputSource
+  resolveEntity(String name,
+                String publicId,
+                String baseURI,
+                String systemId)
+  throws SAXException, IOException
+  {
+    return resolveEntity(runtime, name, publicId, baseURI, systemId);
+  }
+
+  private static File
+  join(String parent, String child)
+  {
+    if (new File(parent).isFile()) {
+      parent = new File(parent).getParent();
+    }
+    return new File(parent, child);
+  }
+
+  private static InputSource
+  emptyInputSource(InputSource source)
+  {
+    source.setByteStream(new ByteArrayInputStream(new byte[0]));
+    return source;
+  }
+
+  private boolean
+  shouldLoadDtd()
+  {
+    return options.dtdLoad || options.dtdValid;
+  }
+
+  private void
+  addError(String errorMessage)
+  {
+    if (handler != null) { handler.addError(new Exception(errorMessage)); }
+  }
+
+  /**
+   * Create a file base input source taking into account the current
+   * directory of <code>runtime</code>.
+   * @throws SAXException
+   */
+  protected InputSource
+  resolveEntity(Ruby runtime, String name, String publicId, String baseURI, String systemId)
+  throws IOException, SAXException
+  {
+    InputSource s = new InputSource();
+    if (name.equals("[dtd]") && !shouldLoadDtd()) {
+      return emptyInputSource(s);
+    } else if (!name.equals("[dtd]") && !options.noEnt) {
+      return emptyInputSource(s);
+    }
+    String adjustedSystemId;
+    URI uri = URI.create(systemId);
+    if (options.noNet && uri.getHost() != null) {
+      addError("Attempt to load network entity " + systemId);
+      return emptyInputSource(s);
+    }
+    // if this is a url or absolute file name then use it
+    if (uri.isAbsolute() && !uri.isOpaque()) {
+      adjustedSystemId = uri.toURL().toString();
+    } else if (new File(uri.getPath()).isAbsolute()) {
+      adjustedSystemId = uri.getPath();
+    } else if (baseURI != null) {
+      URI baseuri = URI.create(baseURI);
+      if (options.noNet && baseuri.getHost() != null) {
+        addError("Attempt to load network entity " + systemId);
+        return emptyInputSource(s);
+      }
+      if (baseuri.getHost() == null) {
+        // this is a local file
+        adjustedSystemId = join(baseuri.getPath(), uri.getPath()).getCanonicalPath();
+      } else {
+        // this is a url, then resolve uri using baseuri
+        adjustedSystemId = baseuri.resolve(systemId).toURL().toString();
+      }
+    } else {
+      // baseURI is null we have to use the current working directory to resolve the entity
+      String pwd = runtime.getCurrentDirectory();
+      adjustedSystemId = join(pwd, uri.getPath()).getCanonicalPath();
+    }
+    s.setSystemId(adjustedSystemId);
+    s.setPublicId(publicId);
+    return s;
+  }
+
+}

data/ext/java/nokogiri/internals/NokogiriErrorHandler.java

@@ -0,0 +1,65 @@
+package nokogiri.internals;
+
+import nokogiri.XmlSyntaxError;
+import org.apache.xerces.xni.parser.XMLErrorHandler;
+import org.jruby.Ruby;
+import org.jruby.RubyException;
+import org.jruby.exceptions.RaiseException;
+import org.xml.sax.ErrorHandler;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Super class of error handlers.
+ *
+ * XMLErrorHandler is used by nokogiri.internals.HtmlDomParserContext since NekoHtml
+ * uses this type of the error handler.
+ *
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public abstract class NokogiriErrorHandler implements ErrorHandler, XMLErrorHandler
+{
+  private final Ruby runtime;
+  protected final List<RubyException> errors;
+  protected boolean noerror;
+  protected boolean nowarning;
+
+  public
+  NokogiriErrorHandler(Ruby runtime, boolean noerror, boolean nowarning)
+  {
+    this.runtime = runtime;
+    this.errors = new ArrayList<RubyException>(4);
+    this.noerror = noerror;
+    this.nowarning = nowarning;
+  }
+
+  public List<RubyException>
+  getErrors() { return errors; }
+
+  public void
+  addError(Exception ex)
+  {
+    addError(XmlSyntaxError.createXMLSyntaxError(runtime, ex));
+  }
+
+  public void
+  addError(RubyException ex)
+  {
+    errors.add(ex);
+  }
+
+  public void
+  addError(RaiseException ex)
+  {
+    addError(ex.getException());
+  }
+
+  protected boolean
+  usesNekoHtml(String domain)
+  {
+    return "http://cyberneko.org/html".equals(domain);
+  }
+
+}