Nokogiri_precompiled_aarch64_dedshit 1.14.5

data/ext/java/nokogiri/Html4ElementDescription.java

@@ -0,0 +1,133 @@
+package nokogiri;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import net.sourceforge.htmlunit.cyberneko.HTMLElements;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Class for Nokogiri::HTML4::ElementDescription.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+@JRubyClass(name = "Nokogiri::HTML4::ElementDescription")
+public class Html4ElementDescription extends RubyObject
+{
+  private static final long serialVersionUID = 1L;
+  private static final HTMLElements htmlElements_ = new HTMLElements();
+
+  /**
+   * Stores memoized hash of element -> list of valid subelements.
+   */
+  static protected Map<Short, List<String>> subElements;
+  static
+  {
+    Map<Short, List<String>> _subElements =
+      new HashMap<Short, List<String>>();
+    subElements = Collections.synchronizedMap(_subElements);
+  }
+
+  protected HTMLElements.Element element;
+
+  public
+  Html4ElementDescription(Ruby runtime, RubyClass rubyClass)
+  {
+    super(runtime, rubyClass);
+  }
+
+  /**
+   * Lookup the list of sub elements of <code>code</code>.  If not
+   * already stored, iterate through all elements to find valid
+   * subelements; save this list and return it.
+   */
+  protected static List<String>
+  findSubElements(HTMLElements.Element elem)
+  {
+    List<String> subs = subElements.get(elem.code);
+
+    if (subs == null) {
+      subs = new ArrayList<String>();
+
+      /*
+       * A bit of a hack.  NekoHtml source code shows that
+       * UNKNOWN is the highest value element.  We cannot access
+       * the list of elements directly because it's protected.
+       */
+      for (short c = 0; c < HTMLElements.UNKNOWN; c++) {
+        HTMLElements.Element maybe_sub = htmlElements_.getElement(c);
+        if (maybe_sub != null && maybe_sub.isParent(elem)) {
+          subs.add(maybe_sub.name);
+        }
+      }
+
+      subElements.put(elem.code, subs);
+    }
+
+    return subs;
+  }
+
+  @JRubyMethod(name = "[]", meta = true)
+  public static IRubyObject
+  get(ThreadContext context,
+      IRubyObject klazz, IRubyObject name)
+  {
+
+    // nekohtml will return an element even for invalid names, which breaks `test_fetch_nonexistent'
+    // see getElement() in HTMLElements.java
+    HTMLElements.Element elem = htmlElements_.getElement(name.asJavaString(), htmlElements_.NO_SUCH_ELEMENT);
+    if (elem == htmlElements_.NO_SUCH_ELEMENT) {
+      return context.nil;
+    }
+
+    Html4ElementDescription desc =
+      new Html4ElementDescription(context.getRuntime(), (RubyClass)klazz);
+    desc.element = elem;
+    return desc;
+  }
+
+  @JRubyMethod()
+  public IRubyObject
+  name(ThreadContext context)
+  {
+    return context.getRuntime().newString(element.name.toLowerCase());
+  }
+
+  @JRubyMethod(name = "inline?")
+  public IRubyObject
+  inline_eh(ThreadContext context)
+  {
+    return context.getRuntime().newBoolean(element.isInline());
+  }
+
+  @JRubyMethod(name = "empty?")
+  public IRubyObject
+  empty_eh(ThreadContext context)
+  {
+    return context.getRuntime().newBoolean(element.isEmpty());
+  }
+
+  @JRubyMethod()
+  public IRubyObject
+  sub_elements(ThreadContext context)
+  {
+    Ruby ruby = context.getRuntime();
+    List<String> subs = findSubElements(element);
+    IRubyObject[] ary = new IRubyObject[subs.size()];
+    for (int i = 0; i < subs.size(); ++i) {
+      ary[i] = ruby.newString(subs.get(i));
+    }
+
+    return ruby.newArray(ary);
+  }
+
+}

data/ext/java/nokogiri/Html4EntityLookup.java

