activesupport 1.4.4 → 2.0.0

data/lib/active_support/json/decoding.rb

@@ -0,0 +1,60 @@
+require 'yaml'
+require 'strscan'
+
+module ActiveSupport
+  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})?)?$/
+
+        # 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
+
+          if marks.empty?
+            json.gsub(/\\\//, '/')
+          else
+            # FIXME: multiple slow enumerations
+            output = ([0] + marks.map(&:succ)).
+                      zip(marks + [json.length]).
+                      map { |left, right| json[left..right] }.
+                      join(" ")
+            times.each { |i| output[i-1] = ' ' }
+            output.gsub!(/\\\//, '/')
+            output
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+class Date
+  def to_json(options = nil) #:nodoc:
+    %("#{strftime("%Y/%m/%d")}")
+  end
+end

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

@@ -0,0 +1,5 @@
+class DateTime
+  def to_json(options = nil) #:nodoc:
+    %("#{strftime("%Y/%m/%d %H:%M:%S %z")}")
+  end
+end

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

@@ -0,0 +1,12 @@
+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) } * ', '}]"
+  end
+end

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

@@ -0,0 +1,5 @@
+class FalseClass
+  def to_json(options = nil) #:nodoc:
+    'false'
+  end
+end

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

@@ -0,0 +1,50 @@
+class Hash
+  # Returns a JSON string representing the hash.
+  #
+  # Without any +options+, the returned JSON string will include all
+  # the hash keys. For example:
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json
+  #
+  #   {"name": "Konata Izumi", 1: 2, "age": 16}
+  #
+  # The keys in the JSON string are unordered due to the nature of hashes.
+  #
+  # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the
+  # attributes included, and will accept 1 or more hash keys to include/exclude.
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:only => [:name, 'age'])
+  #
+  #   {"name": "Konata Izumi", "age": 16}
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:except => 1)
+  #
+  #   {"name": "Konata Izumi", "age": 16}
+  #
+  # The +options+ also filter down to any hash values. This is particularly
+  # useful for converting hashes containing ActiveRecord objects or any object
+  # that responds to options in their <tt>to_json</tt> method. For example:
+  #
+  #   users = User.find(:all)
+  #   { :users => users, :count => users.size }.to_json(:include => :posts)
+  #
+  # 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 options[:except]
+      hash_keys = hash_keys - Array(options[:except])
+    elsif options[:only]
+      hash_keys = hash_keys & Array(options[:only])
+    end
+
+    returning result = '{' do
+      result << hash_keys.map do |key|
+        "#{ActiveSupport::JSON.encode(key)}: #{ActiveSupport::JSON.encode(self[key], options)}"
+      end * ', '
+      result << '}'
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+class NilClass
+  def to_json(options = nil) #:nodoc:
+    'null'
+  end
+end

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

@@ -0,0 +1,5 @@
+class Numeric
+  def to_json(options = nil) #:nodoc:
+    to_s
+  end
+end

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

@@ -0,0 +1,6 @@
+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)
+  end
+end

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

@@ -0,0 +1,5 @@
+class Regexp
+  def to_json(options = nil) #:nodoc:
+    inspect
+  end
+end

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

@@ -0,0 +1,30 @@
+module ActiveSupport
+  module JSON
+    module Encoding
+      ESCAPED_CHARS = {
+        "\010" =>  '\b',
+        "\f"   =>  '\f',
+        "\n"   =>  '\n',
+        "\r"   =>  '\r',
+        "\t"   =>  '\t',
+        '"'    =>  '\"',
+        '\\'   =>  '\\\\',
+        '>'    =>  '\u003E',
+        '<'    =>  '\u003C',
+        '&'    =>  '\u0026'
+      }
+    end
+  end
+end
+
+class String
+  def to_json(options = nil) #:nodoc:
+    '"' + gsub(/[\010\f\n\r\t"\\><&]/) { |s|
+      ActiveSupport::JSON::Encoding::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}/, '\\\\u\&')
+    } + '"'
+  end
+end

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

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

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

@@ -0,0 +1,5 @@
+class Time
+  def to_json(options = nil) #:nodoc:
+    to_datetime.to_json(options)
+  end
+end

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

@@ -0,0 +1,5 @@
+class TrueClass
+  def to_json(options = nil) #:nodoc:
+    'true'
+  end
+end

data/lib/active_support/json/encoding.rb

