bundle_depot 0.0.1

data/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/java/src/json/ext/ParserService.java

@@ -0,0 +1,35 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby and GPLv2 licenses; see COPYING and GPL files
+ * for details.
+ */
+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/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/java/src/json/ext/RuntimeInfo.java

@@ -0,0 +1,121 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby and GPLv2 licenses; see COPYING and GPL files
+ * for details.
+ */
+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 boolean encodingsSupported() {
+        return utf8 != null && utf8.get() != null;
+    }
+
+    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/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/java/src/json/ext/StringDecoder.java

@@ -0,0 +1,167 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby and GPLv2 licenses; see COPYING and GPL files
+ * for details.
+ */
+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/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/java/src/json/ext/StringEncoder.java

@@ -0,0 +1,106 @@
+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/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/java/src/json/ext/Utils.java

@@ -0,0 +1,89 @@
+/*
+ * This code is copyrighted work by Daniel Luz <dev at mernen dot com>.
+ *
+ * Distributed under the Ruby and GPLv2 licenses; see COPYING and GPL files
+ * for details.
+ */
+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;
+    }
+}

data/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/json-java.gemspec

@@ -0,0 +1,23 @@
+#!/usr/bin/env jruby
+require "rubygems"
+
+spec = Gem::Specification.new do |s|
+  s.name = "json"
+  s.version = File.read("VERSION").chomp
+  s.summary = "JSON implementation for JRuby"
+  s.description = "A JSON implementation as a JRuby extension."
+  s.author = "Daniel Luz"
+  s.email = "dev+ruby@mernen.com"
+  s.homepage = "http://json-jruby.rubyforge.org/"
+  s.platform = 'java'
+  s.rubyforge_project = "json-jruby"
+  s.license = "Ruby"
+
+  s.files = Dir["{docs,lib,tests}/**/*"]
+end
+
+if $0 == __FILE__
+  Gem::Builder.new(spec).build
+else
+  spec
+end