@@ -0,0 +1,63 @@
+package nokogiri;
+
+import static org.jruby.runtime.Helpers.invoke;
+
+import net.sourceforge.htmlunit.cyberneko.HTMLEntitiesParser;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Class for Nokogiri::HTML4::EntityLookup.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ */
+@JRubyClass(name = "Nokogiri::HTML4::EntityLookup")
+public class Html4EntityLookup extends RubyObject
+{
+  private static final long serialVersionUID = 1L;
+
+  public
+  Html4EntityLookup(Ruby runtime, RubyClass rubyClass)
+  {
+    super(runtime, rubyClass);
+  }
+
+  /**
+   * Looks up an HTML entity <code>key</code>.
+   *
+   * The description is a bit lacking.
+   */
+  @JRubyMethod()
+  public IRubyObject
+  get(ThreadContext context, IRubyObject key)
+  {
+    Ruby ruby = context.getRuntime();
+    String name = key.toString();
+
+    HTMLEntitiesParser parser = new HTMLEntitiesParser();
+    for (int j = 0 ; j < name.length() ; j++) {
+      if (!parser.parse(name.charAt(j))) {
+        break;
+      }
+    }
+    String match = parser.getMatch();
+
+    if (match == null) { return ruby.getNil(); }
+
+    int val = match.charAt(0);
+
+    IRubyObject edClass =
+      ruby.getClassFromPath("Nokogiri::HTML4::EntityDescription");
+    IRubyObject edObj = invoke(context, edClass, "new",
+                               ruby.newFixnum(val), ruby.newString(name),
+                               ruby.newString(name + " entity"));
+
+    return edObj;
+  }
+
+}

data/ext/java/nokogiri/Html4SaxParserContext.java

