video_chat_get 0.1.0

data/vendor/bundle/ruby/2.5.0/gems/json-2.3.0/java/src/json/ext/ParserService.java

@@ -0,0 +1,34 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby license: https://www.ruby-lang.org/en/about/license.txt
+ */
+package json.ext;
+
+import java.io.IOException;
+import java.lang.ref.WeakReference;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.load.BasicLibraryService;
+
+/**
+ * The service invoked by JRuby's {@link org.jruby.runtime.load.LoadService LoadService}.
+ * Defines the <code>JSON::Ext::Parser</code> class.
+ * @author mernen
+ */
+public class ParserService implements BasicLibraryService {
+    public boolean basicLoad(Ruby runtime) throws IOException {
+        runtime.getLoadService().require("json/common");
+        RuntimeInfo info = RuntimeInfo.initRuntime(runtime);
+
+        info.jsonModule = new WeakReference<RubyModule>(runtime.defineModule("JSON"));
+        RubyModule jsonExtModule = info.jsonModule.get().defineModuleUnder("Ext");
+        RubyClass parserClass =
+            jsonExtModule.defineClassUnder("Parser", runtime.getObject(),
+                                           Parser.ALLOCATOR);
+        parserClass.defineAnnotatedMethods(Parser.class);
+        return true;
+    }
+}

data/vendor/bundle/ruby/2.5.0/gems/json-2.3.0/java/src/json/ext/RuntimeInfo.java

@@ -0,0 +1,116 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby license: https://www.ruby-lang.org/en/about/license.txt
+ */
+package json.ext;
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyEncoding;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+
+final class RuntimeInfo {
+    // since the vast majority of cases runs just one runtime,
+    // we optimize for that
+    private static WeakReference<Ruby> runtime1 = new WeakReference<Ruby>(null);
+    private static RuntimeInfo info1;
+    // store remaining runtimes here (does not include runtime1)
+    private static Map<Ruby, RuntimeInfo> runtimes;
+
+    // these fields are filled by the service loaders
+    // Use WeakReferences so that RuntimeInfo doesn't indirectly hold a hard reference to
+    // the Ruby runtime object, which would cause memory leaks in the runtimes map above.
+    /** JSON */
+    WeakReference<RubyModule> jsonModule;
+    /** JSON::Ext::Generator::GeneratorMethods::String::Extend */
+    WeakReference<RubyModule> stringExtendModule;
+    /** JSON::Ext::Generator::State */
+    WeakReference<RubyClass> generatorStateClass;
+    /** JSON::SAFE_STATE_PROTOTYPE */
+    WeakReference<GeneratorState> safeStatePrototype;
+
+    final WeakReference<RubyEncoding> utf8;
+    final WeakReference<RubyEncoding> ascii8bit;
+    // other encodings
+    private final Map<String, WeakReference<RubyEncoding>> encodings;
+
+    private RuntimeInfo(Ruby runtime) {
+        RubyClass encodingClass = runtime.getEncoding();
+        if (encodingClass == null) { // 1.8 mode
+            utf8 = ascii8bit = null;
+            encodings = null;
+        } else {
+            ThreadContext context = runtime.getCurrentContext();
+
+            utf8 = new WeakReference<RubyEncoding>((RubyEncoding)RubyEncoding.find(context,
+                    encodingClass, runtime.newString("utf-8")));
+            ascii8bit = new WeakReference<RubyEncoding>((RubyEncoding)RubyEncoding.find(context,
+                    encodingClass, runtime.newString("ascii-8bit")));
+            encodings = new HashMap<String, WeakReference<RubyEncoding>>();
+        }
+    }
+
+    static RuntimeInfo initRuntime(Ruby runtime) {
+        synchronized (RuntimeInfo.class) {
+            if (runtime1.get() == runtime) {
+                return info1;
+            } else if (runtime1.get() == null) {
+                runtime1 = new WeakReference<Ruby>(runtime);
+                info1 = new RuntimeInfo(runtime);
+                return info1;
+            } else {
+                if (runtimes == null) {
+                    runtimes = new WeakHashMap<Ruby, RuntimeInfo>(1);
+                }
+                RuntimeInfo cache = runtimes.get(runtime);
+                if (cache == null) {
+                    cache = new RuntimeInfo(runtime);
+                    runtimes.put(runtime, cache);
+                }
+                return cache;
+            }
+        }
+    }
+
+    public static RuntimeInfo forRuntime(Ruby runtime) {
+        synchronized (RuntimeInfo.class) {
+            if (runtime1.get() == runtime) return info1;
+            RuntimeInfo cache = null;
+            if (runtimes != null) cache = runtimes.get(runtime);
+            assert cache != null : "Runtime given has not initialized JSON::Ext";
+            return cache;
+        }
+    }
+
+    public RubyEncoding getEncoding(ThreadContext context, String name) {
+        synchronized (encodings) {
+            WeakReference<RubyEncoding> encoding = encodings.get(name);
+            if (encoding == null) {
+                Ruby runtime = context.getRuntime();
+                encoding = new WeakReference<RubyEncoding>((RubyEncoding)RubyEncoding.find(context,
+                        runtime.getEncoding(), runtime.newString(name)));
+                encodings.put(name, encoding);
+            }
+            return encoding.get();
+        }
+    }
+
+    public GeneratorState getSafeStatePrototype(ThreadContext context) {
+        if (safeStatePrototype == null) {
+            IRubyObject value = jsonModule.get().getConstant("SAFE_STATE_PROTOTYPE");
+            if (!(value instanceof GeneratorState)) {
+                throw context.getRuntime().newTypeError(value, generatorStateClass.get());
+            }
+            safeStatePrototype = new WeakReference<GeneratorState>((GeneratorState)value);
+        }
+        return safeStatePrototype.get();
+    }
+}