data/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/json.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+# stub: json 1.8.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "json"
+  s.version = "1.8.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Florian Frank"]
+  s.date = "2013-10-17"
+  s.description = "This is a JSON implementation as a Ruby extension in C."
+  s.email = "flori@ping.de"
+  s.extensions = ["ext/json/ext/generator/extconf.rb", "ext/json/ext/parser/extconf.rb"]
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.files = [".gitignore", ".travis.yml", "CHANGES", "COPYING", "COPYING-json-jruby", "GPL", "Gemfile", "README-json-jruby.markdown", "README.rdoc", "Rakefile", "TODO", "VERSION", "data/example.json", "data/index.html", "data/prototype.js", "diagrams/.keep", "ext/json/ext/fbuffer/fbuffer.h", "ext/json/ext/generator/depend", "ext/json/ext/generator/extconf.rb", "ext/json/ext/generator/generator.c", "ext/json/ext/generator/generator.h", "ext/json/ext/parser/depend", "ext/json/ext/parser/extconf.rb", "ext/json/ext/parser/parser.c", "ext/json/ext/parser/parser.h", "ext/json/ext/parser/parser.rl", "install.rb", "java/src/json/ext/ByteListTranscoder.java", "java/src/json/ext/Generator.java", "java/src/json/ext/GeneratorMethods.java", "java/src/json/ext/GeneratorService.java", "java/src/json/ext/GeneratorState.java", "java/src/json/ext/OptionsReader.java", "java/src/json/ext/Parser.java", "java/src/json/ext/Parser.rl", "java/src/json/ext/ParserService.java", "java/src/json/ext/RuntimeInfo.java", "java/src/json/ext/StringDecoder.java", "java/src/json/ext/StringEncoder.java", "java/src/json/ext/Utils.java", "json-java.gemspec", "json.gemspec", "json_pure.gemspec", "lib/json.rb", "lib/json/add/bigdecimal.rb", "lib/json/add/complex.rb", "lib/json/add/core.rb", "lib/json/add/date.rb", "lib/json/add/date_time.rb", "lib/json/add/exception.rb", "lib/json/add/ostruct.rb", "lib/json/add/range.rb", "lib/json/add/rational.rb", "lib/json/add/regexp.rb", "lib/json/add/struct.rb", "lib/json/add/symbol.rb", "lib/json/add/time.rb", "lib/json/common.rb", "lib/json/ext.rb", "lib/json/ext/.keep", "lib/json/generic_object.rb", "lib/json/pure.rb", "lib/json/pure/generator.rb", "lib/json/pure/parser.rb", "lib/json/version.rb", "tests/fixtures/fail1.json", "tests/fixtures/fail10.json", "tests/fixtures/fail11.json", "tests/fixtures/fail12.json", "tests/fixtures/fail13.json", "tests/fixtures/fail14.json", "tests/fixtures/fail18.json", "tests/fixtures/fail19.json", "tests/fixtures/fail2.json", "tests/fixtures/fail20.json", "tests/fixtures/fail21.json", "tests/fixtures/fail22.json", "tests/fixtures/fail23.json", "tests/fixtures/fail24.json", "tests/fixtures/fail25.json", "tests/fixtures/fail27.json", "tests/fixtures/fail28.json", "tests/fixtures/fail3.json", "tests/fixtures/fail4.json", "tests/fixtures/fail5.json", "tests/fixtures/fail6.json", "tests/fixtures/fail7.json", "tests/fixtures/fail8.json", "tests/fixtures/fail9.json", "tests/fixtures/pass1.json", "tests/fixtures/pass15.json", "tests/fixtures/pass16.json", "tests/fixtures/pass17.json", "tests/fixtures/pass2.json", "tests/fixtures/pass26.json", "tests/fixtures/pass3.json", "tests/setup_variant.rb", "tests/test_json.rb", "tests/test_json_addition.rb", "tests/test_json_encoding.rb", "tests/test_json_fixtures.rb", "tests/test_json_generate.rb", "tests/test_json_generic_object.rb", "tests/test_json_string_matching.rb", "tests/test_json_unicode.rb", "tools/fuzz.rb", "tools/server.rb", "./tests/test_json.rb", "./tests/test_json_addition.rb", "./tests/test_json_encoding.rb", "./tests/test_json_fixtures.rb", "./tests/test_json_generate.rb", "./tests/test_json_generic_object.rb", "./tests/test_json_string_matching.rb", "./tests/test_json_unicode.rb"]
+  s.homepage = "http://flori.github.com/json"
+  s.licenses = ["Ruby"]
+  s.rdoc_options = ["--title", "JSON implemention for Ruby", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.1.9"
+  s.summary = "JSON Implementation for Ruby"
+  s.test_files = ["./tests/test_json.rb", "./tests/test_json_addition.rb", "./tests/test_json_encoding.rb", "./tests/test_json_fixtures.rb", "./tests/test_json_generate.rb", "./tests/test_json_generic_object.rb", "./tests/test_json_string_matching.rb", "./tests/test_json_unicode.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<permutation>, [">= 0"])
+      s.add_development_dependency(%q<sdoc>, ["~> 0.3.16"]) if RUBY_VERSION > "1.8.6"
+    else
+      s.add_dependency(%q<permutation>, [">= 0"])
+      s.add_dependency(%q<sdoc>, ["~> 0.3.16"]) if RUBY_VERSION > "1.8.6"
+    end
+  else
+    s.add_dependency(%q<permutation>, [">= 0"])
+    s.add_dependency(%q<sdoc>, ["~> 0.3.16"]) if RUBY_VERSION > "1.8.6"
+  end
+end

data/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/json_pure.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+# stub: json_pure 1.8.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "json_pure"
+  s.version = "1.8.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Florian Frank"]
+  s.date = "2013-10-17"
+  s.description = "This is a JSON implementation in pure Ruby."
+  s.email = "flori@ping.de"
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.files = [".gitignore", ".travis.yml", "CHANGES", "COPYING", "COPYING-json-jruby", "GPL", "Gemfile", "README-json-jruby.markdown", "README.rdoc", "Rakefile", "TODO", "VERSION", "data/example.json", "data/index.html", "data/prototype.js", "diagrams/.keep", "ext/json/ext/fbuffer/fbuffer.h", "ext/json/ext/generator/depend", "ext/json/ext/generator/extconf.rb", "ext/json/ext/generator/generator.c", "ext/json/ext/generator/generator.h", "ext/json/ext/parser/depend", "ext/json/ext/parser/extconf.rb", "ext/json/ext/parser/parser.c", "ext/json/ext/parser/parser.h", "ext/json/ext/parser/parser.rl", "install.rb", "java/src/json/ext/ByteListTranscoder.java", "java/src/json/ext/Generator.java", "java/src/json/ext/GeneratorMethods.java", "java/src/json/ext/GeneratorService.java", "java/src/json/ext/GeneratorState.java", "java/src/json/ext/OptionsReader.java", "java/src/json/ext/Parser.java", "java/src/json/ext/Parser.rl", "java/src/json/ext/ParserService.java", "java/src/json/ext/RuntimeInfo.java", "java/src/json/ext/StringDecoder.java", "java/src/json/ext/StringEncoder.java", "java/src/json/ext/Utils.java", "json-java.gemspec", "json.gemspec", "json_pure.gemspec", "lib/json.rb", "lib/json/add/bigdecimal.rb", "lib/json/add/complex.rb", "lib/json/add/core.rb", "lib/json/add/date.rb", "lib/json/add/date_time.rb", "lib/json/add/exception.rb", "lib/json/add/ostruct.rb", "lib/json/add/range.rb", "lib/json/add/rational.rb", "lib/json/add/regexp.rb", "lib/json/add/struct.rb", "lib/json/add/symbol.rb", "lib/json/add/time.rb", "lib/json/common.rb", "lib/json/ext.rb", "lib/json/ext/.keep", "lib/json/generic_object.rb", "lib/json/pure.rb", "lib/json/pure/generator.rb", "lib/json/pure/parser.rb", "lib/json/version.rb", "tests/fixtures/fail1.json", "tests/fixtures/fail10.json", "tests/fixtures/fail11.json", "tests/fixtures/fail12.json", "tests/fixtures/fail13.json", "tests/fixtures/fail14.json", "tests/fixtures/fail18.json", "tests/fixtures/fail19.json", "tests/fixtures/fail2.json", "tests/fixtures/fail20.json", "tests/fixtures/fail21.json", "tests/fixtures/fail22.json", "tests/fixtures/fail23.json", "tests/fixtures/fail24.json", "tests/fixtures/fail25.json", "tests/fixtures/fail27.json", "tests/fixtures/fail28.json", "tests/fixtures/fail3.json", "tests/fixtures/fail4.json", "tests/fixtures/fail5.json", "tests/fixtures/fail6.json", "tests/fixtures/fail7.json", "tests/fixtures/fail8.json", "tests/fixtures/fail9.json", "tests/fixtures/pass1.json", "tests/fixtures/pass15.json", "tests/fixtures/pass16.json", "tests/fixtures/pass17.json", "tests/fixtures/pass2.json", "tests/fixtures/pass26.json", "tests/fixtures/pass3.json", "tests/setup_variant.rb", "tests/test_json.rb", "tests/test_json_addition.rb", "tests/test_json_encoding.rb", "tests/test_json_fixtures.rb", "tests/test_json_generate.rb", "tests/test_json_generic_object.rb", "tests/test_json_string_matching.rb", "tests/test_json_unicode.rb", "tools/fuzz.rb", "tools/server.rb", "./tests/test_json.rb", "./tests/test_json_addition.rb", "./tests/test_json_encoding.rb", "./tests/test_json_fixtures.rb", "./tests/test_json_generate.rb", "./tests/test_json_generic_object.rb", "./tests/test_json_string_matching.rb", "./tests/test_json_unicode.rb"]
+  s.homepage = "http://flori.github.com/json"
+  s.licenses = ["Ruby"]
+  s.rdoc_options = ["--title", "JSON implemention for ruby", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.1.9"
+  s.summary = "JSON Implementation for Ruby"
+  s.test_files = ["./tests/test_json.rb", "./tests/test_json_addition.rb", "./tests/test_json_encoding.rb", "./tests/test_json_fixtures.rb", "./tests/test_json_generate.rb", "./tests/test_json_generic_object.rb", "./tests/test_json_string_matching.rb", "./tests/test_json_unicode.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<permutation>, [">= 0"])
+      s.add_development_dependency(%q<sdoc>, ["~> 0.3.16"]) if RUBY_VERSION > "1.8.6"
+      s.add_development_dependency(%q<rake>, ["~> 0.9.2"])
+    else
+      s.add_dependency(%q<permutation>, [">= 0"])
+      s.add_dependency(%q<sdoc>, ["~> 0.3.16"]) if RUBY_VERSION > "1.8.6"
+      s.add_dependency(%q<rake>, ["~> 0.9.2"])
+    end
+  else
+    s.add_dependency(%q<permutation>, [">= 0"])
+    s.add_dependency(%q<sdoc>, ["~> 0.3.16"]) if RUBY_VERSION > "1.8.6"
+    s.add_dependency(%q<rake>, ["~> 0.9.2"])
+  end
+end

data/fixtures/bundle/json/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c/ruby/2.0.0/gems/json_pure-1.8.1/lib/json/add/bigdecimal.rb

@@ -0,0 +1,28 @@
+unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
+  require 'json'
+end
+defined?(::BigDecimal) or require 'bigdecimal'
+
+class BigDecimal
+  # Import a JSON Marshalled object.
+  #
+  # method used for JSON marshalling support.
+  def self.json_create(object)
+    BigDecimal._load object['b']
+  end
+
+  # Marshal the object to JSON.
+  #
+  # method used for JSON marshalling support.
+  def as_json(*)
+    {
+      JSON.create_id => self.class.name,
+      'b'            => _dump,
+    }
+  end
+
+  # return the JSON value
+  def to_json(*)
+    as_json.to_json
+  end
+end