@@ -0,0 +1,289 @@
+package nokogiri;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+import java.nio.charset.IllegalCharsetNameException;
+import java.nio.charset.UnsupportedCharsetException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.xerces.parsers.AbstractSAXParser;
+import net.sourceforge.htmlunit.cyberneko.parsers.SAXParser;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.xml.sax.SAXException;
+
+import nokogiri.internals.NokogiriHandler;
+import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
+
+/**
+ * Class for Nokogiri::HTML4::SAX::ParserContext.
+ *
+ * @author serabe
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+@JRubyClass(name = "Nokogiri::HTML4::SAX::ParserContext", parent = "Nokogiri::XML::SAX::ParserContext")
+public class Html4SaxParserContext extends XmlSaxParserContext
+{
+  private static final long serialVersionUID = 1L;
+
+  static Html4SaxParserContext
+  newInstance(final Ruby runtime, final RubyClass klazz)
+  {
+    Html4SaxParserContext instance = new Html4SaxParserContext(runtime, klazz);
+    instance.initialize(runtime);
+    return instance;
+  }
+
+  public
+  Html4SaxParserContext(Ruby ruby, RubyClass rubyClass)
+  {
+    super(ruby, rubyClass);
+  }
+
+  @Override
+  protected AbstractSAXParser
+  createParser() throws SAXException
+  {
+    SAXParser parser = new SAXParser();
+
+    try {
+      parser.setProperty(
+        "http://cyberneko.org/html/properties/names/elems", "lower");
+      parser.setProperty(
+        "http://cyberneko.org/html/properties/names/attrs", "lower");
+
+      // NekoHTML should not try to guess the encoding based on the meta
+      // tags or other information in the document.  This is already
+      // handled by the EncodingReader.
+      parser.setFeature("http://cyberneko.org/html/features/scanner/ignore-specified-charset", true);
+      return parser;
+    } catch (SAXException ex) {
+      throw new SAXException(
+        "Problem while creating HTML4 SAX Parser: " + ex.toString());
+    }
+  }
+
+  @JRubyMethod(name = "memory", meta = true)
+  public static IRubyObject
+  parse_memory(ThreadContext context,
+               IRubyObject klazz,
+               IRubyObject data,
+               IRubyObject encoding)
+  {
+    Html4SaxParserContext ctx = Html4SaxParserContext.newInstance(context.runtime, (RubyClass) klazz);
+    String javaEncoding = findEncodingName(context, encoding);
+    if (javaEncoding != null) {
+      CharSequence input = applyEncoding(rubyStringToString(data.convertToString()), javaEncoding);
+      ByteArrayInputStream istream = new ByteArrayInputStream(input.toString().getBytes());
+      ctx.setInputSource(istream);
+      ctx.getInputSource().setEncoding(javaEncoding);
+    }
+    return ctx;
+  }
+
+  public enum EncodingType {
+    NONE(0, "NONE"),
+    UTF_8(1, "UTF-8"),
+    UTF16LE(2, "UTF16LE"),
+    UTF16BE(3, "UTF16BE"),
+    UCS4LE(4, "UCS4LE"),
+    UCS4BE(5, "UCS4BE"),
+    EBCDIC(6, "EBCDIC"),
+    UCS4_2143(7, "ICS4-2143"),
+    UCS4_3412(8, "UCS4-3412"),
+    UCS2(9, "UCS2"),
+    ISO_8859_1(10, "ISO-8859-1"),
+    ISO_8859_2(11, "ISO-8859-2"),
+    ISO_8859_3(12, "ISO-8859-3"),
+    ISO_8859_4(13, "ISO-8859-4"),
+    ISO_8859_5(14, "ISO-8859-5"),
+    ISO_8859_6(15, "ISO-8859-6"),
+    ISO_8859_7(16, "ISO-8859-7"),
+    ISO_8859_8(17, "ISO-8859-8"),
+    ISO_8859_9(18, "ISO-8859-9"),
+    ISO_2022_JP(19, "ISO-2022-JP"),
+    SHIFT_JIS(20, "SHIFT-JIS"),
+    EUC_JP(21, "EUC-JP"),
+    ASCII(22, "ASCII");
+
+    private final int value;
+    private final String name;
+
+    EncodingType(int value, String name)
+    {
+      this.value = value;
+      this.name = name;
+    }
+
+    public int getValue()
+    {
+      return value;
+    }
+
+    public String toString()
+    {
+      return name;
+    }
+
+    private static transient EncodingType[] values;
+
+    // NOTE: assuming ordinal == value
+    static EncodingType get(final int ordinal)
+    {
+      EncodingType[] values = EncodingType.values;
+      if (values == null) {
+        values = EncodingType.values();
+        EncodingType.values = values;
+      }
+      if (ordinal >= 0 && ordinal < values.length) {
+        return values[ordinal];
+      }
+      return null;
+    }
+
+  }
+
+  private static String
+  findEncodingName(final int value)
+  {
+    EncodingType type = EncodingType.get(value);
+    if (type == null) { return null; }
+    assert type.value == value;
+    return type.name;
+  }
+
+  private static String
+  findEncodingName(ThreadContext context, IRubyObject encoding)
+  {
+    String rubyEncoding = null;
+    if (encoding instanceof RubyString) {
+      rubyEncoding = rubyStringToString((RubyString) encoding);
+    } else if (encoding instanceof RubyFixnum) {
+      rubyEncoding = findEncodingName(RubyFixnum.fix2int((RubyFixnum) encoding));
+    }
+    if (rubyEncoding == null) { return null; }
+    try {
+      return Charset.forName(rubyEncoding).displayName();
+    } catch (UnsupportedCharsetException e) {
+      throw context.getRuntime().newEncodingCompatibilityError(rubyEncoding + "is not supported");
+    } catch (IllegalCharsetNameException e) {
+      throw context.getRuntime().newEncodingError(e.getMessage());
+    }
+  }
+
+  private static final Pattern CHARSET_PATTERN = Pattern.compile("charset(()|\\s)=(()|\\s)([a-z]|-|_|\\d)+",
+      Pattern.CASE_INSENSITIVE);
+
+  private static CharSequence
+  applyEncoding(final String input, final String enc)
+  {
+    int start_pos = 0;
+    int end_pos = 0;
+    if (containsIgnoreCase(input, "charset")) {
+      Matcher m = CHARSET_PATTERN.matcher(input);
+      while (m.find()) {
+        start_pos = m.start();
+        end_pos = m.end();
+      }
+    }
+    if (start_pos != end_pos) {
+      return new StringBuilder(input).replace(start_pos, end_pos, "charset=" + enc);
+    }
+    return input;
+  }
+
+  private static boolean
+  containsIgnoreCase(final String str, final String sub)
+  {
+    final int len = sub.length();
+    final int max = str.length() - len;
+
+    if (len == 0) { return true; }
+    final char c0Lower = Character.toLowerCase(sub.charAt(0));
+    final char c0Upper = Character.toUpperCase(sub.charAt(0));
+
+    for (int i = 0; i <= max; i++) {
+      final char ch = str.charAt(i);
+      if (ch != c0Lower && Character.toLowerCase(ch) != c0Lower && Character.toUpperCase(ch) != c0Upper) {
+        continue; // first char doesn't match
+      }
+
+      if (str.regionMatches(true, i + 1, sub, 0 + 1, len - 1)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @JRubyMethod(name = "file", meta = true)
+  public static IRubyObject
+  parse_file(ThreadContext context,
+             IRubyObject klass,
+             IRubyObject data,
+             IRubyObject encoding)
+  {
+    if (!(data instanceof RubyString)) {
+      throw context.getRuntime().newTypeError("data must be kind_of String");
+    }
+    if (!(encoding instanceof RubyString)) {
+      throw context.getRuntime().newTypeError("data must be kind_of String");
+    }
+
+    Html4SaxParserContext ctx = Html4SaxParserContext.newInstance(context.runtime, (RubyClass) klass);
+    ctx.setInputSourceFile(context, data);
+    String javaEncoding = findEncodingName(context, encoding);
+    if (javaEncoding != null) {
+      ctx.getInputSource().setEncoding(javaEncoding);
+    }
+    return ctx;
+  }
+
+  @JRubyMethod(name = "io", meta = true)
+  public static IRubyObject
+  parse_io(ThreadContext context,
+           IRubyObject klass,
+           IRubyObject data,
+           IRubyObject encoding)
+  {
+    if (!(encoding instanceof RubyFixnum)) {
+      throw context.getRuntime().newTypeError("encoding must be kind_of String");
+    }
+
+    Html4SaxParserContext ctx = Html4SaxParserContext.newInstance(context.runtime, (RubyClass) klass);
+    ctx.setIOInputSource(context, data, context.nil);
+    String javaEncoding = findEncodingName(context, encoding);
+    if (javaEncoding != null) {
+      ctx.getInputSource().setEncoding(javaEncoding);
+    }
+    return ctx;
+  }
+
+  /**
+   * Create a new parser context that will read from a raw input stream.
+   * Meant to be run in a separate thread by Html4SaxPushParser.
+   */
+  static Html4SaxParserContext
+  parse_stream(final Ruby runtime, RubyClass klass, InputStream stream)
+  {
+    Html4SaxParserContext ctx = Html4SaxParserContext.newInstance(runtime, klass);
+    ctx.setInputSource(stream);
+    return ctx;
+  }
+
+  @Override
+  protected void
+  preParse(final Ruby runtime, IRubyObject handlerRuby, NokogiriHandler handler)
+  {
+    // this function is meant to be empty.  It overrides the one in XmlSaxParserContext
+  }
+
+}

