depengine 0.0.1

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/lib/json/pure/parser.rb

@@ -0,0 +1,307 @@
+require 'strscan'
+
+module JSON
+  module Pure
+    # This class implements the JSON parser that is used to parse a JSON string
+    # into a Ruby data structure.
+    class Parser < StringScanner
+      STRING                = /" ((?:[^\x0-\x1f"\\] |
+                                   # escaped special characters:
+                                  \\["\\\/bfnrt] |
+                                  \\u[0-9a-fA-F]{4} |
+                                   # match all but escaped special characters:
+                                  \\[\x20-\x21\x23-\x2e\x30-\x5b\x5d-\x61\x63-\x65\x67-\x6d\x6f-\x71\x73\x75-\xff])*)
+                              "/nx
+      INTEGER               = /(-?0|-?[1-9]\d*)/
+      FLOAT                 = /(-?
+                                (?:0|[1-9]\d*)
+                                (?:
+                                  \.\d+(?i:e[+-]?\d+) |
+                                  \.\d+ |
+                                  (?i:e[+-]?\d+)
+                                )
+                                )/x
+      NAN                   = /NaN/
+      INFINITY              = /Infinity/
+      MINUS_INFINITY        = /-Infinity/
+      OBJECT_OPEN           = /\{/
+      OBJECT_CLOSE          = /\}/
+      ARRAY_OPEN            = /\[/
+      ARRAY_CLOSE           = /\]/
+      PAIR_DELIMITER        = /:/
+      COLLECTION_DELIMITER  = /,/
+      TRUE                  = /true/
+      FALSE                 = /false/
+      NULL                  = /null/
+      IGNORE                = %r(
+        (?:
+         //[^\n\r]*[\n\r]| # line comments
+         /\*               # c-style comments
+         (?:
+          [^*/]|        # normal chars
+          /[^*]|        # slashes that do not start a nested comment
+          \*[^/]|       # asterisks that do not end this comment
+          /(?=\*/)      # single slash before this comment's end 
+         )*
+           \*/               # the End of this comment
+           |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
+        )+
+      )mx
+
+      UNPARSED = Object.new
+
+      # Creates a new JSON::Pure::Parser instance for the string _source_.
+      #
+      # It will be configured by the _opts_ hash. _opts_ can have the following
+      # keys:
+      # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+      #   structures. Disable depth checking with :max_nesting => false|nil|0,
+      #   it defaults to 19.
+      # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+      #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+      #   to false.
+      # * *symbolize_names*: If set to true, returns symbols for the names
+      #   (keys) in a JSON object. Otherwise strings are returned, which is also
+      #   the default.
+      # * *create_additions*: If set to false, the Parser doesn't create
+      #   additions even if a matchin class and create_id was found. This option
+      #   defaults to true.
+      # * *object_class*: Defaults to Hash
+      # * *array_class*: Defaults to Array
+      def initialize(source, opts = {})
+          if defined?(::Encoding)
+            if source.encoding == Encoding::ASCII_8BIT
+              b = source[0, 4].bytes.to_a
+              source = case
+                       when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
+                         source.dup.force_encoding(Encoding::UTF_32BE).encode!(Encoding::UTF_8)
+                       when b.size >= 4 && b[0] == 0 && b[2] == 0
+                         source.dup.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8)
+                       when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
+                         source.dup.force_encoding(Encoding::UTF_32LE).encode!(Encoding::UTF_8)
+                       when b.size >= 4 && b[1] == 0 && b[3] == 0
+                         source.dup.force_encoding(Encoding::UTF_16LE).encode!(Encoding::UTF_8)
+                       else
+                         source.dup
+                       end
+            else
+              source = source.encode(Encoding::UTF_8)
+            end
+            source.force_encoding(Encoding::ASCII_8BIT)
+          else
+            b = source
+            source = case
+                     when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
+                       JSON.iconv('utf-8', 'utf-32be', b)
+                     when b.size >= 4 && b[0] == 0 && b[2] == 0
+                       JSON.iconv('utf-8', 'utf-16be', b)
+                     when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
+                       JSON.iconv('utf-8', 'utf-32le', b)
+                     when b.size >= 4 && b[1] == 0 && b[3] == 0
+                       JSON.iconv('utf-8', 'utf-16le', b)
+                     else
+                       b
+                     end
+          end
+        super source
+        if !opts.key?(:max_nesting) # defaults to 19
+          @max_nesting = 19
+        elsif opts[:max_nesting]
+          @max_nesting = opts[:max_nesting]
+        else
+          @max_nesting = 0
+        end
+        @allow_nan = !!opts[:allow_nan]
+        @symbolize_names = !!opts[:symbolize_names]
+        ca = true
+        ca = opts[:create_additions] if opts.key?(:create_additions)
+        @create_id = ca ? JSON.create_id : nil
+        @object_class = opts[:object_class] || Hash
+        @array_class = opts[:array_class] || Array
+      end
+
+      alias source string
+
+      # Parses the current JSON string _source_ and returns the complete data
+      # structure as a result.
+      def parse
+        reset
+        obj = nil
+        until eos?
+          case
+          when scan(OBJECT_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+            @current_nesting = 1
+            obj = parse_object
+          when scan(ARRAY_OPEN)
+            obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+            @current_nesting = 1
+            obj = parse_array
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "source '#{peek(20)}' not in JSON!"
+          end
+        end
+        obj or raise ParserError, "source did not contain any JSON!"
+        obj
+      end
+
+      private
+
+      # Unescape characters in strings.
+      UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+      UNESCAPE_MAP.update({
+        ?"  => '"',
+        ?\\ => '\\',
+        ?/  => '/',
+        ?b  => "\b",
+        ?f  => "\f",
+        ?n  => "\n",
+        ?r  => "\r",
+        ?t  => "\t",
+        ?u  => nil, 
+      })
+
+      def parse_string
+        if scan(STRING)
+          return '' if self[1].empty?
+          string = self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+            if u = UNESCAPE_MAP[$&[1]]
+              u
+            else # \uXXXX
+              bytes = ''
+              i = 0
+              while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+                bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+                i += 1
+              end
+              JSON::UTF16toUTF8.iconv(bytes)
+            end
+          end
+          if string.respond_to?(:force_encoding)
+            string.force_encoding(Encoding::UTF_8)
+          end
+          string
+        else
+          UNPARSED
+        end
+      rescue Iconv::Failure => e
+        raise GeneratorError, "Caught #{e.class}: #{e}"
+      end
+
+      def parse_value
+        case
+        when scan(FLOAT)
+          Float(self[1])
+        when scan(INTEGER)
+          Integer(self[1])
+        when scan(TRUE)
+          true
+        when scan(FALSE)
+          false
+        when scan(NULL)
+          nil
+        when (string = parse_string) != UNPARSED
+          string
+        when scan(ARRAY_OPEN)
+          @current_nesting += 1
+          ary = parse_array
+          @current_nesting -= 1
+          ary
+        when scan(OBJECT_OPEN)
+          @current_nesting += 1
+          obj = parse_object
+          @current_nesting -= 1
+          obj
+        when @allow_nan && scan(NAN)
+          NaN
+        when @allow_nan && scan(INFINITY)
+          Infinity
+        when @allow_nan && scan(MINUS_INFINITY)
+          MinusInfinity
+        else
+          UNPARSED
+        end
+      end
+
+      def parse_array
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = @array_class.new
+        delim = false
+        until eos?
+          case
+          when (value = parse_value) != UNPARSED
+            delim = false
+            result << value
+            skip(IGNORE)
+            if scan(COLLECTION_DELIMITER)
+              delim = true
+            elsif match?(ARRAY_CLOSE)
+              ;
+            else
+              raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
+            end
+          when scan(ARRAY_CLOSE)
+            if delim
+              raise ParserError, "expected next element in array at '#{peek(20)}'!"
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in array at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+
+      def parse_object
+        raise NestingError, "nesting of #@current_nesting is too deep" if
+          @max_nesting.nonzero? && @current_nesting > @max_nesting
+        result = @object_class.new
+        delim = false
+        until eos?
+          case
+          when (string = parse_string) != UNPARSED
+            skip(IGNORE)
+            unless scan(PAIR_DELIMITER)
+              raise ParserError, "expected ':' in object at '#{peek(20)}'!"
+            end
+            skip(IGNORE)
+            unless (value = parse_value).equal? UNPARSED
+              result[@symbolize_names ? string.to_sym : string] = value
+              delim = false
+              skip(IGNORE)
+              if scan(COLLECTION_DELIMITER)
+                delim = true
+              elsif match?(OBJECT_CLOSE)
+                ;
+              else
+                raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
+              end
+            else
+              raise ParserError, "expected value in object at '#{peek(20)}'!"
+            end
+          when scan(OBJECT_CLOSE)
+            if delim
+              raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
+            end
+            if @create_id and klassname = result[@create_id]
+              klass = JSON.deep_const_get klassname
+              break unless klass and klass.json_creatable?
+              result = klass.json_create(result)
+            end
+            break
+          when skip(IGNORE)
+            ;
+          else
+            raise ParserError, "unexpected token in object at '#{peek(20)}'!"
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/lib/json/pure.rb

@@ -0,0 +1,77 @@
+require 'json/common'
+require 'json/pure/parser'
+require 'json/pure/generator'
+
+module JSON
+  begin
+    require 'iconv'
+    # An iconv instance to convert from UTF8 to UTF16 Big Endian.
+    UTF16toUTF8 = Iconv.new('utf-8', 'utf-16be') # :nodoc:
+    # An iconv instance to convert from UTF16 Big Endian to UTF8.
+    UTF8toUTF16 = Iconv.new('utf-16be', 'utf-8') # :nodoc:
+    UTF8toUTF16.iconv('no bom')
+  rescue LoadError
+    raise MissingUnicodeSupport,
+      "iconv couldn't be loaded, which is required for UTF-8/UTF-16 conversions"
+  rescue Errno::EINVAL, Iconv::InvalidEncoding
+    # Iconv doesn't support big endian utf-16. Let's try to hack this manually
+    # into the converters.
+    begin
+      old_verbose, $VERBSOSE = $VERBOSE, nil
+      # An iconv instance to convert from UTF8 to UTF16 Big Endian.
+      UTF16toUTF8 = Iconv.new('utf-8', 'utf-16') # :nodoc:
+      # An iconv instance to convert from UTF16 Big Endian to UTF8.
+      UTF8toUTF16 = Iconv.new('utf-16', 'utf-8') # :nodoc:
+      UTF8toUTF16.iconv('no bom')
+      if UTF8toUTF16.iconv("\xe2\x82\xac") == "\xac\x20"
+        swapper = Class.new do
+          def initialize(iconv) # :nodoc:
+            @iconv = iconv
+          end
+
+          def iconv(string) # :nodoc:
+            result = @iconv.iconv(string)
+            JSON.swap!(result)
+          end
+        end
+        UTF8toUTF16 = swapper.new(UTF8toUTF16) # :nodoc:
+      end
+      if UTF16toUTF8.iconv("\xac\x20") == "\xe2\x82\xac"
+        swapper = Class.new do
+          def initialize(iconv) # :nodoc:
+            @iconv = iconv
+          end
+
+          def iconv(string) # :nodoc:
+            string = JSON.swap!(string.dup)
+            @iconv.iconv(string)
+          end
+        end
+        UTF16toUTF8 = swapper.new(UTF16toUTF8) # :nodoc:
+      end
+    rescue Errno::EINVAL, Iconv::InvalidEncoding
+      raise MissingUnicodeSupport, "iconv doesn't seem to support UTF-8/UTF-16 conversions"
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+
+  # Swap consecutive bytes of _string_ in place.
+  def self.swap!(string) # :nodoc:
+    0.upto(string.size / 2) do |i|
+      break unless string[2 * i + 1]
+      string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
+    end
+    string
+  end
+
+  # This module holds all the modules/classes that implement JSON's
+  # functionality in pure ruby.
+  module Pure
+    $DEBUG and warn "Using pure library for JSON."
+    JSON.parser = Parser
+    JSON.generator = Generator
+  end
+
+  JSON_LOADED = true
+end

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/lib/json/version.rb

@@ -0,0 +1,8 @@
+module JSON
+  # JSON version
+  VERSION         = '1.4.3'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/lib/json.rb

@@ -0,0 +1,10 @@
+require 'json/common'
+module JSON
+  require 'json/version'
+
+  begin
+    require 'json/ext'
+  rescue LoadError
+    require 'json/pure'
+  end
+end

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail1.json

@@ -0,0 +1 @@
+"A JSON payload should be an object or array, not a string."

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail10.json

@@ -0,0 +1 @@
+{"Extra value after close": true} "misplaced quoted value"

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail11.json

@@ -0,0 +1 @@
+{"Illegal expression": 1 + 2}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail12.json

@@ -0,0 +1 @@
+{"Illegal invocation": alert()}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail13.json

@@ -0,0 +1 @@
+{"Numbers cannot have leading zeroes": 013}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail14.json

@@ -0,0 +1 @@
+{"Numbers cannot be hex": 0x14}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail18.json

@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail19.json

@@ -0,0 +1 @@
+{"Missing colon" null}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail2.json

@@ -0,0 +1 @@
+["Unclosed array"

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail20.json

@@ -0,0 +1 @@
+{"Double colon":: null}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail21.json

@@ -0,0 +1 @@
+{"Comma instead of colon", null}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail22.json

@@ -0,0 +1 @@
+["Colon instead of comma": false]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail23.json

@@ -0,0 +1 @@
+["Bad value", truth]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail24.json

@@ -0,0 +1 @@
+['single quote']

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail25.json

@@ -0,0 +1 @@
+["tab	character	in	string	"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail27.json

@@ -0,0 +1,2 @@
+["line
+break"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail28.json

@@ -0,0 +1,2 @@
+["line\
+break"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail3.json

@@ -0,0 +1 @@
+{unquoted_key: "keys must be quoted"}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail4.json

@@ -0,0 +1 @@
+["extra comma",]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail5.json

@@ -0,0 +1 @@
+["double extra comma",,]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail6.json

@@ -0,0 +1 @@
+[   , "<-- missing value"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail7.json

@@ -0,0 +1 @@
+["Comma after the close"],

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail8.json

@@ -0,0 +1 @@
+["Extra close"]]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/fail9.json

@@ -0,0 +1 @@
+{"Extra comma": true,}

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/pass1.json

@@ -0,0 +1,56 @@
+[
+    "JSON Test Pattern pass1",
+    {"object with 1 member":["array with 1 element"]},
+    {},
+    [],
+    -42,
+    true,
+    false,
+    null,
+    {
+        "integer": 1234567890,
+        "real": -9876.543210,
+        "e": 0.123456789e-12,
+        "E": 1.234567890E+34,
+        "":  23456789012E666,
+        "zero": 0,
+        "one": 1,
+        "space": " ",
+        "quote": "\"",
+        "backslash": "\\",
+        "controls": "\b\f\n\r\t",
+        "slash": "/ & \/",
+        "alpha": "abcdefghijklmnopqrstuvwyz",
+        "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
+        "digit": "0123456789",
+        "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
+        "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
+        "true": true,
+        "false": false,
+        "null": null,
+        "array":[  ],
+        "object":{  },
+        "address": "50 St. James Street",
+        "url": "http://www.JSON.org/",
+        "comment": "// /* <!-- --",
+        "# -- --> */": " ",
+        " s p a c e d " :[1,2 , 3
+
+,
+
+4 , 5        ,          6           ,7        ],
+        "compact": [1,2,3,4,5,6,7],
+        "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
+        "quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
+        "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
+: "A key can be any string"
+    },
+    0.5 ,98.6
+,
+99.44
+,
+
+1066
+
+
+,"rosebud"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/pass15.json

@@ -0,0 +1 @@
+["Illegal backslash escape: \x15"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/pass16.json

@@ -0,0 +1 @@
+["Illegal backslash escape: \'"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/pass17.json

@@ -0,0 +1 @@
+["Illegal backslash escape: \017"]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/pass2.json

@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/pass26.json

@@ -0,0 +1 @@
+["tab\   character\   in\  string\  "]

data/etc/isolate/jruby-1.8/gems/json_pure-1.4.3/tests/fixtures/pass3.json

@@ -0,0 +1,6 @@
+{
+    "JSON Test Pattern pass3": {
+        "The outermost value": "must be an object or array.",
+        "In this test": "It is an object."
+    }
+}