video_chat_get 0.1.5 → 0.1.6

data/vendor/bundle/ruby/2.5.0/gems/json-2.3.0/ext/json/extconf 2.rb

@@ -1,2 +0,0 @@
-require 'mkmf'
-create_makefile('json')

data/vendor/bundle/ruby/2.5.0/gems/json-2.3.0/install 2.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'fileutils'
-include FileUtils::Verbose
-require 'rbconfig'
-include\
-  begin
-    RbConfig
-  rescue NameError
-    Config
-  end
-
-sitelibdir = CONFIG["sitelibdir"]
-cd 'lib' do
-  install('json.rb', sitelibdir)
-  mkdir_p File.join(sitelibdir, 'json')
-  for file in Dir['json/**/*}']
-    d = File.join(sitelibdir, file)
-    mkdir_p File.dirname(d)
-    install(file, d)
-  end
-end
-warn " *** Installed PURE ruby library."

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

@@ -1,166 +0,0 @@
-/*
- * 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 class specialized in transcoding a certain String format into another,
- * using UTF-8 ByteLists as both input and output.
- */
-abstract class ByteListTranscoder {
-    protected final ThreadContext context;
-
-    protected ByteList src;
-    protected int srcEnd;
-    /** Position where the last read character started */
-    protected int charStart;
-    /** Position of the next character to read */
-    protected int pos;
-
-    private ByteList out;
-    /**
-     * When a character that can be copied straight into the output is found,
-     * its index is stored on this variable, and copying is delayed until
-     * the sequence of characters that can be copied ends.
-     *
-     * <p>The variable stores -1 when not in a plain sequence.
-     */
-    private int quoteStart = -1;
-
-    protected ByteListTranscoder(ThreadContext context) {
-        this.context = context;
-    }
-
-    protected void init(ByteList src, ByteList out) {
-        this.init(src, 0, src.length(), out);
-    }
-
-    protected void init(ByteList src, int start, int end, ByteList out) {
-        this.src = src;
-        this.pos = start;
-        this.charStart = start;
-        this.srcEnd = end;
-        this.out = out;
-    }
-
-    /**
-     * Returns whether there are any characters left to be read.
-     */
-    protected boolean hasNext() {
-        return pos < srcEnd;
-    }
-
-    /**
-     * Returns the next character in the buffer.
-     */
-    private char next() {
-        return src.charAt(pos++);
-    }
-
-    /**
-     * Reads an UTF-8 character from the input and returns its code point,
-     * while advancing the input position.
-     *
-     * <p>Raises an {@link #invalidUtf8()} exception if an invalid byte
-     * is found.
-     */
-    protected int readUtf8Char() {
-        charStart = pos;
-        char head = next();
-        if (head <= 0x7f) { // 0b0xxxxxxx (ASCII)
-            return head;
-        }
-        if (head <= 0xbf) { // 0b10xxxxxx
-            throw invalidUtf8(); // tail byte with no head
-        }
-        if (head <= 0xdf) { // 0b110xxxxx
-            ensureMin(1);
-            int cp = ((head  & 0x1f) << 6)
-                     | nextPart();
-            if (cp < 0x0080) throw invalidUtf8();
-            return cp;
-        }
-        if (head <= 0xef) { // 0b1110xxxx
-            ensureMin(2);
-            int cp = ((head & 0x0f) << 12)
-                     | (nextPart()  << 6)
-                     | nextPart();
-            if (cp < 0x0800) throw invalidUtf8();
-            return cp;
-        }
-        if (head <= 0xf7) { // 0b11110xxx
-            ensureMin(3);
-            int cp = ((head & 0x07) << 18)
-                     | (nextPart()  << 12)
-                     | (nextPart()  << 6)
-                     | nextPart();
-            if (!Character.isValidCodePoint(cp)) throw invalidUtf8();
-            return cp;
-        }
-        // 0b11111xxx?
-        throw invalidUtf8();
-    }
-
-    /**
-     * Throws a GeneratorError if the input list doesn't have at least this
-     * many bytes left.
-     */
-    protected void ensureMin(int n) {
-        if (pos + n > srcEnd) throw incompleteUtf8();
-    }
-
-    /**
-     * Reads the next byte of a multi-byte UTF-8 character and returns its
-     * contents (lower 6 bits).
-     *
-     * <p>Throws a GeneratorError if the byte is not a valid tail.
-     */
-    private int nextPart() {
-        char c = next();
-        // tail bytes must be 0b10xxxxxx
-        if ((c & 0xc0) != 0x80) throw invalidUtf8();
-        return c & 0x3f;
-    }
-
-
-    protected void quoteStart() {
-        if (quoteStart == -1) quoteStart = charStart;
-    }
-
-    /**
-     * When in a sequence of characters that can be copied directly,
-     * interrupts the sequence and copies it to the output buffer.
-     *
-     * @param endPos The offset until which the direct character quoting should
-     *               occur. You may pass {@link #pos} to quote until the most
-     *               recently read character, or {@link #charStart} to quote
-     *               until the character before it.
-     */
-    protected void quoteStop(int endPos) {
-        if (quoteStart != -1) {
-            out.append(src, quoteStart, endPos - quoteStart);
-            quoteStart = -1;
-        }
-    }
-
-    protected void append(int b) {
-        out.append(b);
-    }
-
-    protected void append(byte[] origin, int start, int length) {
-        out.append(origin, start, length);
-    }
-
-
-    protected abstract RaiseException invalidUtf8();
-
-    protected RaiseException incompleteUtf8() {
-        return invalidUtf8();
-    }
-}

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

