video_chat_get 0.1.4 → 0.1.5

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/html_element_description 2.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_HTML_ELEMENT_DESCRIPTION
+#define NOKOGIRI_HTML_ELEMENT_DESCRIPTION
+
+#include <nokogiri.h>
+
+void init_html_element_description();
+
+extern VALUE cNokogiriHtmlElementDescription ;
+
+#endif

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/html_entity_lookup 2.c

@@ -0,0 +1,32 @@
+#include <html_entity_lookup.h>
+
+/*
+ * call-seq:
+ *  get(key)
+ *
+ * Get the HTML::EntityDescription for +key+
+ */
+static VALUE get(VALUE self, VALUE key)
+{
+  const htmlEntityDesc * desc =
+    htmlEntityLookup((const xmlChar *)StringValueCStr(key));
+  VALUE klass, args[3];
+
+  if(NULL == desc) return Qnil;
+  klass = rb_const_get(mNokogiriHtml, rb_intern("EntityDescription"));
+
+  args[0] = INT2NUM((long)desc->value);
+  args[1] = NOKOGIRI_STR_NEW2(desc->name);
+  args[2] = NOKOGIRI_STR_NEW2(desc->desc);
+
+  return rb_class_new_instance(3, args, klass);
+}
+
+void init_html_entity_lookup()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE html = rb_define_module_under(nokogiri, "HTML");
+  VALUE klass = rb_define_class_under(html, "EntityLookup", rb_cObject);
+
+  rb_define_method(klass, "get", get, 1);
+}

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/html_entity_lookup 2.h

@@ -0,0 +1,8 @@
+#ifndef NOKOGIRI_HTML_ENTITY_LOOKUP
+#define NOKOGIRI_HTML_ENTITY_LOOKUP
+
+#include <nokogiri.h>
+
+void init_html_entity_lookup();
+
+#endif

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/html_sax_parser_context 2.c

@@ -0,0 +1,116 @@
+#include <html_sax_parser_context.h>
+
+VALUE cNokogiriHtmlSaxParserContext ;
+
+static void deallocate(xmlParserCtxtPtr ctxt)
+{
+  NOKOGIRI_DEBUG_START(handler);
+
+  ctxt->sax = NULL;
+
+  htmlFreeParserCtxt(ctxt);
+
+  NOKOGIRI_DEBUG_END(handler);
+}
+
+static VALUE
+parse_memory(VALUE klass, VALUE data, VALUE encoding)
+{
+    htmlParserCtxtPtr ctxt;
+
+    if (NIL_P(data))
+	rb_raise(rb_eArgError, "data cannot be nil");
+    if (!(int)RSTRING_LEN(data))
+	rb_raise(rb_eRuntimeError, "data cannot be empty");
+
+    ctxt = htmlCreateMemoryParserCtxt(StringValuePtr(data),
+				      (int)RSTRING_LEN(data));
+    if (ctxt->sax) {
+	xmlFree(ctxt->sax);
+	ctxt->sax = NULL;
+    }
+
+    if (RTEST(encoding)) {
+	xmlCharEncodingHandlerPtr enc = xmlFindCharEncodingHandler(StringValueCStr(encoding));
+	if (enc != NULL) {
+	    xmlSwitchToEncoding(ctxt, enc);
+	    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+		rb_raise(rb_eRuntimeError, "Unsupported encoding %s",
+			 StringValueCStr(encoding));
+	    }
+	}
+    }
+
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+static VALUE parse_file(VALUE klass, VALUE filename, VALUE encoding)
+{
+  htmlParserCtxtPtr ctxt = htmlCreateFileParserCtxt(
+      StringValueCStr(filename),
+      StringValueCStr(encoding)
+  );
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+static VALUE
+parse_doc(VALUE ctxt_val)
+{
+    htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+    htmlParseDocument(ctxt);
+    return Qnil;
+}
+
+static VALUE
+parse_doc_finalize(VALUE ctxt_val)
+{
+    htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+
+    if (ctxt->myDoc)
+	xmlFreeDoc(ctxt->myDoc);
+
+    NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+    return Qnil;
+}
+
+static VALUE
+parse_with(VALUE self, VALUE sax_handler)
+{
+    htmlParserCtxtPtr ctxt;
+    htmlSAXHandlerPtr sax;
+
+    if (!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser))
+	rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
+
+    Data_Get_Struct(self, htmlParserCtxt, ctxt);
+    Data_Get_Struct(sax_handler, htmlSAXHandler, sax);
+
+    /* Free the sax handler since we'll assign our own */
+    if (ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler)
+	xmlFree(ctxt->sax);
+
+    ctxt->sax = sax;
+    ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
+
+    rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
+
+    return self;
+}
+
+void init_html_sax_parser_context()
+{
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE html      = rb_define_module_under(nokogiri, "HTML");
+  VALUE sax       = rb_define_module_under(xml, "SAX");
+  VALUE hsax      = rb_define_module_under(html, "SAX");
+  VALUE pc        = rb_define_class_under(sax, "ParserContext", rb_cObject);
+  VALUE klass     = rb_define_class_under(hsax, "ParserContext", pc);
+
+  cNokogiriHtmlSaxParserContext = klass;
+
+  rb_define_singleton_method(klass, "memory", parse_memory, 2);
+  rb_define_singleton_method(klass, "file", parse_file, 2);
+
+  rb_define_method(klass, "parse_with", parse_with, 1);
+}

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/html_sax_parser_context 2.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_HTML_SAX_PARSER_CONTEXT
+#define NOKOGIRI_HTML_SAX_PARSER_CONTEXT
+
+#include <nokogiri.h>
+
+extern VALUE cNokogiriHtmlSaxParserContext;
+
+void init_html_sax_parser_context();
+
+#endif
+

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/html_sax_push_parser 2.c