@@ -0,0 +1,38 @@
+require 'active_support/json/variable'
+
+require 'active_support/json/encoders/object' # Require explicitly for rdoc.
+Dir["#{File.dirname(__FILE__)}/encoders/**/*.rb"].each do |file|
+  basename = File.basename(file, '.rb')
+  unless basename == 'object'
+    require "active_support/json/encoders/#{basename}"
+  end
+end
+
+module ActiveSupport
+  module JSON
+    class CircularReferenceError < StandardError
+    end
+
+    class << self
+      REFERENCE_STACK_VARIABLE = :json_reference_stack #:nodoc:
+
+      # Converts a Ruby object into a JSON string.
+      def encode(value, options = {})
+        raise_on_circular_reference(value) do
+          value.send(:to_json, options)
+        end
+      end
+
+      protected
+        def raise_on_circular_reference(value) #:nodoc:
+          stack = Thread.current[REFERENCE_STACK_VARIABLE] ||= []
+          raise CircularReferenceError, 'object references itself' if
+            stack.include? value
+          stack << value
+          yield
+        ensure
+          stack.pop
+        end
+    end
+  end
+end

data/lib/active_support/json/variable.rb

@@ -0,0 +1,10 @@
+module ActiveSupport
+  module JSON
+    # A string that returns itself as its JSON-encoded form.
+    class Variable < String
+      def to_json(options=nil)
+        self
+      end
+    end
+  end
+end

data/lib/active_support/multibyte.rb

@@ -1,7 +1,9 @@
-module ActiveSupport::Multibyte #:nodoc:
-  DEFAULT_NORMALIZATION_FORM = :kc
-  NORMALIZATIONS_FORMS = [:c, :kc, :d, :kd]
-  UNICODE_VERSION = '5.0.0'
+module ActiveSupport
+  module Multibyte #:nodoc:
+    DEFAULT_NORMALIZATION_FORM = :kc
+    NORMALIZATIONS_FORMS = [:c, :kc, :d, :kd]
+    UNICODE_VERSION = '5.0.0'
+  end
 end
 
-require 'active_support/multibyte/chars'
+require 'active_support/multibyte/chars'

data/lib/active_support/multibyte/chars.rb

@@ -41,6 +41,12 @@ module ActiveSupport::Multibyte #:nodoc:
       @string
     end
     
+    # Make duck-typing with String possible
+    def respond_to?(method)
+      super || @string.respond_to?(method) || handler.respond_to?(method) ||
+        (method.to_s =~ /(.*)!/ && handler.respond_to?($1)) || false
+    end
+    
     # Create a new Chars instance.
     def initialize(str)
       @string = str.respond_to?(:string) ? str.string : str

data/lib/active_support/multibyte/handlers/utf8_handler.rb

@@ -140,6 +140,83 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
         bidx ? (u_unpack(str.slice(0...bidx)).size) : nil
       end
       
+      # Works just like the indexed replace method on string, except instead of byte offsets you specify
+      # character offsets.
+      #
+      # Example:
+      #
+      #   s = "Müller"
+      #   s.chars[2] = "e" # Replace character with offset 2
+      #   s
+      #   #=> "Müeler"
+      #
+      #   s = "Müller"
+      #   s.chars[1, 2] = "ö" # Replace 2 characters at character offset 1
+      #   s
+      #   #=> "Möler"
+      def []=(str, *args)
+        replace_by = args.pop
+        # Indexed replace with regular expressions already works
+        return str[*args] = replace_by if args.first.is_a?(Regexp)
+        result = u_unpack(str)
+        if args[0].is_a?(Fixnum)
+          raise IndexError, "index #{args[0]} out of string" if args[0] >= result.length
+          min = args[0]
+          max = args[1].nil? ? min : (min + args[1] - 1)
+          range = Range.new(min, max)
+          replace_by = [replace_by].pack('U') if replace_by.is_a?(Fixnum)
+        elsif args.first.is_a?(Range)
+          raise RangeError, "#{args[0]} out of range" if args[0].min >= result.length
+          range = args[0]
+        else
+          needle = args[0].to_s
+          min = index(str, needle)
+          max = min + length(needle) - 1
+          range = Range.new(min, max)
+        end
+        result[range] = u_unpack(replace_by)
+        str.replace(result.pack('U*'))
+      end
+      
+      # Works just like String#rjust, only integer specifies characters instead of bytes.
+      #
+      # Example:
+      #
+      #   "¾ cup".chars.rjust(8).to_s
+      #   #=> "   ¾ cup"
+      #
+      #   "¾ cup".chars.rjust(8, " ").to_s # Use non-breaking whitespace
+      #   #=> "   ¾ cup"
+      def rjust(str, integer, padstr=' ')
+        justify(str, integer, :right, padstr)
+      end
+      
+      # Works just like String#ljust, only integer specifies characters instead of bytes.
+      #
+      # Example:
+      #
+      #   "¾ cup".chars.rjust(8).to_s
+      #   #=> "¾ cup   "
+      #
+      #   "¾ cup".chars.rjust(8, " ").to_s # Use non-breaking whitespace
+      #   #=> "¾ cup   "
+      def ljust(str, integer, padstr=' ')
+        justify(str, integer, :left, padstr)
+      end
+      
+      # Works just like String#center, only integer specifies characters instead of bytes.
+      #
+      # Example:
+      #
+      #   "¾ cup".chars.center(8).to_s
+      #   #=> " ¾ cup  "
+      #
+      #   "¾ cup".chars.center(8, " ").to_s # Use non-breaking whitespace
+      #   #=> " ¾ cup  "
+      def center(str, integer, padstr=' ')
+        justify(str, integer, :center, padstr)
+      end
+      
       # Does Unicode-aware rstrip
       def rstrip(str)
         str.gsub(UNICODE_TRAILERS_PAT, '')