data/vendor/bundle/ruby/2.5.0/gems/json-2.3.0/java/src/json/ext/StringDecoder.java

@@ -0,0 +1,166 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby license: https://www.ruby-lang.org/en/about/license.txt
+ */
+package json.ext;
+
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.util.ByteList;
+
+/**
+ * A decoder that reads a JSON-encoded string from the given sources and
+ * returns its decoded form on a new ByteList. Escaped Unicode characters
+ * are encoded as UTF-8.
+ */
+final class StringDecoder extends ByteListTranscoder {
+    /**
+     * Stores the offset of the high surrogate when reading a surrogate pair,
+     * or -1 when not.
+     */
+    private int surrogatePairStart = -1;
+
+    // Array used for writing multi-byte characters into the buffer at once
+    private final byte[] aux = new byte[4];
+
+    StringDecoder(ThreadContext context) {
+        super(context);
+    }
+
+    ByteList decode(ByteList src, int start, int end) {
+        ByteList out = new ByteList(end - start);
+        out.setEncoding(src.getEncoding());
+        init(src, start, end, out);
+        while (hasNext()) {
+            handleChar(readUtf8Char());
+        }
+        quoteStop(pos);
+        return out;
+    }
+
+    private void handleChar(int c) {
+        if (c == '\\') {
+            quoteStop(charStart);
+            handleEscapeSequence();
+        } else {
+            quoteStart();
+        }
+    }
+
+    private void handleEscapeSequence() {
+        ensureMin(1);
+        switch (readUtf8Char()) {
+        case 'b':
+            append('\b');
+            break;
+        case 'f':
+            append('\f');
+            break;
+        case 'n':
+            append('\n');
+            break;
+        case 'r':
+            append('\r');
+            break;
+        case 't':
+            append('\t');
+            break;
+        case 'u':
+            ensureMin(4);
+            int cp = readHex();
+            if (Character.isHighSurrogate((char)cp)) {
+                handleLowSurrogate((char)cp);
+            } else if (Character.isLowSurrogate((char)cp)) {
+                // low surrogate with no high surrogate
+                throw invalidUtf8();
+            } else {
+                writeUtf8Char(cp);
+            }
+            break;
+        default: // '\\', '"', '/'...
+            quoteStart();
+        }
+    }
+
+    private void handleLowSurrogate(char highSurrogate) {
+        surrogatePairStart = charStart;
+        ensureMin(1);
+        int lowSurrogate = readUtf8Char();
+
+        if (lowSurrogate == '\\') {
+            ensureMin(5);
+            if (readUtf8Char() != 'u') throw invalidUtf8();
+            lowSurrogate = readHex();
+        }
+
+        if (Character.isLowSurrogate((char)lowSurrogate)) {
+            writeUtf8Char(Character.toCodePoint(highSurrogate,
+                                                (char)lowSurrogate));
+            surrogatePairStart = -1;
+        } else {
+            throw invalidUtf8();
+        }
+    }
+
+    private void writeUtf8Char(int codePoint) {
+        if (codePoint < 0x80) {
+            append(codePoint);
+        } else if (codePoint < 0x800) {
+            aux[0] = (byte)(0xc0 | (codePoint >>> 6));
+            aux[1] = tailByte(codePoint & 0x3f);
+            append(aux, 0, 2);
+        } else if (codePoint < 0x10000) {
+            aux[0] = (byte)(0xe0 | (codePoint >>> 12));
+            aux[1] = tailByte(codePoint >>> 6);
+            aux[2] = tailByte(codePoint);
+            append(aux, 0, 3);
+        } else {
+            aux[0] = (byte)(0xf0 | codePoint >>> 18);
+            aux[1] = tailByte(codePoint >>> 12);
+            aux[2] = tailByte(codePoint >>> 6);
+            aux[3] = tailByte(codePoint);
+            append(aux, 0, 4);
+        }
+    }
+
+    private byte tailByte(int value) {
+        return (byte)(0x80 | (value & 0x3f));
+    }
+
+    /**
+     * Reads a 4-digit unsigned hexadecimal number from the source.
+     */
+    private int readHex() {
+        int numberStart = pos;
+        int result = 0;
+        int length = 4;
+        for (int i = 0; i < length; i++) {
+            int digit = readUtf8Char();
+            int digitValue;
+            if (digit >= '0' && digit <= '9') {
+                digitValue = digit - '0';
+            } else if (digit >= 'a' && digit <= 'f') {
+                digitValue = 10 + digit - 'a';
+            } else if (digit >= 'A' && digit <= 'F') {
+                digitValue = 10 + digit - 'A';
+            } else {
+                throw new NumberFormatException("Invalid base 16 number "
+                        + src.subSequence(numberStart, numberStart + length));
+            }
+            result = result * 16 + digitValue;
+        }
+        return result;
+    }
+
+    @Override
+    protected RaiseException invalidUtf8() {
+        ByteList message = new ByteList(
+                ByteList.plain("partial character in source, " +
+                               "but hit end near "));
+        int start = surrogatePairStart != -1 ? surrogatePairStart : charStart;
+        message.append(src, start, srcEnd - start);
+        return Utils.newException(context, Utils.M_PARSER_ERROR,
+                                  context.getRuntime().newString(message));
+    }
+}