@@ -0,0 +1,87 @@
+#include <html_sax_push_parser.h>
+
+/*
+ * call-seq:
+ *  native_write(chunk, last_chunk)
+ *
+ * Write +chunk+ to PushParser. +last_chunk+ triggers the end_document handle
+ */
+static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
+{
+  xmlParserCtxtPtr ctx;
+  const char * chunk  = NULL;
+  int size            = 0;
+
+
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  if(Qnil != _chunk) {
+    chunk = StringValuePtr(_chunk);
+    size = (int)RSTRING_LEN(_chunk);
+  }
+
+  if(htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
+    if (!(ctx->options & XML_PARSE_RECOVER)) {
+      xmlErrorPtr e = xmlCtxtGetLastError(ctx);
+      Nokogiri_error_raise(NULL, e);
+    }
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *  initialize_native(xml_sax, filename)
+ *
+ * Initialize the push parser with +xml_sax+ using +filename+
+ */
+static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
+			       VALUE encoding)
+{
+  htmlSAXHandlerPtr sax;
+  const char * filename = NULL;
+  htmlParserCtxtPtr ctx;
+  xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+
+  Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
+
+  if(_filename != Qnil) filename = StringValueCStr(_filename);
+
+  if (!NIL_P(encoding)) {
+    enc = xmlParseCharEncoding(StringValueCStr(encoding));
+    if (enc == XML_CHAR_ENCODING_ERROR)
+      rb_raise(rb_eArgError, "Unsupported Encoding");
+  }
+
+  ctx = htmlCreatePushParserCtxt(
+      sax,
+      NULL,
+      NULL,
+      0,
+      filename,
+      enc
+  );
+  if(ctx == NULL)
+    rb_raise(rb_eRuntimeError, "Could not create a parser context");
+
+  ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
+
+  ctx->sax2 = 1;
+  DATA_PTR(self) = ctx;
+  return self;
+}
+
+VALUE cNokogiriHtmlSaxPushParser;
+void init_html_sax_push_parser()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE html = rb_define_module_under(nokogiri, "HTML");
+  VALUE sax = rb_define_module_under(html, "SAX");
+  VALUE klass = rb_define_class_under(sax, "PushParser", cNokogiriXmlSaxPushParser);
+
+  cNokogiriHtmlSaxPushParser = klass;
+
+  rb_define_private_method(klass, "initialize_native", initialize_native, 3);
+  rb_define_private_method(klass, "native_write", native_write, 2);
+}

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/html_sax_push_parser 2.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_HTML_SAX_PUSH_PARSER
+#define NOKOGIRI_HTML_SAX_PUSH_PARSER
+
+#include <nokogiri.h>
+
+void init_html_sax_push_parser();
+
+extern VALUE cNokogiriHtmlSaxPushParser ;
+#endif

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/nokogiri 2.c

