activesupport 2.3.2 → 2.3.3

data/lib/active_support/json/decoding.rb

@@ -1,82 +1,33 @@
-require 'yaml'
-require 'strscan'
+require 'active_support/core_ext/module/attribute_accessors'
 
 module ActiveSupport
+  # Look for and parse json strings that look like ISO 8601 times.
+  mattr_accessor :parse_json_times
+
   module JSON
-    class ParseError < StandardError
-    end
-    
     class << self
-      # Converts a JSON string into a Ruby object.
-      def decode(json)
-        YAML.load(convert_json_to_yaml(json))
-      rescue ArgumentError => e
-        raise ParseError, "Invalid JSON string"
-      end
-      
-      protected
-        # matches YAML-formatted dates
-        DATE_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[ \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)$/
+      delegate :decode, :to => :backend
 
-        # Ensure that ":" and "," are always followed by a space
-        def convert_json_to_yaml(json) #:nodoc:
-          scanner, quoting, marks, pos, times = StringScanner.new(json), false, [], nil, []
-          while scanner.scan_until(/(\\['"]|['":,\\]|\\.)/)
-            case char = scanner[1]
-            when '"', "'"
-              if !quoting
-                quoting = char
-                pos = scanner.pos
-              elsif quoting == char
-                if json[pos..scanner.pos-2] =~ DATE_REGEX
-                  # found a date, track the exact positions of the quotes so we can remove them later.
-                  # oh, and increment them for each current mark, each one is an extra padded space that bumps
-                  # the position in the final YAML output
-                  total_marks = marks.size
-                  times << pos+total_marks << scanner.pos+total_marks
-                end
-                quoting = false
-              end
-            when ":",","
-              marks << scanner.pos - 1 unless quoting
-            end
-          end
+      def backend
+        self.backend = "Yaml" unless defined?(@backend)
+        @backend
+      end
 
-          if marks.empty?
-            json.gsub(/\\([\\\/]|u[[:xdigit:]]{4})/) do
-              ustr = $1
-              if ustr.starts_with?('u')
-                [ustr[1..-1].to_i(16)].pack("U")
-              elsif ustr == '\\'
-                '\\\\'
-              else
-                ustr
-              end
-            end
-          else
-            left_pos  = [-1].push(*marks)
-            right_pos = marks << scanner.pos + scanner.rest_size
-            output    = []
-            left_pos.each_with_index do |left, i|
-              scanner.pos = left.succ
-              output << scanner.peek(right_pos[i] - scanner.pos + 1).gsub(/\\([\\\/]|u[[:xdigit:]]{4})/) do
-                ustr = $1
-                if ustr.starts_with?('u')
-                  [ustr[1..-1].to_i(16)].pack("U")
-                elsif ustr == '\\'
-                '\\\\'
-                else
-                  ustr
-                end
-              end
-            end
-            output = output * " "
-            
-            times.each { |i| output[i-1] = ' ' }
-            output.gsub!(/\\\//, '/')
-            output
-          end
+      def backend=(name)
+        if name.is_a?(Module)
+          @backend = name
+        else
+          require "active_support/json/backends/#{name.to_s.downcase}.rb"
+          @backend = ActiveSupport::JSON::Backends::const_get(name)
         end
+      end
+
+      def with_backend(name)
+        old_backend, self.backend = backend, name
+        yield
+      ensure
+        self.backend = old_backend
+      end
     end
   end
 end

data/lib/active_support/json/encoders/date.rb

@@ -1,21 +1,22 @@
 class Date
-  # Returns a JSON string representing the date. If ActiveSupport.use_standard_json_time_format is set to true, the
-  # ISO 8601 format is used.
+  # Coerces the date to a string for JSON encoding.
+  #
+  # ISO 8601 format is used if ActiveSupport::JSON::Encoding.use_standard_json_time_format is set.
   #
   # ==== Examples
   #
-  #   # With ActiveSupport.use_standard_json_time_format = true
+  #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
   #   Date.new(2005,2,1).to_json
   #   # => "2005-02-01"
   #
-  #   # With ActiveSupport.use_standard_json_time_format = false
+  #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
   #   Date.new(2005,2,1).to_json
   #   # => "2005/02/01"
-  def to_json(options = nil)
-    if ActiveSupport.use_standard_json_time_format
-      %("#{strftime("%Y-%m-%d")}")
+  def as_json(options = nil)
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      strftime("%Y-%m-%d")
     else
-      %("#{strftime("%Y/%m/%d")}")
+      strftime("%Y/%m/%d")
     end
   end
 end

data/lib/active_support/json/encoders/date_time.rb

@@ -1,21 +1,22 @@
 class DateTime
-  # Returns a JSON string representing the datetime. If ActiveSupport.use_standard_json_time_format is set to true, the
-  # ISO 8601 format is used.
+  # Coerces the datetime to a string for JSON encoding.
+  #
+  # ISO 8601 format is used if ActiveSupport::JSON::Encoding.use_standard_json_time_format is set.
   #
   # ==== Examples
   #
-  #   # With ActiveSupport.use_standard_json_time_format = true
+  #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
   #   DateTime.civil(2005,2,1,15,15,10).to_json
   #   # => "2005-02-01T15:15:10+00:00"
   #
-  #   # With ActiveSupport.use_standard_json_time_format = false
+  #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
   #   DateTime.civil(2005,2,1,15,15,10).to_json
   #   # => "2005/02/01 15:15:10 +0000"
-  def to_json(options = nil)
-    if ActiveSupport.use_standard_json_time_format
-      xmlschema.inspect
+  def as_json(options = nil)
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      xmlschema
     else
-      strftime('"%Y/%m/%d %H:%M:%S %z"')
+      strftime('%Y/%m/%d %H:%M:%S %z')
     end
   end
 end

data/lib/active_support/json/encoders/enumerable.rb

@@ -1,12 +1,17 @@
 module Enumerable
-  # Returns a JSON string representing the enumerable. Any +options+
-  # given will be passed on to its elements. For example:
-  #
-  #   users = User.find(:all)
-  #   # => users.to_json(:only => :name)
-  #
-  # will pass the <tt>:only => :name</tt> option to each user.
-  def to_json(options = {}) #:nodoc:
-    "[#{map { |value| ActiveSupport::JSON.encode(value, options) } * ', '}]"
+  # Coerces the enumerable to an array for JSON encoding.
+  def as_json(options = nil) #:nodoc:
+    to_a
+  end
+end
+
+class Array
+  # Returns a JSON string representing the Array. +options+ are passed to each element.
+  def to_json(options = nil) #:nodoc:
+    "[#{map { |value| ActiveSupport::JSON.encode(value, options) } * ','}]"
+  end
+
+  def as_json(options = nil) #:nodoc:
+    self
   end
 end

data/lib/active_support/json/encoders/false_class.rb

@@ -1,5 +1,7 @@
 class FalseClass
-  def to_json(options = nil) #:nodoc:
-    'false'
+  AS_JSON = ActiveSupport::JSON::Variable.new('false').freeze
+
+  def as_json(options = nil) #:nodoc:
+    AS_JSON
   end
 end

data/lib/active_support/json/encoders/hash.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array/wrapper'
+
 class Hash
   # Returns a JSON string representing the hash.
   #
@@ -28,19 +30,27 @@ class Hash
   # would pass the <tt>:include => :posts</tt> option to <tt>users</tt>,
   # allowing the posts association in the User model to be converted to JSON
   # as well.
-  def to_json(options = {}) #:nodoc:
-    hash_keys = self.keys
-
-    if except = options[:except]
-      hash_keys = hash_keys - Array.wrap(except)
-    elsif only = options[:only]
-      hash_keys = hash_keys & Array.wrap(only)
-    end
+  def to_json(options = nil) #:nodoc:
+    hash = as_json(options)
 
     result = '{'
-    result << hash_keys.map do |key|
-      "#{ActiveSupport::JSON.encode(key.to_s)}: #{ActiveSupport::JSON.encode(self[key], options)}"
-    end * ', '
+    result << hash.map do |key, value|
+      "#{ActiveSupport::JSON.encode(key.to_s)}:#{ActiveSupport::JSON.encode(value, options)}"
+    end * ','
     result << '}'
   end
+
+  def as_json(options = nil) #:nodoc:
+    if options
+      if attrs = options[:except]
+        except(*Array.wrap(attrs))
+      elsif attrs = options[:only]
+        slice(*Array.wrap(attrs))
+      else
+        self
+      end
+    else
+      self
+    end
+  end
 end

data/lib/active_support/json/encoders/nil_class.rb

@@ -1,5 +1,7 @@
 class NilClass
-  def to_json(options = nil) #:nodoc:
-    'null'
+  AS_JSON = ActiveSupport::JSON::Variable.new('null').freeze
+
+  def as_json(options = nil) #:nodoc:
+    AS_JSON
   end
 end

data/lib/active_support/json/encoders/numeric.rb

@@ -2,4 +2,20 @@ class Numeric
   def to_json(options = nil) #:nodoc:
     to_s
   end
+
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+end
+
+class Float
+  def to_json(options = nil) #:nodoc:
+    to_s
+  end
+end
+
+class Integer
+  def to_json(options = nil) #:nodoc:
+    to_s
+  end
 end

data/lib/active_support/json/encoders/object.rb

@@ -1,6 +1,10 @@
 class Object
   # Dumps object in JSON (JavaScript Object Notation). See www.json.org for more info.
-  def to_json(options = {})
-    ActiveSupport::JSON.encode(instance_values, options)
+  def to_json(options = nil)
+    ActiveSupport::JSON.encode(as_json(options))
+  end
+
+  def as_json(options = nil)
+    instance_values
   end
 end

data/lib/active_support/json/encoders/regexp.rb

@@ -2,4 +2,8 @@ class Regexp
   def to_json(options = nil) #:nodoc:
     inspect
   end
+
+  def as_json(options = nil) #:nodoc:
+    self
+  end
 end

data/lib/active_support/json/encoders/string.rb

@@ -1,36 +1,9 @@
-module ActiveSupport
-  module JSON
-    module Encoding
-      mattr_accessor :escape_regex
-
-      ESCAPED_CHARS = {
-        "\010" =>  '\b',
-        "\f"   =>  '\f',
-        "\n"   =>  '\n',
-        "\r"   =>  '\r',
-        "\t"   =>  '\t',
-        '"'    =>  '\"',
-        '\\'   =>  '\\\\',
-        '>'    =>  '\u003E',
-        '<'    =>  '\u003C',
-        '&'    =>  '\u0026'
-      }
-    end
-  end
-end
-
-ActiveSupport.escape_html_entities_in_json = true
-
 class String
   def to_json(options = nil) #:nodoc:
-    json = '"' + gsub(ActiveSupport::JSON::Encoding.escape_regex) { |s|
-      ActiveSupport::JSON::Encoding::ESCAPED_CHARS[s]
-    }
-    json.force_encoding('ascii-8bit') if respond_to?(:force_encoding)
-    json.gsub(/([\xC0-\xDF][\x80-\xBF]|
-             [\xE0-\xEF][\x80-\xBF]{2}|
-             [\xF0-\xF7][\x80-\xBF]{3})+/nx) { |s|
-      s.unpack("U*").pack("n*").unpack("H*")[0].gsub(/.{4}/, '\\\\u\&')
-    } + '"'
+    ActiveSupport::JSON::Encoding.escape(self)
+  end
+
+  def as_json(options = nil) #:nodoc:
+    self
   end
 end

data/lib/active_support/json/encoders/symbol.rb

@@ -1,5 +1,5 @@
 class Symbol
-  def to_json(options = {}) #:nodoc:
-    ActiveSupport::JSON.encode(to_s, options)
+  def as_json(options = nil) #:nodoc:
+    to_s
   end
 end

data/lib/active_support/json/encoders/time.rb

@@ -1,21 +1,22 @@
 class Time
-  # Returns a JSON string representing the time. If ActiveSupport.use_standard_json_time_format is set to true, the
-  # ISO 8601 format is used.
+  # Coerces the time to a string for JSON encoding.
+  #
+  # ISO 8601 format is used if ActiveSupport::JSON::Encoding.use_standard_json_time_format is set.
   #
   # ==== Examples
   #
-  #   # With ActiveSupport.use_standard_json_time_format = true
+  #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
   #   Time.utc(2005,2,1,15,15,10).to_json
   #   # => "2005-02-01T15:15:10Z"
   #
-  #   # With ActiveSupport.use_standard_json_time_format = false
+  #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
   #   Time.utc(2005,2,1,15,15,10).to_json
   #   # => "2005/02/01 15:15:10 +0000"
-  def to_json(options = nil)
-    if ActiveSupport.use_standard_json_time_format
-      xmlschema.inspect
+  def as_json(options = nil)
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      xmlschema
     else
-      %("#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)}")
+      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
     end
   end
 end

data/lib/active_support/json/encoders/true_class.rb

@@ -1,5 +1,7 @@
 class TrueClass
-  def to_json(options = nil) #:nodoc:
-    'true'
+  AS_JSON = ActiveSupport::JSON::Variable.new('true').freeze
+
+  def as_json(options = nil) #:nodoc:
+    AS_JSON
   end
 end

data/lib/active_support/json/encoding.rb

@@ -1,20 +1,91 @@
+# encoding: utf-8
+require 'active_support/core_ext/module/delegation'
+require 'active_support/deprecation'
+
 module ActiveSupport
+  class << self
+    delegate :use_standard_json_time_format, :use_standard_json_time_format=,
+      :escape_html_entities_in_json, :escape_html_entities_in_json=,
+      :to => :'ActiveSupport::JSON::Encoding'
+  end
+
   module JSON
-    class CircularReferenceError < StandardError
+    # matches YAML-formatted dates
+    DATE_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[ \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?))$/
+
+    class << self
+      delegate :encode, :to => :'ActiveSupport::JSON::Encoding'
     end
 
-    # Converts a Ruby object into a JSON string.
-    def self.encode(value, options = {})
-      seen = (options[:seen] ||= [])
-      raise CircularReferenceError, 'object references itself' if seen.include?(value)
-      seen << value
-      value.send(:to_json, options)
-    ensure
-      seen.pop
+    module Encoding #:nodoc:
+      class CircularReferenceError < StandardError
+      end
+
+      ESCAPED_CHARS = {
+        "\010" =>  '\b',
+        "\f"   =>  '\f',
+        "\n"   =>  '\n',
+        "\r"   =>  '\r',
+        "\t"   =>  '\t',
+        '"'    =>  '\"',
+        '\\'   =>  '\\\\',
+        '>'    =>  '\u003E',
+        '<'    =>  '\u003C',
+        '&'    =>  '\u0026' }
+
+      class << self
+        # If true, use ISO 8601 format for dates and times. Otherwise, fall back to the Active Support legacy format.
+        attr_accessor :use_standard_json_time_format
+
+        attr_accessor :escape_regex
+        attr_reader :escape_html_entities_in_json
+
+        def escape_html_entities_in_json=(value)
+          self.escape_regex = \
+            if @escape_html_entities_in_json = value
+              /[\010\f\n\r\t"\\><&]/
+            else
+              /[\010\f\n\r\t"\\]/
+            end
+        end
+
+        def escape(string)
+          string = string.dup.force_encoding(::Encoding::BINARY) if string.respond_to?(:force_encoding)
+          json = string.
+            gsub(escape_regex) { |s| ESCAPED_CHARS[s] }.
+            gsub(/([\xC0-\xDF][\x80-\xBF]|
+                   [\xE0-\xEF][\x80-\xBF]{2}|
+                   [\xF0-\xF7][\x80-\xBF]{3})+/nx) { |s|
+            s.unpack("U*").pack("n*").unpack("H*")[0].gsub(/.{4}/n, '\\\\u\&')
+          }
+          %("#{json}")
+        end
+
+        # Converts a Ruby object into a JSON string.
+        def encode(value, options = nil)
+          options = {} unless Hash === options
+          seen = (options[:seen] ||= [])
+          raise CircularReferenceError, 'object references itself' if seen.include?(value)
+          seen << value
+          value.to_json(options)
+        ensure
+          seen.pop
+        end
+      end
+
+      self.escape_html_entities_in_json = true
     end
+
+    CircularReferenceError = Deprecation::DeprecatedConstantProxy.new('ActiveSupport::JSON::CircularReferenceError', Encoding::CircularReferenceError)
   end
 end
 
+# Hack to load json gem first so we can overwrite its to_json.
+begin
+  require 'json'
+rescue LoadError
+end
+
 require 'active_support/json/variable'
 require 'active_support/json/encoders/date'
 require 'active_support/json/encoders/date_time'