@@ -169,11 +246,17 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       # Implements Unicode-aware slice with codepoints. Slicing on one point returns the codepoints for that
       # character.
       def slice(str, *args)
-        if (args.size == 2 && args.first.is_a?(Range))
-          raise TypeError, 'cannot convert Range into Integer' # Do as if we were native
+        if args.size > 2
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" # Do as if we were native
+        elsif (args.size == 2 && !(args.first.is_a?(Numeric) || args.first.is_a?(Regexp)))
+          raise TypeError, "cannot convert #{args.first.class} into Integer" # Do as if we were native
+        elsif (args.size == 2 && !args[1].is_a?(Numeric))
+          raise TypeError, "cannot convert #{args[1].class} into Integer" # Do as if we were native
         elsif args[0].kind_of? Range
           cps = u_unpack(str).slice(*args)
           cps.nil? ? nil : cps.pack('U*')
+        elsif args[0].kind_of? Regexp
+          str.slice(*args)
         elsif args.size == 1 && args[0].kind_of?(Numeric)
           u_unpack(str)[args[0]]
         else
@@ -200,8 +283,8 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       # Returns the KC normalization of the string by default. NFKC is considered the best normalization form for
       # passing strings to databases and validations.
       #
-      # * <tt>str</tt>: The string to perform normalization on.
-      # * <tt>form</tt>: The form you want to normalize in. Should be one of the following: :c, :kc, :d or :kd.
+      # * <tt>str</tt> - The string to perform normalization on.
+      # * <tt>form</tt> - The form you want to normalize in. Should be one of the following: :c, :kc, :d or :kd.
       def normalize(str, form=ActiveSupport::Multibyte::DEFAULT_NORMALIZATION_FORM)
         # See http://www.unicode.org/reports/tr15, Table 1
         codepoints = u_unpack(str)
@@ -235,8 +318,8 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
       
       # Used to translate an offset from bytes to characters, for instance one received from a regular expression match
       def translate_offset(str, byte_offset)
-        return 0 if str == ''
         return nil if byte_offset.nil?
+        return 0 if str == ''
         chunk = str[0..byte_offset]
         begin
           begin
@@ -338,6 +421,33 @@ module ActiveSupport::Multibyte::Handlers #:nodoc:
         unpacked.flatten
       end
       
+      # Justifies a string in a certain way. Valid values for <tt>way</tt> are <tt>:right</tt>, <tt>:left</tt> and
+      # <tt>:center</tt>. Is primarily used as a helper method by <tt>rjust</tt>, <tt>ljust</tt> and <tt>center</tt>.
+      def justify(str, integer, way, padstr=' ')
+        raise ArgumentError, "zero width padding" if padstr.length == 0
+        padsize = integer - size(str)
+        padsize = padsize > 0 ? padsize : 0
+        case way
+        when :right
+          str.dup.insert(0, padding(padsize, padstr))
+        when :left
+          str.dup.insert(-1, padding(padsize, padstr))
+        when :center
+          lpad = padding((padsize / 2.0).floor, padstr)
+          rpad = padding((padsize / 2.0).ceil, padstr)
+          str.dup.insert(0, lpad).insert(-1, rpad)
+        end
+      end
+      
+      # Generates a padding string of a certain size.
+      def padding(padsize, padstr=' ')
+        if padsize != 0
+          slice(padstr * ((padsize / size(padstr)) + 1), 0, padsize)
+        else
+          ''
+        end
+      end
+      
       # Convert characters to a different case
       def to_case(way, str)
         u_unpack(str).map do |codepoint|