data/vendor/bundle/ruby/2.5.0/gems/json-2.3.0/java/src/json/ext/StringEncoder.java

@@ -0,0 +1,111 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby license: https://www.ruby-lang.org/en/about/license.txt
+ */
+package json.ext;
+
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.util.ByteList;
+
+/**
+ * An encoder that reads from the given source and outputs its representation
+ * to another ByteList. The source string is fully checked for UTF-8 validity,
+ * and throws a GeneratorError if any problem is found.
+ */
+final class StringEncoder extends ByteListTranscoder {
+    private final boolean asciiOnly;
+
+    // Escaped characters will reuse this array, to avoid new allocations
+    // or appending them byte-by-byte
+    private final byte[] aux =
+        new byte[] {/* First unicode character */
+                    '\\', 'u', 0, 0, 0, 0,
+                    /* Second unicode character (for surrogate pairs) */
+                    '\\', 'u', 0, 0, 0, 0,
+                    /* "\X" characters */
+                    '\\', 0};
+    // offsets on the array above
+    private static final int ESCAPE_UNI1_OFFSET = 0;
+    private static final int ESCAPE_UNI2_OFFSET = ESCAPE_UNI1_OFFSET + 6;
+    private static final int ESCAPE_CHAR_OFFSET = ESCAPE_UNI2_OFFSET + 6;
+    /** Array used for code point decomposition in surrogates */
+    private final char[] utf16 = new char[2];
+
+    private static final byte[] HEX =
+            new byte[] {'0', '1', '2', '3', '4', '5', '6', '7',
+                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+    StringEncoder(ThreadContext context, boolean asciiOnly) {
+        super(context);
+        this.asciiOnly = asciiOnly;
+    }
+
+    void encode(ByteList src, ByteList out) {
+        init(src, out);
+        append('"');
+        while (hasNext()) {
+            handleChar(readUtf8Char());
+        }
+        quoteStop(pos);
+        append('"');
+    }
+
+    private void handleChar(int c) {
+        switch (c) {
+        case '"':
+        case '\\':
+            escapeChar((char)c);
+            break;
+        case '\n':
+            escapeChar('n');
+            break;
+        case '\r':
+            escapeChar('r');
+            break;
+        case '\t':
+            escapeChar('t');
+            break;
+        case '\f':
+            escapeChar('f');
+            break;
+        case '\b':
+            escapeChar('b');
+            break;
+        default:
+            if (c >= 0x20 && c <= 0x7f ||
+                    (c >= 0x80 && !asciiOnly)) {
+                quoteStart();
+            } else {
+                quoteStop(charStart);
+                escapeUtf8Char(c);
+            }
+        }
+    }
+
+    private void escapeChar(char c) {
+        quoteStop(charStart);
+        aux[ESCAPE_CHAR_OFFSET + 1] = (byte)c;
+        append(aux, ESCAPE_CHAR_OFFSET, 2);
+    }
+
+    private void escapeUtf8Char(int codePoint) {
+        int numChars = Character.toChars(codePoint, utf16, 0);
+        escapeCodeUnit(utf16[0], ESCAPE_UNI1_OFFSET + 2);
+        if (numChars > 1) escapeCodeUnit(utf16[1], ESCAPE_UNI2_OFFSET + 2);
+        append(aux, ESCAPE_UNI1_OFFSET, 6 * numChars);
+    }
+
+    private void escapeCodeUnit(char c, int auxOffset) {
+        for (int i = 0; i < 4; i++) {
+            aux[auxOffset + i] = HEX[(c >>> (12 - 4 * i)) & 0xf];
+        }
+    }
+
+    @Override
+    protected RaiseException invalidUtf8() {
+         return Utils.newException(context, Utils.M_GENERATOR_ERROR,
+                 "source sequence is illegal/malformed utf-8");
+    }
+}

data/vendor/bundle/ruby/2.5.0/gems/json-2.3.0/java/src/json/ext/Utils.java

@@ -0,0 +1,88 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby license: https://www.ruby-lang.org/en/about/license.txt
+ */
+package json.ext;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * Library of miscellaneous utility functions
+ */
+final class Utils {
+    public static final String M_GENERATOR_ERROR = "GeneratorError";
+    public static final String M_NESTING_ERROR = "NestingError";
+    public static final String M_PARSER_ERROR = "ParserError";
+
+    private Utils() {
+        throw new RuntimeException();
+    }
+
+    /**
+     * Safe {@link RubyArray} type-checking.
+     * Returns the given object if it is an <code>Array</code>,
+     * or throws an exception if not.
+     * @param object The object to test
+     * @return The given object if it is an <code>Array</code>
+     * @throws RaiseException <code>TypeError</code> if the object is not
+     *                        of the expected type
+     */
+    static RubyArray ensureArray(IRubyObject object) throws RaiseException {
+        if (object instanceof RubyArray) return (RubyArray)object;
+        Ruby runtime = object.getRuntime();
+        throw runtime.newTypeError(object, runtime.getArray());
+    }
+
+    static RubyHash ensureHash(IRubyObject object) throws RaiseException {
+        if (object instanceof RubyHash) return (RubyHash)object;
+        Ruby runtime = object.getRuntime();
+        throw runtime.newTypeError(object, runtime.getHash());
+    }
+
+    static RubyString ensureString(IRubyObject object) throws RaiseException {
+        if (object instanceof RubyString) return (RubyString)object;
+        Ruby runtime = object.getRuntime();
+        throw runtime.newTypeError(object, runtime.getString());
+    }
+
+    static RaiseException newException(ThreadContext context,
+                                       String className, String message) {
+        return newException(context, className,
+                            context.getRuntime().newString(message));
+    }
+
+    static RaiseException newException(ThreadContext context,
+                                       String className, RubyString message) {
+        RuntimeInfo info = RuntimeInfo.forRuntime(context.getRuntime());
+        RubyClass klazz = info.jsonModule.get().getClass(className);
+        RubyException excptn =
+            (RubyException)klazz.newInstance(context,
+                new IRubyObject[] {message}, Block.NULL_BLOCK);
+        return new RaiseException(excptn);
+    }
+
+    static byte[] repeat(ByteList a, int n) {
+        return repeat(a.unsafeBytes(), a.begin(), a.length(), n);
+    }
+
+    static byte[] repeat(byte[] a, int begin, int length, int n) {
+        if (length == 0) return ByteList.NULL_ARRAY;
+        int resultLen = length * n;
+        byte[] result = new byte[resultLen];
+        for (int pos = 0; pos < resultLen; pos += length) {
+            System.arraycopy(a, begin, result, pos, length);
+        }
+        return result;
+    }
+}