data/ext/java/nokogiri/Html4SaxPushParser.java

@@ -0,0 +1,213 @@
+package nokogiri;
+
+import nokogiri.internals.ClosedStreamException;
+import nokogiri.internals.NokogiriBlockingQueueInputStream;
+import nokogiri.internals.NokogiriHelpers;
+import nokogiri.internals.ParserContext;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.*;
+
+import static nokogiri.XmlSaxPushParser.terminateExecution;
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+import static org.jruby.runtime.Helpers.invoke;
+
+/**
+ * Class for Nokogiri::HTML4::SAX::PushParser
+ *
+ * @author
+ * @author Piotr Szmielew <p.szmielew@ava.waw.pl> - based on Nokogiri::XML::SAX::PushParser
+ */
+@JRubyClass(name = "Nokogiri::HTML4::SAX::PushParser")
+public class Html4SaxPushParser extends RubyObject
+{
+  private static final long serialVersionUID = 1L;
+
+  ParserContext.Options options;
+  IRubyObject saxParser;
+
+  NokogiriBlockingQueueInputStream stream;
+
+  private ParserTask parserTask = null;
+  private FutureTask<Html4SaxParserContext> futureTask = null;
+  private ExecutorService executor = null;
+
+  public
+  Html4SaxPushParser(Ruby ruby, RubyClass rubyClass)
+  {
+    super(ruby, rubyClass);
+  }
+
+  @SuppressWarnings("deprecation")
+  @Override
+  public void
+  finalize()
+  {
+    try {
+      terminateImpl();
+    } catch (Exception e) { /* ignored */ }
+  }
+
+  @JRubyMethod
+  public IRubyObject
+  initialize_native(final ThreadContext context,
+                    IRubyObject saxParser,
+                    IRubyObject fileName,
+                    IRubyObject encoding)
+  {
+    // NOTE: Silently skips provided encoding
+    options = new ParserContext.Options(0);
+    this.saxParser = saxParser;
+    return this;
+  }
+
+  private transient IRubyObject parse_options;
+
+  private IRubyObject
+  parse_options(final ThreadContext context)
+  {
+    if (parse_options == null) {
+      parse_options = invoke(context, context.runtime.getClassFromPath("Nokogiri::XML::ParseOptions"), "new");
+    }
+    return parse_options;
+  }
+
+  @JRubyMethod(name = "options")
+  public IRubyObject
+  getOptions(ThreadContext context)
+  {
+    return invoke(context, parse_options(context), "options");
+  }
+
+  @JRubyMethod(name = "options=")
+  public IRubyObject
+  setOptions(ThreadContext context, IRubyObject opts)
+  {
+    invoke(context, parse_options(context), "options=", opts);
+    options = new ParserContext.Options(opts.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());
+    }
+    final ByteArrayInputStream data = NokogiriHelpers.stringBytesToStream(chunk);
+    if (data == null) {
+      terminateTask(context.runtime);
+      throw XmlSyntaxError.createHTMLSyntaxError(context.runtime).toThrowable(); // Nokogiri::HTML4::SyntaxError
+    }
+
+    int errorCount0 = parserTask.getErrorCount();
+
+    if (isLast.isTrue()) {
+      IRubyObject document = invoke(context, this, "document");
+      invoke(context, document, "end_document");
+      terminateTask(context.runtime);
+    } else {
+      try {
+        Future<Void> task = stream.addChunk(data);
+        task.get();
+      } catch (ClosedStreamException ex) {
+        // this means the stream is closed, ignore this exception
+      } catch (Exception e) {
+        throw context.runtime.newRuntimeError(e.getMessage());
+      }
+
+    }
+
+    if (!options.recover && parserTask.getErrorCount() > errorCount0) {
+      terminateTask(context.runtime);
+      throw parserTask.getLastError().toThrowable();
+    }
+
+    return this;
+  }
+
+  @SuppressWarnings("unchecked")
+  private void
+  initialize_task(ThreadContext context) throws IOException
+  {
+    if (futureTask == null || stream == null) {
+      stream = new NokogiriBlockingQueueInputStream();
+
+      assert saxParser != null : "saxParser null";
+      parserTask = new ParserTask(context, saxParser, stream);
+      futureTask = new FutureTask<Html4SaxParserContext>((Callable) parserTask);
+      executor = Executors.newSingleThreadExecutor(new ThreadFactory() {
+        @Override
+        public Thread newThread(Runnable r) {
+          Thread t = new Thread(r);
+          t.setName("Html4SaxPushParser");
+          t.setDaemon(true);
+          return t;
+        }
+      });
+      executor.submit(futureTask);
+    }
+  }
+
+  private void
+  terminateTask(final Ruby runtime)
+  {
+    if (executor == null) { return; }
+
+    try {
+      terminateImpl();
+    } catch (InterruptedException e) {
+      throw runtime.newRuntimeError(e.toString());
+    } catch (Exception e) {
+      throw runtime.newRuntimeError(e.toString());
+    }
+  }
+
+  private synchronized void
+  terminateImpl() throws InterruptedException, ExecutionException
+  {
+    terminateExecution(executor, stream, futureTask);
+
+    executor = null;
+    stream = null;
+    futureTask = null;
+  }
+
+  private static Html4SaxParserContext
+  parse(final Ruby runtime, final InputStream stream)
+  {
+    RubyClass klazz = getNokogiriClass(runtime, "Nokogiri::HTML4::SAX::ParserContext");
+    return Html4SaxParserContext.parse_stream(runtime, klazz, stream);
+  }
+
+  static class ParserTask extends XmlSaxPushParser.ParserTask /* <Html4SaxPushParser> */
+  {
+
+    private
+    ParserTask(ThreadContext context, IRubyObject handler, InputStream stream)
+    {
+      super(context, handler, parse(context.runtime, stream), stream);
+    }
+
+    @Override
+    public Html4SaxParserContext
+    call() throws Exception
+    {
+      return (Html4SaxParserContext) super.call();
+    }
+
+  }
+
+}