@@ -0,0 +1,141 @@
+#include <nokogiri.h>
+
+VALUE mNokogiri ;
+VALUE mNokogiriXml ;
+VALUE mNokogiriHtml ;
+VALUE mNokogiriXslt ;
+VALUE mNokogiriXmlSax ;
+VALUE mNokogiriHtmlSax ;
+
+#ifdef USE_INCLUDED_VASPRINTF
+/*
+ * I srsly hate windows.  it doesn't have vasprintf.
+ * Thank you Geoffroy Couprie for this implementation of vasprintf!
+ */
+int vasprintf (char **strp, const char *fmt, va_list ap)
+{
+  /* Mingw32/64 have a broken vsnprintf implementation that fails when
+   * using a zero-byte limit in order to retrieve the required size for malloc.
+   * So we use a one byte buffer instead.
+   */
+  char tmp[1];
+  int len = vsnprintf (tmp, 1, fmt, ap) + 1;
+  char *res = (char *)malloc((unsigned int)len);
+  if (res == NULL)
+      return -1;
+  *strp = res;
+  return vsnprintf(res, (unsigned int)len, fmt, ap);
+}
+#endif
+
+void vasprintf_free (void *p)
+{
+  free(p);
+}
+
+#ifdef HAVE_RUBY_UTIL_H
+#include "ruby/util.h"
+#else
+#include "util.h"
+#endif
+
+void nokogiri_root_node(xmlNodePtr node)
+{
+  xmlDocPtr doc;
+  nokogiriTuplePtr tuple;
+
+  doc = node->doc;
+  if (doc->type == XML_DOCUMENT_FRAG_NODE) doc = doc->doc;
+  tuple = (nokogiriTuplePtr)doc->_private;
+  st_insert(tuple->unlinkedNodes, (st_data_t)node, (st_data_t)node);
+}
+
+void nokogiri_root_nsdef(xmlNsPtr ns, xmlDocPtr doc)
+{
+  nokogiriTuplePtr tuple;
+
+  if (doc->type == XML_DOCUMENT_FRAG_NODE) doc = doc->doc;
+  tuple = (nokogiriTuplePtr)doc->_private;
+  st_insert(tuple->unlinkedNodes, (st_data_t)ns, (st_data_t)ns);
+}
+
+void Init_nokogiri()
+{
+  xmlMemSetup(
+      (xmlFreeFunc)ruby_xfree,
+      (xmlMallocFunc)ruby_xmalloc,
+      (xmlReallocFunc)ruby_xrealloc,
+      ruby_strdup
+  );
+
+  mNokogiri         = rb_define_module("Nokogiri");
+  mNokogiriXml      = rb_define_module_under(mNokogiri, "XML");
+  mNokogiriHtml     = rb_define_module_under(mNokogiri, "HTML");
+  mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
+  mNokogiriXmlSax   = rb_define_module_under(mNokogiriXml, "SAX");
+  mNokogiriHtmlSax  = rb_define_module_under(mNokogiriHtml, "SAX");
+
+  rb_const_set( mNokogiri,
+                rb_intern("LIBXML_VERSION"),
+                NOKOGIRI_STR_NEW2(LIBXML_DOTTED_VERSION)
+              );
+  rb_const_set( mNokogiri,
+                rb_intern("LIBXML_PARSER_VERSION"),
+                NOKOGIRI_STR_NEW2(xmlParserVersion)
+              );
+
+#ifdef NOKOGIRI_USE_PACKAGED_LIBRARIES
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_USE_PACKAGED_LIBRARIES"), Qtrue);
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXML2_PATH"), NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXML2_PATH));
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXSLT_PATH"), NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXSLT_PATH));
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXML2_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXML2_PATCHES), " "));
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXSLT_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXSLT_PATCHES), " "));
+#else
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_USE_PACKAGED_LIBRARIES"), Qfalse);
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXML2_PATH"), Qnil);
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXSLT_PATH"), Qnil);
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXML2_PATCHES"), Qnil);
+  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXSLT_PATCHES"), Qnil);
+#endif
+
+#ifdef LIBXML_ICONV_ENABLED
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qtrue);
+#else
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qfalse);
+#endif
+
+  xmlInitParser();
+
+  init_xml_document();
+  init_html_document();
+  init_xml_node();
+  init_xml_document_fragment();
+  init_xml_text();
+  init_xml_cdata();
+  init_xml_processing_instruction();
+  init_xml_attr();
+  init_xml_entity_reference();
+  init_xml_comment();
+  init_xml_node_set();
+  init_xml_xpath_context();
+  init_xml_sax_parser_context();
+  init_xml_sax_parser();
+  init_xml_sax_push_parser();
+  init_xml_reader();
+  init_xml_dtd();
+  init_xml_element_content();
+  init_xml_attribute_decl();
+  init_xml_element_decl();
+  init_xml_entity_decl();
+  init_xml_namespace();
+  init_html_sax_parser_context();
+  init_html_sax_push_parser();
+  init_xslt_stylesheet();
+  init_xml_syntax_error();
+  init_html_entity_lookup();
+  init_html_element_description();
+  init_xml_schema();
+  init_xml_relax_ng();
+  init_nokogiri_io();
+  init_xml_encoding_handler();
+}

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/ext/nokogiri/nokogiri 2.h

