scout 5.1.2 → 5.1.3

data/vendor/json_pure/lib/json/add/core.rb

@@ -7,6 +7,19 @@ unless Object.const_defined?(:JSON) and ::JSON.const_defined?(:JSON_LOADED) and
 end
 require 'date'
 
+class Symbol
+  def to_json(*a)
+    {
+      JSON.create_id => self.class.name,
+      's' => to_s,
+    }.to_json(*a)
+  end
+
+  def self.json_create(o)
+    o['s'].to_sym
+  end
+end
+
 class Time
   def self.json_create(object)
     if usec = object.delete('u') # used to be tv_usec -> tv_nsec
@@ -21,7 +34,7 @@ class Time
 
   def to_json(*args)
     {
-      'json_class' => self.class.name,
+      JSON.create_id => self.class.name,
       's' => tv_sec,
       'n' => respond_to?(:tv_nsec) ? tv_nsec : tv_usec * 1000
     }.to_json(*args)
@@ -37,7 +50,7 @@ class Date
 
   def to_json(*args)
     {
-      'json_class' => self.class.name,
+      JSON.create_id => self.class.name,
       'y' => year,
       'm' => month,
       'd' => day,
@@ -63,7 +76,7 @@ class DateTime
 
   def to_json(*args)
     {
-      'json_class' => self.class.name,
+      JSON.create_id => self.class.name,
       'y' => year,
       'm' => month,
       'd' => day,
@@ -83,7 +96,7 @@ class Range
 
   def to_json(*args)
     {
-      'json_class'   => self.class.name,
+      JSON.create_id   => self.class.name,
       'a'         => [ first, last, exclude_end? ]
     }.to_json(*args)
   end
@@ -98,7 +111,7 @@ class Struct
     klass = self.class.name
     klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
     {
-      'json_class' => klass,
+      JSON.create_id => klass,
       'v'     => values,
     }.to_json(*args)
   end
@@ -113,7 +126,7 @@ class Exception
 
   def to_json(*args)
     {
-      'json_class' => self.class.name,
+      JSON.create_id => self.class.name,
       'm'   => message,
       'b' => backtrace,
     }.to_json(*args)
@@ -127,7 +140,7 @@ class Regexp
 
   def to_json(*)
     {
-      'json_class' => self.class.name,
+      JSON.create_id => self.class.name,
       'o' => options,
       's' => source,
     }.to_json

data/vendor/json_pure/lib/json/add/rails.rb

@@ -10,7 +10,7 @@ class Object
   def self.json_create(object)
     obj = new
     for key, value in object
-      next if key == 'json_class'
+      next if key == JSON.create_id
       instance_variable_set "@#{key}", value
     end
     obj
@@ -18,7 +18,7 @@ class Object
 
   def to_json(*a)
     result = {
-      'json_class' => self.class.name
+      JSON.create_id => self.class.name
     }
     instance_variables.inject(result) do |r, name|
       r[name[1..-1]] = instance_variable_get name

data/vendor/json_pure/lib/json/common.rb

@@ -1,4 +1,5 @@
 require 'json/version'
+require 'iconv'
 
 module JSON
   class << self
@@ -32,12 +33,16 @@ module JSON
     # level (absolute namespace path?). If there doesn't exist a constant at
     # the given path, an ArgumentError is raised.
     def deep_const_get(path) # :nodoc:
-      path = path.to_s
-      path.split(/::/).inject(Object) do |p, c|
+      path.to_s.split(/::/).inject(Object) do |p, c|
         case
         when c.empty?             then p
         when p.const_defined?(c)  then p.const_get(c)
-        else                      raise ArgumentError, "can't find const #{path}"
+        else
+          begin
+            p.const_missing(c)
+          rescue NameError
+            raise ArgumentError, "can't find const #{path}"
+          end
         end
       end
     end
@@ -58,6 +63,20 @@ module JSON
       end
       self.state = generator::State
       const_set :State, self.state
+      const_set :SAFE_STATE_PROTOTYPE, State.new.freeze
+      const_set :FAST_STATE_PROTOTYPE, State.new(
+        :indent         => '',
+        :space          => '',
+        :object_nl      => "",
+        :array_nl       => "",
+        :max_nesting    => false
+      ).freeze
+      const_set :PRETTY_STATE_PROTOTYPE, State.new(
+        :indent         => '  ',
+        :space          => ' ',
+        :object_nl      => "\n",
+        :array_nl       => "\n"
+      ).freeze
     end
 
     # Returns the JSON generator modul, that is used by JSON. This might be
@@ -74,7 +93,7 @@ module JSON
   end
   self.create_id = 'json_class'
 
-  NaN           = (-1.0) ** 0.5
+  NaN           = 0.0/0
 
   Infinity      = 1.0/0
 
@@ -90,22 +109,22 @@ module JSON
   # deep.
   class NestingError < ParserError; end
 
+  # :stopdoc:
+  class CircularDatastructure < NestingError; end
+  # :startdoc:
+
   # This exception is raised, if a generator or unparser error occurs.
   class GeneratorError < JSONError; end
   # For backwards compatibility
   UnparserError = GeneratorError
 
-  # If a circular data structure is encountered while unparsing
-  # this exception is raised.
-  class CircularDatastructure < GeneratorError; end
-
   # This exception is raised, if the required unicode support is missing on the
   # system. Usually this means, that the iconv library is not installed.
   class MissingUnicodeSupport < JSONError; end
 
   module_function
 
-  # Parse the JSON string _source_ into a Ruby data structure and return it.
+  # Parse the JSON document _source_ into a Ruby data structure and return it.
   #
   # _opts_ can have the following
   # keys:
@@ -115,16 +134,21 @@ module JSON
   # * *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 parse(source, opts = {})
-    JSON.parser.new(source, opts).parse
+    Parser.new(source, opts).parse
   end
 
-  # Parse the JSON string _source_ into a Ruby data structure and return it.
+  # Parse the JSON document _source_ into a Ruby data structure and return it.
   # The bang version of the parse method, defaults to the more dangerous values
-  # for the _opts_ hash, so be sure only to parse trusted _source_ strings.
+  # for the _opts_ hash, so be sure only to parse trusted _source_ documents.
   #
   # _opts_ can have the following keys:
   # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
@@ -139,15 +163,14 @@ module JSON
   #   defaults to true.
   def parse!(source, opts = {})
     opts = {
-      :max_nesting => false,
-      :allow_nan => true
+      :max_nesting  => false,
+      :allow_nan    => true
     }.update(opts)
-    JSON.parser.new(source, opts).parse
+    Parser.new(source, opts).parse
   end
 
-  # Unparse the Ruby data structure _obj_ into a single line JSON string and
-  # return it. _state_ is
-  # * a JSON::State object,
+  # Generate a JSON document from the Ruby data structure _obj_ and return
+  # it. _state_ is * a JSON::State object,
   # * or a Hash like object (responding to to_hash),
   # * an object convertible into a hash by a to_h method,
   # that is used as or to configure a State object.
@@ -162,8 +185,6 @@ module JSON
   # * *space_before*: a string that is put before a : pair delimiter (default: ''),
   # * *object_nl*: a string that is put at the end of a JSON object (default: ''), 
   # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
-  # * *check_circular*: true if checking for circular data structures
-  #   should be done (the default), false otherwise.
   # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
   #   generated, otherwise an exception is thrown, if these values are
   #   encountered. This options defaults to false.
@@ -174,13 +195,21 @@ module JSON
   # See also the fast_generate for the fastest creation method with the least
   # amount of sanity checks, and the pretty_generate method for some
   # defaults for a pretty output.
-  def generate(obj, state = nil)
-    if state
-      state = State.from_state(state)
+  def generate(obj, opts = nil)
+    if opts
+      if opts.respond_to? :to_hash
+        opts = opts.to_hash
+      elsif opts.respond_to? :to_h
+        opts = opts.to_h
+      else
+        raise TypeError, "can't convert #{opts.class} into Hash"
+      end
+      state = SAFE_STATE_PROTOTYPE.dup
+      state = state.configure(opts)
     else
-      state = State.new
+      state = SAFE_STATE_PROTOTYPE
     end
-    obj.to_json(state)
+    state.generate(obj)
   end
 
   # :stopdoc:
@@ -190,14 +219,26 @@ module JSON
   module_function :unparse
   # :startdoc:
 
-  # Unparse the Ruby data structure _obj_ into a single line JSON string and
-  # return it. This method disables the checks for circles in Ruby objects, and
-  # also generates NaN, Infinity, and, -Infinity float values.
+  # Generate a JSON document from the Ruby data structure _obj_ and return it.
+  # This method disables the checks for circles in Ruby objects.
   #
   # *WARNING*: Be careful not to pass any Ruby data structures with circles as
   # _obj_ argument, because this will cause JSON to go into an infinite loop.
-  def fast_generate(obj)
-    obj.to_json(nil)
+  def fast_generate(obj, opts = nil)
+    if opts
+      if opts.respond_to? :to_hash
+        opts = opts.to_hash
+      elsif opts.respond_to? :to_h
+        opts = opts.to_h
+      else
+        raise TypeError, "can't convert #{opts.class} into Hash"
+      end
+      state = FAST_STATE_PROTOTYPE.dup
+      state.configure(opts)
+    else
+      state = FAST_STATE_PROTOTYPE
+    end
+    state.generate(obj)
   end
 
   # :stopdoc:
@@ -206,19 +247,13 @@ module JSON
   module_function :fast_unparse
   # :startdoc:
 
-  # Unparse the Ruby data structure _obj_ into a JSON string and return it. The
-  # returned string is a prettier form of the string returned by #unparse.
+  # Generate a JSON document from the Ruby data structure _obj_ and return it.
+  # The returned document is a prettier form of the document returned by
+  # #unparse.
   #
   # The _opts_ argument can be used to configure the generator, see the
   # generate method for a more detailed explanation.
   def pretty_generate(obj, opts = nil)
-    state = JSON.state.new(
-      :indent     => '  ',
-      :space      => ' ',
-      :object_nl  => "\n",
-      :array_nl   => "\n",
-      :check_circular => true
-    )
     if opts
       if opts.respond_to? :to_hash
         opts = opts.to_hash
@@ -227,9 +262,12 @@ module JSON
       else
         raise TypeError, "can't convert #{opts.class} into Hash"
       end
+      state = PRETTY_STATE_PROTOTYPE.dup
       state.configure(opts)
+    else
+      state = PRETTY_STATE_PROTOTYPE
     end
-    obj.to_json(state)
+    state.generate(obj)
   end
 
   # :stopdoc:
@@ -270,8 +308,6 @@ module JSON
       proc.call result
     end
   end
-  private :recurse_proc
-  module_function :recurse_proc
 
   alias restore load
   module_function :restore
@@ -307,9 +343,16 @@ module JSON
   rescue JSON::NestingError
     raise ArgumentError, "exceed depth limit"
   end
+
+  # Shortuct for iconv.
+  def self.iconv(to, from, string)
+    Iconv.iconv(to, from, string).first
+  end
 end
 
 module ::Kernel
+  private
+
   # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
   # one line.
   def j(*objs)

data/vendor/json_pure/lib/json/pure.rb

@@ -10,6 +10,9 @@ module JSON
     # 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.
@@ -51,9 +54,6 @@ module JSON
     ensure
       $VERBOSE = old_verbose
     end
-  rescue LoadError
-    raise MissingUnicodeSupport,
-      "iconv couldn't be loaded, which is required for UTF-8/UTF-16 conversions"
   end
 
   # Swap consecutive bytes of _string_ in place.

data/vendor/json_pure/lib/json/pure/generator.rb

@@ -34,17 +34,25 @@ module JSON
     "\x1f" => '\u001f',
     '"'   =>  '\"',
     '\\'  =>  '\\\\',
-    '/'   =>  '\/',
   } # :nodoc:
 
   # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
   # UTF16 big endian characters as \u????, and return it.
-  if String.method_defined?(:force_encoding)
+  if defined?(::Encoding)
     def utf8_to_json(string) # :nodoc:
       string = string.dup
       string << '' # XXX workaround: avoid buffer sharing
-      string.force_encoding(Encoding::ASCII_8BIT)
-      string.gsub!(/["\\\/\x0-\x1f]/) { MAP[$&] }
+      string.force_encoding(::Encoding::ASCII_8BIT)
+      string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
+      string.force_encoding(::Encoding::UTF_8)
+      string
+    end
+
+    def utf8_to_json_ascii(string) # :nodoc:
+      string = string.dup
+      string << '' # XXX workaround: avoid buffer sharing
+      string.force_encoding(::Encoding::ASCII_8BIT)
+      string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
       string.gsub!(/(
                       (?:
                         [\xc2-\xdf][\x80-\xbf]    |
@@ -57,14 +65,18 @@ module JSON
                       s = JSON::UTF8toUTF16.iconv(c).unpack('H*')[0]
                       s.gsub!(/.{4}/n, '\\\\u\&')
                     }
-      string.force_encoding(Encoding::UTF_8)
+      string.force_encoding(::Encoding::UTF_8)
       string
     rescue Iconv::Failure => e
       raise GeneratorError, "Caught #{e.class}: #{e}"
     end
   else
     def utf8_to_json(string) # :nodoc:
-      string = string.gsub(/["\\\/\x0-\x1f]/) { MAP[$&] }
+      string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
+    end
+
+    def utf8_to_json_ascii(string) # :nodoc:
+      string = string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
       string.gsub!(/(
                       (?:
                         [\xc2-\xdf][\x80-\xbf]    |
@@ -82,7 +94,7 @@ module JSON
       raise GeneratorError, "Caught #{e.class}: #{e}"
     end
   end
-  module_function :utf8_to_json
+  module_function :utf8_to_json, :utf8_to_json_ascii
 
   module Pure
     module Generator
@@ -100,7 +112,7 @@ module JSON
           when Hash
             new(opts)
           else
-            new
+            SAFE_STATE_PROTOTYPE
           end
         end
 
@@ -113,22 +125,20 @@ module JSON
         # * *space_before*: a string that is put before a : pair delimiter (default: ''),
         # * *object_nl*: a string that is put at the end of a JSON object (default: ''), 
         # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
-        # * *check_circular*: true if checking for circular data structures
-        #   should be done (the default), false otherwise.
-        # * *check_circular*: true if checking for circular data structures
-        #   should be done, false (the default) otherwise.
+        # * *check_circular*: is deprecated now, use the :max_nesting option instead,
+        # * *max_nesting*: sets the maximum level of data structure nesting in
+        #   the generated JSON, max_nesting = 0 if no maximum should be checked.
         # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
         #   generated, otherwise an exception is thrown, if these values are
         #   encountered. This options defaults to false.
         def initialize(opts = {})
-          @seen = {}
           @indent         = ''
           @space          = ''
           @space_before   = ''
           @object_nl      = ''
           @array_nl       = ''
-          @check_circular = true
           @allow_nan      = false
+          @ascii_only     = false
           configure opts
         end
 
@@ -160,10 +170,10 @@ module JSON
             raise NestingError, "nesting of #{current_nesting} is too deep"
         end
 
-        # Returns true, if circular data structures should be checked,
+        # Returns true, if circular data structures are checked,
         # otherwise returns false.
         def check_circular?
-          @check_circular
+          !@max_nesting.zero?
         end
 
         # Returns true if NaN, Infinity, and -Infinity should be considered as
@@ -172,21 +182,8 @@ module JSON
           @allow_nan
         end
 
-        # Returns _true_, if _object_ was already seen during this generating
-        # run. 
-        def seen?(object)
-          @seen.key?(object.__id__)
-        end
-
-        # Remember _object_, to find out if it was already encountered (if a
-        # cyclic data structure is if a cyclic data structure is rendered). 
-        def remember(object)
-          @seen[object.__id__] = true
-        end
-
-        # Forget _object_ for this generating run.
-        def forget(object)
-          @seen.delete object.__id__
+        def ascii_only?
+          @ascii_only
         end
 
         # Configure this State instance with the Hash _opts_, and return
@@ -197,8 +194,8 @@ module JSON
           @space_before   = opts[:space_before] if opts.key?(:space_before)
           @object_nl      = opts[:object_nl] if opts.key?(:object_nl)
           @array_nl       = opts[:array_nl] if opts.key?(:array_nl)
-          @check_circular = !!opts[:check_circular] if opts.key?(:check_circular)
           @allow_nan      = !!opts[:allow_nan] if opts.key?(:allow_nan)
+          @ascii_only     = opts[:ascii_only] if opts.key?(:ascii_only)
           if !opts.key?(:max_nesting) # defaults to 19
             @max_nesting = 19
           elsif opts[:max_nesting]
@@ -213,11 +210,27 @@ module JSON
         # passed to the configure method.
         def to_h
           result = {}
-          for iv in %w[indent space space_before object_nl array_nl check_circular allow_nan max_nesting]
+          for iv in %w[indent space space_before object_nl array_nl allow_nan max_nesting]
             result[iv.intern] = instance_variable_get("@#{iv}")
           end
           result
         end
+
+        # Generates a valid JSON document from object +obj+ and returns the
+        # result. If no valid JSON document can be created this method raises a
+        # GeneratorError exception.
+        def generate(obj)
+          result = obj.to_json(self)
+          if result !~ /\A\s*(?:\[.*\]|\{.*\})\s*\Z/m
+            raise GeneratorError, "only generation of JSON objects or arrays allowed"
+          end
+          result
+        end
+
+        # Return the value returned by method +name+.
+        def [](name)
+          __send__ name
+        end
       end
 
       module GeneratorMethods
@@ -236,27 +249,14 @@ module JSON
           # _depth_ is used to find out nesting depth, to indent accordingly.
           def to_json(state = nil, depth = 0, *)
             if state
-              state = JSON.state.from_state(state)
+              state = State.from_state(state)
               state.check_max_nesting(depth)
-              json_check_circular(state) { json_transform(state, depth) }
-            else
-              json_transform(state, depth)
             end
+            json_transform(state, depth)
           end
 
           private
 
-          def json_check_circular(state)
-            if state and state.check_circular?
-              state.seen?(self) and raise JSON::CircularDatastructure,
-                  "circular data structures not supported!"
-              state.remember self
-            end
-            yield
-          ensure
-            state and state.forget self
-          end
-
           def json_shift(state, depth)
             state and not state.object_nl.empty? or return ''
             state.indent * depth
@@ -268,16 +268,22 @@ module JSON
               delim << state.object_nl
               result = '{'
               result << state.object_nl
-              result << map { |key,value|
-                s = json_shift(state, depth + 1)
-                s << key.to_s.to_json(state, depth + 1)
-                s << state.space_before
-                s << ':'
-                s << state.space
-                s << value.to_json(state, depth + 1)
-              }.join(delim)
+              depth += 1
+              first = true
+              indent = state && !state.object_nl.empty?
+              each { |key,value|
+                result << delim unless first
+                result << state.indent * depth if indent
+                result << key.to_s.to_json(state, depth)
+                result << state.space_before
+                result << ':'
+                result << state.space
+                result << value.to_json(state, depth)
+                first = false
+              }
+              depth -= 1
               result << state.object_nl
-              result << json_shift(state, depth)
+              result << state.indent * depth if indent if indent
               result << '}'
             else
               result = '{'
@@ -298,43 +304,32 @@ module JSON
           # _depth_ is used to find out nesting depth, to indent accordingly.
           def to_json(state = nil, depth = 0, *)
             if state
-              state = JSON.state.from_state(state)
+              state = State.from_state(state)
               state.check_max_nesting(depth)
-              json_check_circular(state) { json_transform(state, depth) }
-            else
-              json_transform(state, depth)
             end
+            json_transform(state, depth)
           end
 
           private
 
-          def json_check_circular(state)
-            if state and state.check_circular?
-              state.seen?(self) and raise JSON::CircularDatastructure,
-                "circular data structures not supported!"
-              state.remember self
-            end
-            yield
-          ensure
-            state and state.forget self
-          end
-
-          def json_shift(state, depth)
-            state and not state.array_nl.empty? or return ''
-            state.indent * depth
-          end
-
           def json_transform(state, depth)
             delim = ','
             if state
               delim << state.array_nl
               result = '['
               result << state.array_nl
-              result << map { |value|
-                json_shift(state, depth + 1) << value.to_json(state, depth + 1)
-              }.join(delim)
+              depth += 1
+              first = true
+              indent = state && !state.array_nl.empty?
+              each { |value|
+                result << delim unless first
+                result << state.indent * depth if indent
+                result << value.to_json(state, depth)
+                first = false
+              }
+              depth -= 1
               result << state.array_nl
-              result << json_shift(state, depth) 
+              result << state.indent * depth if indent
               result << ']'
             else
               '[' << map { |value| value.to_json }.join(delim) << ']'
@@ -352,13 +347,13 @@ module JSON
           def to_json(state = nil, *)
             case
             when infinite?
-              if !state || state.allow_nan?
+              if state && state.allow_nan?
                 to_s
               else
                 raise GeneratorError, "#{self} not allowed in JSON"
               end
             when nan?
-              if !state || state.allow_nan?
+              if state && state.allow_nan?
                 to_s
               else
                 raise GeneratorError, "#{self} not allowed in JSON"
@@ -370,18 +365,45 @@ module JSON
         end
 
         module String
-          # This string should be encoded with UTF-8 A call to this method
-          # returns a JSON string encoded with UTF16 big endian characters as
-          # \u????.
-          def to_json(*)
-            '"' << JSON.utf8_to_json(self) << '"'
+          if defined?(::Encoding)
+            # This string should be encoded with UTF-8 A call to this method
+            # returns a JSON string encoded with UTF16 big endian characters as
+            # \u????.
+            def to_json(*args)
+              state, = *args
+              state ||= State.from_state(state)
+              if encoding == ::Encoding::UTF_8
+                string = self
+              else
+                string = encode(::Encoding::UTF_8)
+              end
+              if state.ascii_only?
+                '"' << JSON.utf8_to_json_ascii(string) << '"'
+              else
+                '"' << JSON.utf8_to_json(string) << '"'
+              end
+            end
+          else
+            # This string should be encoded with UTF-8 A call to this method
+            # returns a JSON string encoded with UTF16 big endian characters as
+            # \u????.
+            def to_json(*args)
+              state, = *args
+              state ||= State.from_state(state)
+              if state.ascii_only?
+                '"' << JSON.utf8_to_json_ascii(self) << '"'
+              else
+                '"' << JSON.utf8_to_json(self) << '"'
+              end
+            end
           end
 
           # Module that holds the extinding methods if, the String module is
           # included.
           module Extend
-            # Raw Strings are JSON Objects (the raw bytes are stored in an array for the
-            # key "raw"). The Ruby String can be created by this module method.
+            # Raw Strings are JSON Objects (the raw bytes are stored in an
+            # array for the key "raw"). The Ruby String can be created by this
+            # module method.
             def json_create(o)
               o['raw'].pack('C*')
             end