@@ -1,466 +0,0 @@
-/*
- * 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.RubyBasicObject;
-import org.jruby.RubyBignum;
-import org.jruby.RubyBoolean;
-import org.jruby.RubyClass;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyFloat;
-import org.jruby.RubyHash;
-import org.jruby.RubyNumeric;
-import org.jruby.RubyString;
-import org.jruby.runtime.ClassIndex;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.util.ByteList;
-
-public final class Generator {
-    private Generator() {
-        throw new RuntimeException();
-    }
-
-    /**
-     * Encodes the given object as a JSON string, using the given handler.
-     */
-    static <T extends IRubyObject> RubyString
-            generateJson(ThreadContext context, T object,
-                         Handler<? super T> handler, IRubyObject[] args) {
-        Session session = new Session(context, args.length > 0 ? args[0]
-                                                               : null);
-        return session.infect(handler.generateNew(session, object));
-    }
-
-    /**
-     * Encodes the given object as a JSON string, detecting the appropriate handler
-     * for the given object.
-     */
-    static <T extends IRubyObject> RubyString
-            generateJson(ThreadContext context, T object, IRubyObject[] args) {
-        Handler<? super T> handler = getHandlerFor(context.getRuntime(), object);
-        return generateJson(context, object, handler, args);
-    }
-
-    /**
-     * Encodes the given object as a JSON string, using the appropriate
-     * handler if one is found or calling #to_json if not.
-     */
-    public static <T extends IRubyObject> RubyString
-            generateJson(ThreadContext context, T object,
-                         GeneratorState config) {
-        Session session = new Session(context, config);
-        Handler<? super T> handler = getHandlerFor(context.getRuntime(), object);
-        return handler.generateNew(session, object);
-    }
-
-    // NOTE: drop this once Ruby 1.9.3 support is gone!
-    private static final int FIXNUM = 1;
-    private static final int BIGNUM = 2;
-    private static final int ARRAY = 3;
-    private static final int STRING = 4;
-    private static final int NIL = 5;
-    private static final int TRUE = 6;
-    private static final int FALSE = 7;
-    private static final int HASH = 10;
-    private static final int FLOAT = 11;
-    // hard-coded due JRuby 1.7 compatibility
-    // https://github.com/jruby/jruby/blob/1.7.27/core/src/main/java/org/jruby/runtime/ClassIndex.java
-
-    /**
-     * Returns the best serialization handler for the given object.
-     */
-    // Java's generics can't handle this satisfactorily, so I'll just leave
-    // the best I could get and ignore the warnings
-    @SuppressWarnings("unchecked")
-    private static <T extends IRubyObject>
-            Handler<? super T> getHandlerFor(Ruby runtime, T object) {
-        switch (((RubyBasicObject) object).getNativeTypeIndex()) {
-            // can not use getNativeClassIndex due 1.7 compatibility
-            case NIL    : return (Handler) NIL_HANDLER;
-            case TRUE   : return (Handler) TRUE_HANDLER;
-            case FALSE  : return (Handler) FALSE_HANDLER;
-            case FLOAT  : return (Handler) FLOAT_HANDLER;
-            case FIXNUM : return (Handler) FIXNUM_HANDLER;
-            case BIGNUM : return (Handler) BIGNUM_HANDLER;
-            case STRING :
-                if (((RubyBasicObject) object).getMetaClass() != runtime.getString()) break;
-                return (Handler) STRING_HANDLER;
-            case ARRAY  :
-                if (((RubyBasicObject) object).getMetaClass() != runtime.getArray()) break;
-                return (Handler) ARRAY_HANDLER;
-            case HASH   :
-                if (((RubyBasicObject) object).getMetaClass() != runtime.getHash()) break;
-                return (Handler) HASH_HANDLER;
-        }
-        return GENERIC_HANDLER;
-    }
-
-
-    /* Generator context */
-
-    /**
-     * A class that concentrates all the information that is shared by
-     * generators working on a single session.
-     *
-     * <p>A session is defined as the process of serializing a single root
-     * object; any handler directly called by container handlers (arrays and
-     * hashes/objects) shares this object with its caller.
-     *
-     * <p>Note that anything called indirectly (via {@link GENERIC_HANDLER})
-     * won't be part of the session.
-     */
-    static class Session {
-        private final ThreadContext context;
-        private GeneratorState state;
-        private IRubyObject possibleState;
-        private RuntimeInfo info;
-        private StringEncoder stringEncoder;
-
-        private boolean tainted = false;
-        private boolean untrusted = false;
-
-        Session(ThreadContext context, GeneratorState state) {
-            this.context = context;
-            this.state = state;
-        }
-
-        Session(ThreadContext context, IRubyObject possibleState) {
-            this.context = context;
-            this.possibleState = possibleState == null || possibleState.isNil()
-                    ? null : possibleState;
-        }
-
-        public ThreadContext getContext() {
-            return context;
-        }
-
-        public Ruby getRuntime() {
-            return context.getRuntime();
-        }
-
-        public GeneratorState getState() {
-            if (state == null) {
-                state = GeneratorState.fromState(context, getInfo(), possibleState);
-            }
-            return state;
-        }
-
-        public RuntimeInfo getInfo() {
-            if (info == null) info = RuntimeInfo.forRuntime(getRuntime());
-            return info;
-        }
-
-        public StringEncoder getStringEncoder() {
-            if (stringEncoder == null) {
-                stringEncoder = new StringEncoder(context, getState().asciiOnly());
-            }
-            return stringEncoder;
-        }
-
-        public void infectBy(IRubyObject object) {
-            if (object.isTaint()) tainted = true;
-            if (object.isUntrusted()) untrusted = true;
-        }
-
-        public <T extends IRubyObject> T infect(T object) {
-            if (tainted) object.setTaint(true);
-            if (untrusted) object.setUntrusted(true);
-            return object;
-        }
-    }
-
-
-    /* Handler base classes */
-
-    private static abstract class Handler<T extends IRubyObject> {
-        /**
-         * Returns an estimative of how much space the serialization of the
-         * given object will take. Used for allocating enough buffer space
-         * before invoking other methods.
-         */
-        int guessSize(Session session, T object) {
-            return 4;
-        }
-
-        RubyString generateNew(Session session, T object) {
-            RubyString result;
-            ByteList buffer = new ByteList(guessSize(session, object));
-            generate(session, object, buffer);
-            result = RubyString.newString(session.getRuntime(), buffer);
-            ThreadContext context = session.getContext();
-            RuntimeInfo info = session.getInfo();
-            result.force_encoding(context, info.utf8.get());
-            return result;
-        }
-
-        abstract void generate(Session session, T object, ByteList buffer);
-    }
-
-    /**
-     * A handler that returns a fixed keyword regardless of the passed object.
-     */
-    private static class KeywordHandler<T extends IRubyObject>
-            extends Handler<T> {
-        private final ByteList keyword;
-
-        private KeywordHandler(String keyword) {
-            this.keyword = new ByteList(ByteList.plain(keyword), false);
-        }
-
-        @Override
-        int guessSize(Session session, T object) {
-            return keyword.length();
-        }
-
-        @Override
-        RubyString generateNew(Session session, T object) {
-            return RubyString.newStringShared(session.getRuntime(), keyword);
-        }
-
-        @Override
-        void generate(Session session, T object, ByteList buffer) {
-            buffer.append(keyword);
-        }
-    }
-
-
-    /* Handlers */
-
-    static final Handler<RubyBignum> BIGNUM_HANDLER =
-        new Handler<RubyBignum>() {
-            @Override
-            void generate(Session session, RubyBignum object, ByteList buffer) {
-                // JRUBY-4751: RubyBignum.to_s() returns generic object
-                // representation (fixed in 1.5, but we maintain backwards
-                // compatibility; call to_s(IRubyObject[]) then
-                buffer.append(((RubyString)object.to_s(IRubyObject.NULL_ARRAY)).getByteList());
-            }
-        };
-
-    static final Handler<RubyFixnum> FIXNUM_HANDLER =
-        new Handler<RubyFixnum>() {
-            @Override
-            void generate(Session session, RubyFixnum object, ByteList buffer) {
-                buffer.append(object.to_s().getByteList());
-            }
-        };
-
-    static final Handler<RubyFloat> FLOAT_HANDLER =
-        new Handler<RubyFloat>() {
-            @Override
-            void generate(Session session, RubyFloat object, ByteList buffer) {
-                double value = RubyFloat.num2dbl(object);
-
-                if (Double.isInfinite(value) || Double.isNaN(value)) {
-                    if (!session.getState().allowNaN()) {
-                        throw Utils.newException(session.getContext(),
-                                Utils.M_GENERATOR_ERROR,
-                                object + " not allowed in JSON");
-                    }
-                }
-                buffer.append(((RubyString)object.to_s()).getByteList());
-            }
-        };
-
-    static final Handler<RubyArray> ARRAY_HANDLER =
-        new Handler<RubyArray>() {
-            @Override
-            int guessSize(Session session, RubyArray object) {
-                GeneratorState state = session.getState();
-                int depth = state.getDepth();
-                int perItem =
-                    4                                           // prealloc
-                    + (depth + 1) * state.getIndent().length()  // indent
-                    + 1 + state.getArrayNl().length();          // ',' arrayNl
-                return 2 + object.size() * perItem;
-            }
-
-            @Override
-            void generate(Session session, RubyArray object, ByteList buffer) {
-                ThreadContext context = session.getContext();
-                Ruby runtime = context.getRuntime();
-                GeneratorState state = session.getState();
-                int depth = state.increaseDepth();
-
-                ByteList indentUnit = state.getIndent();
-                byte[] shift = Utils.repeat(indentUnit, depth);
-
-                ByteList arrayNl = state.getArrayNl();
-                byte[] delim = new byte[1 + arrayNl.length()];
-                delim[0] = ',';
-                System.arraycopy(arrayNl.unsafeBytes(), arrayNl.begin(), delim, 1,
-                        arrayNl.length());
-
-                session.infectBy(object);
-
-                buffer.append((byte)'[');
-                buffer.append(arrayNl);
-                boolean firstItem = true;
-                for (int i = 0, t = object.getLength(); i < t; i++) {
-                    IRubyObject element = object.eltInternal(i);
-                    session.infectBy(element);
-                    if (firstItem) {
-                        firstItem = false;
-                    } else {
-                        buffer.append(delim);
-                    }
-                    buffer.append(shift);
-                    Handler<IRubyObject> handler = getHandlerFor(runtime, element);
-                    handler.generate(session, element, buffer);
-                }
-
-                state.decreaseDepth();
-                if (arrayNl.length() != 0) {
-                    buffer.append(arrayNl);
-                    buffer.append(shift, 0, state.getDepth() * indentUnit.length());
-                }
-
-                buffer.append((byte)']');
-            }
-        };
-
-    static final Handler<RubyHash> HASH_HANDLER =
-        new Handler<RubyHash>() {
-            @Override
-            int guessSize(Session session, RubyHash object) {
-                GeneratorState state = session.getState();
-                int perItem =
-                    12    // key, colon, comma
-                    + (state.getDepth() + 1) * state.getIndent().length()
-                    + state.getSpaceBefore().length()
-                    + state.getSpace().length();
-                return 2 + object.size() * perItem;
-            }
-
-            @Override
-            void generate(final Session session, RubyHash object,
-                          final ByteList buffer) {
-                ThreadContext context = session.getContext();
-                final Ruby runtime = context.getRuntime();
-                final GeneratorState state = session.getState();
-                final int depth = state.increaseDepth();
-
-                final ByteList objectNl = state.getObjectNl();
-                final byte[] indent = Utils.repeat(state.getIndent(), depth);
-                final ByteList spaceBefore = state.getSpaceBefore();
-                final ByteList space = state.getSpace();
-
-                buffer.append((byte)'{');
-                buffer.append(objectNl);
-                object.visitAll(new RubyHash.Visitor() {
-                    private boolean firstPair = true;
-
-                    @Override
-                    public void visit(IRubyObject key, IRubyObject value) {
-                        if (firstPair) {
-                            firstPair = false;
-                        } else {
-                            buffer.append((byte)',');
-                            buffer.append(objectNl);
-                        }
-                        if (objectNl.length() != 0) buffer.append(indent);
-
-                        STRING_HANDLER.generate(session, key.asString(), buffer);
-                        session.infectBy(key);
-
-                        buffer.append(spaceBefore);
-                        buffer.append((byte)':');
-                        buffer.append(space);
-
-                        Handler<IRubyObject> valueHandler = getHandlerFor(runtime, value);
-                        valueHandler.generate(session, value, buffer);
-                        session.infectBy(value);
-                    }
-                });
-                state.decreaseDepth();
-                if (objectNl.length() != 0) {
-                    buffer.append(objectNl);
-                    buffer.append(Utils.repeat(state.getIndent(), state.getDepth()));
-                }
-                buffer.append((byte)'}');
-            }
-        };
-
-    static final Handler<RubyString> STRING_HANDLER =
-        new Handler<RubyString>() {
-            @Override
-            int guessSize(Session session, RubyString object) {
-                // for most applications, most strings will be just a set of
-                // printable ASCII characters without any escaping, so let's
-                // just allocate enough space for that + the quotes
-                return 2 + object.getByteList().length();
-            }
-
-            @Override
-            void generate(Session session, RubyString object, ByteList buffer) {
-                RuntimeInfo info = session.getInfo();
-                RubyString src;
-
-                if (object.encoding(session.getContext()) != info.utf8.get()) {
-                    src = (RubyString)object.encode(session.getContext(),
-                                                    info.utf8.get());
-                } else {
-                    src = object;
-                }
-
-                session.getStringEncoder().encode(src.getByteList(), buffer);
-            }
-        };
-
-    static final Handler<RubyBoolean> TRUE_HANDLER =
-        new KeywordHandler<RubyBoolean>("true");
-    static final Handler<RubyBoolean> FALSE_HANDLER =
-        new KeywordHandler<RubyBoolean>("false");
-    static final Handler<IRubyObject> NIL_HANDLER =
-        new KeywordHandler<IRubyObject>("null");
-
-    /**
-     * The default handler (<code>Object#to_json</code>): coerces the object
-     * to string using <code>#to_s</code>, and serializes that string.
-     */
-    static final Handler<IRubyObject> OBJECT_HANDLER =
-        new Handler<IRubyObject>() {
-            @Override
-            RubyString generateNew(Session session, IRubyObject object) {
-                RubyString str = object.asString();
-                return STRING_HANDLER.generateNew(session, str);
-            }
-
-            @Override
-            void generate(Session session, IRubyObject object, ByteList buffer) {
-                RubyString str = object.asString();
-                STRING_HANDLER.generate(session, str, buffer);
-            }
-        };
-
-    /**
-     * A handler that simply calls <code>#to_json(state)</code> on the
-     * given object.
-     */
-    static final Handler<IRubyObject> GENERIC_HANDLER =
-        new Handler<IRubyObject>() {
-            @Override
-            RubyString generateNew(Session session, IRubyObject object) {
-                if (object.respondsTo("to_json")) {
-                    IRubyObject result = object.callMethod(session.getContext(), "to_json",
-                              new IRubyObject[] {session.getState()});
-                    if (result instanceof RubyString) return (RubyString)result;
-                    throw session.getRuntime().newTypeError("to_json must return a String");
-                } else {
-                    return OBJECT_HANDLER.generateNew(session, object);
-                }
-            }
-
-            @Override
-            void generate(Session session, IRubyObject object, ByteList buffer) {
-                RubyString result = generateNew(session, object);
-                buffer.append(result.getByteList());
-            }
-        };
-}