@@ -0,0 +1,121 @@
+#ifndef NOKOGIRI_NATIVE
+#define NOKOGIRI_NATIVE
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+
+#ifdef USE_INCLUDED_VASPRINTF
+int vasprintf (char **strp, const char *fmt, va_list ap);
+#else
+
+#define _GNU_SOURCE
+#  include <stdio.h>
+#undef _GNU_SOURCE
+
+#endif
+
+#include <libxml/parser.h>
+#include <libxml/entities.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/relaxng.h>
+#include <libxml/xinclude.h>
+#include <libxslt/extensions.h>
+#include <libxml/c14n.h>
+#include <ruby.h>
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+
+#ifndef NORETURN
+# if defined(__GNUC__)
+#  define NORETURN(name) __attribute__((noreturn)) name
+# else
+#  define NORETURN(name) name
+# endif
+#endif
+
+#define NOKOGIRI_STR_NEW2(str) \
+  NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
+
+#define NOKOGIRI_STR_NEW(str, len) \
+  rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
+
+#define RBSTR_OR_QNIL(_str) \
+  (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
+
+#include <xml_libxml2_hacks.h>
+
+#include <xml_io.h>
+#include <xml_document.h>
+#include <html_entity_lookup.h>
+#include <html_document.h>
+#include <xml_node.h>
+#include <xml_text.h>
+#include <xml_cdata.h>
+#include <xml_attr.h>
+#include <xml_processing_instruction.h>
+#include <xml_entity_reference.h>
+#include <xml_document_fragment.h>
+#include <xml_comment.h>
+#include <xml_node_set.h>
+#include <xml_dtd.h>
+#include <xml_attribute_decl.h>
+#include <xml_element_decl.h>
+#include <xml_entity_decl.h>
+#include <xml_xpath_context.h>
+#include <xml_element_content.h>
+#include <xml_sax_parser_context.h>
+#include <xml_sax_parser.h>
+#include <xml_sax_push_parser.h>
+#include <xml_reader.h>
+#include <html_sax_parser_context.h>
+#include <html_sax_push_parser.h>
+#include <xslt_stylesheet.h>
+#include <xml_syntax_error.h>
+#include <xml_schema.h>
+#include <xml_relax_ng.h>
+#include <html_element_description.h>
+#include <xml_namespace.h>
+#include <xml_encoding_handler.h>
+
+extern VALUE mNokogiri ;
+extern VALUE mNokogiriXml ;
+extern VALUE mNokogiriXmlSax ;
+extern VALUE mNokogiriHtml ;
+extern VALUE mNokogiriHtmlSax ;
+extern VALUE mNokogiriXslt ;
+
+void nokogiri_root_node(xmlNodePtr);
+void nokogiri_root_nsdef(xmlNsPtr, xmlDocPtr);
+
+#ifdef DEBUG
+
+#define NOKOGIRI_DEBUG_START(p) if (getenv("NOKOGIRI_NO_FREE")) return ; if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p start\n", __FILE__, __LINE__, p);
+#define NOKOGIRI_DEBUG_END(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p end\n", __FILE__, __LINE__, p);
+
+#else
+
+#define NOKOGIRI_DEBUG_START(p)
+#define NOKOGIRI_DEBUG_END(p)
+
+#endif
+
+#ifndef __builtin_expect
+# if defined(__GNUC__)
+#  define __builtin_expect(expr, c) __builtin_expect((long)(expr), (long)(c))
+# endif
+#endif
+
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
+#define XMLNS_BUFFER_LEN 128
+
+#endif