activesupport 2.3.2 → 2.3.3

data/CHANGELOG

@@ -1,3 +1,10 @@
+*2.3.3 (July 20, 2009)*
+
+* JSON: +Object#to_json+ calls +as_json+ to coerce itself into something natively encodable like +Hash+, +Integer+, or +String+. Override +as_json+ instead of +to_json+ so you're JSON-library-agnostic.  [Jeremy Kemper]
+
+* Allow MemCacheStore to be initialized with a MemCache-like object instead of addresses and options [Bryan Helmkamp]
+
+
 *2.3.2 [Final] (March 15, 2009)*
 
 * XmlMini supports LibXML and Nokogiri backends.  #2084, #2190 [Bart ten Brinke, Aaron Patterson]

data/lib/active_support/cache.rb

@@ -91,11 +91,16 @@ module ActiveSupport
     class Store
       cattr_accessor :logger
 
+      attr_reader :silence, :logger_off
+
       def silence!
         @silence = true
         self
       end
 
+      alias silence? silence
+      alias logger_off? logger_off
+
       # Fetches data from the cache, using the given key. If there is data in
       # the cache with the given key, then that data is returned.
       #
@@ -220,8 +225,16 @@ module ActiveSupport
       end
 
       private
+        def expires_in(options)
+          expires_in = options && options[:expires_in]
+
+          raise ":expires_in must be a number" if expires_in && !expires_in.is_a?(Numeric)
+
+          expires_in || 0
+        end
+
         def log(operation, key, options)
-          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}") if logger && !@silence && !@logger_off
+          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}") if logger && !silence? && !logger_off?
         end
     end
   end

data/lib/active_support/cache/mem_cache_store.rb

@@ -23,7 +23,12 @@ module ActiveSupport
         DELETED     = "DELETED\r\n"
       end
 
-      attr_reader :addresses
+      def self.build_mem_cache(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        addresses = ["localhost"] if addresses.empty?
+        MemCache.new(addresses, options)
+      end
 
       # Creates a new MemCacheStore object, with the given memcached server
       # addresses. Each address is either a host name, or a host-with-port string
@@ -34,15 +39,20 @@ module ActiveSupport
       # If no addresses are specified, then MemCacheStore will connect to
       # localhost port 11211 (the default memcached port).
       def initialize(*addresses)
-        addresses = addresses.flatten
-        options = addresses.extract_options!
-        addresses = ["localhost"] if addresses.empty?
-        @addresses = addresses
-        @data = MemCache.new(addresses, options)
+        if addresses.first.respond_to?(:get)
+          @data = addresses.first
+        else
+          @data = self.class.build_mem_cache(*addresses)
+        end
 
         extend Strategy::LocalCache
       end
 
+      # Reads multiple keys from the cache.
+      def read_multi(*keys)
+        @data.get_multi keys
+      end
+
       def read(key, options = nil) # :nodoc:
         super
         @data.get(key, raw?(options))
@@ -120,10 +130,6 @@ module ActiveSupport
       end
 
       private
-        def expires_in(options)
-          (options && options[:expires_in]) || 0
-        end
-
         def raw?(options)
           options && options[:raw]
         end

data/lib/active_support/cache/strategy/local_cache.rb

@@ -38,7 +38,7 @@ module ActiveSupport
           elsif value.nil?
             value = super
             local_cache.write(key, value || NULL) if local_cache
-            value
+            value.duplicable? ? value.dup : value
           else
             # forcing the value to be immutable
             value.duplicable? ? value.dup : value

data/lib/active_support/core_ext/date/calculations.rb

@@ -1,7 +1,7 @@
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Date #:nodoc:
-      # Enables the use of time calculations within Time itself
+      # Enables the use of time calculations within Date itself
       module Calculations
         def self.included(base) #:nodoc:
           base.extend ClassMethods

data/lib/active_support/core_ext/hash/conversions.rb

@@ -1,6 +1,14 @@
 require 'date'
+require 'active_support/core_ext/module/attribute_accessors'
 
 module ActiveSupport #:nodoc:
+  # these accessors are here because people using ActiveResource and REST to integrate with other systems
+  # have to be able to control the default behavior of rename_key. dasherize_xml is set to true to emulate
+  # existing behavior. In a future version it should be set to false by default.
+  mattr_accessor :dasherize_xml
+  mattr_accessor :camelize_xml
+  self.dasherize_xml = true
+  self.camelize_xml  = false
   module CoreExtensions #:nodoc:
     module Hash #:nodoc:
       module Conversions
@@ -143,10 +151,11 @@ module ActiveSupport #:nodoc:
         end
 
         def rename_key(key, options = {})
-          camelize = options.has_key?(:camelize) && options[:camelize]
-          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+          camelize  = options.has_key?(:camelize) ? options[:camelize]   : ActiveSupport.camelize_xml
+          dasherize = options.has_key?(:dasherize) ? options[:dasherize] : ActiveSupport.dasherize_xml
           key = key.camelize if camelize
-          dasherize ? key.dasherize : key
+          key = key.dasherize if dasherize
+          key
         end
 
         module ClassMethods
@@ -221,7 +230,7 @@ module ActiveSupport #:nodoc:
               case params.class.to_s
                 when "Hash"
                   params.inject({}) do |h,(k,v)|
-                    h[k.to_s.underscore.tr("-", "_")] = unrename_keys(v)
+                    h[k.to_s.tr("-", "_")] = unrename_keys(v)
                     h
                   end
                 when "Array"

data/lib/active_support/core_ext/kernel/debugger.rb

@@ -2,12 +2,14 @@ module Kernel
   unless respond_to?(:debugger)
     # Starts a debugging session if ruby-debug has been loaded (call script/server --debugger to do load it).
     def debugger
-      Rails.logger.info "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
+      message = "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
+      defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
     end
   end
 
   def breakpoint
-    Rails.logger.info "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
+    message = "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
+    defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
     debugger
   end
 end

data/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext/array"
+
 # Extends the module object with module and instance accessors for class attributes, 
 # just like the native attr* accessors for instance attributes.
 #

data/lib/active_support/core_ext/module/delegation.rb

@@ -108,12 +108,21 @@ class Module
 
     prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
 
-    allow_nil = options[:allow_nil] && "#{to} && "
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
 
     methods.each do |method|
-      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+      on_nil =
+        if options[:allow_nil]
+          'return'
+        else
+          %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        end
+
+      module_eval(<<-EOS, file, line)
         def #{prefix}#{method}(*args, &block)                           # def customer_name(*args, &block)
-          #{allow_nil}#{to}.__send__(#{method.inspect}, *args, &block)  #   client && client.__send__(:name, *args, &block)
+          #{on_nil} if #{to}.nil?
+          #{to}.__send__(#{method.inspect}, *args, &block)  #   client && client.__send__(:name, *args, &block)
         end                                                             # end
       EOS
     end

data/lib/active_support/core_ext/module/model_naming.rb

@@ -1,13 +1,15 @@
 module ActiveSupport
   class ModelName < String
-    attr_reader :singular, :plural, :cache_key, :partial_path
+    attr_reader :singular, :plural, :element, :collection, :partial_path
+    alias_method :cache_key, :collection
 
     def initialize(name)
       super
-      @singular = underscore.tr('/', '_').freeze
-      @plural = @singular.pluralize.freeze
-      @cache_key = tableize.freeze
-      @partial_path = "#{@cache_key}/#{demodulize.underscore}".freeze
+      @singular = ActiveSupport::Inflector.underscore(self).tr('/', '_').freeze
+      @plural = ActiveSupport::Inflector.pluralize(@singular).freeze
+      @element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).freeze
+      @collection = ActiveSupport::Inflector.tableize(self).freeze
+      @partial_path = "#{@collection}/#{@element}".freeze
     end
   end
 
@@ -16,7 +18,7 @@ module ActiveSupport
       # Returns an ActiveSupport::ModelName object for module. It can be
       # used to retrieve all kinds of naming-related information.
       def model_name
-        @model_name ||= ModelName.new(name)
+        @model_name ||= ::ActiveSupport::ModelName.new(name)
       end
     end
   end

data/lib/active_support/core_ext/numeric/bytes.rb

@@ -3,41 +3,47 @@ module ActiveSupport #:nodoc:
     module Numeric #:nodoc:
       # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
       module Bytes
+        KILOBYTE = 1024
+        MEGABYTE = KILOBYTE * 1024
+        GIGABYTE = MEGABYTE * 1024
+        TERABYTE = GIGABYTE * 1024
+        PETABYTE = TERABYTE * 1024
+        EXABYTE  = PETABYTE * 1024
+
         def bytes
           self
         end
         alias :byte :bytes
 
         def kilobytes
-          self * 1024
+          self * KILOBYTE
         end
         alias :kilobyte :kilobytes
 
         def megabytes
-          self * 1024.kilobytes
+          self * MEGABYTE
         end
         alias :megabyte :megabytes
 
         def gigabytes
-          self * 1024.megabytes 
+          self * GIGABYTE
         end
         alias :gigabyte :gigabytes
 
         def terabytes
-          self * 1024.gigabytes
+          self * TERABYTE
         end
         alias :terabyte :terabytes
-        
+
         def petabytes
-          self * 1024.terabytes
+          self * PETABYTE
         end
         alias :petabyte :petabytes
-        
+
         def exabytes
-          self * 1024.petabytes
+          self * EXABYTE
         end
         alias :exabyte :exabytes
-        
       end
     end
   end

data/lib/active_support/core_ext/string/access.rb

@@ -41,9 +41,15 @@ module ActiveSupport #:nodoc:
           #   "hello".first(2)  # => "he"
           #   "hello".first(10) # => "hello"
           def first(limit = 1)
-            mb_chars[0..(limit - 1)].to_s
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              mb_chars[0...limit].to_s
+            end
           end
-          
+
           # Returns the last character of the string or the last +limit+ characters.
           #
           # Examples: 
@@ -51,7 +57,13 @@ module ActiveSupport #:nodoc:
           #   "hello".last(2)  # => "lo"
           #   "hello".last(10) # => "hello"
           def last(limit = 1)
-            (mb_chars[(-limit)..-1] || self).to_s
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              mb_chars[(-limit)..-1].to_s
+            end
           end
         end
       else
@@ -69,11 +81,23 @@ module ActiveSupport #:nodoc:
           end
 
           def first(limit = 1)
-            self[0..(limit - 1)]
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              to(limit - 1)
+            end
           end
 
           def last(limit = 1)
-            from(-limit) || self
+            if limit == 0
+              ''
+            elsif limit >= size
+              self
+            else
+              from(-limit)
+            end
           end
         end
       end

data/lib/active_support/duration.rb

@@ -67,10 +67,12 @@ module ActiveSupport
 
     def inspect #:nodoc:
       consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
-      [:years, :months, :days, :minutes, :seconds].map do |length|
+      parts = [:years, :months, :days, :minutes, :seconds].map do |length|
         n = consolidated[length]
         "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
-      end.compact.to_sentence(:locale => :en)
+      end.compact
+      parts = ["0 seconds"] if parts.empty?
+      parts.to_sentence(:locale => :en)
     end
 
     protected

data/lib/active_support/json.rb

@@ -1,23 +1,2 @@
-module ActiveSupport
-  # If true, use ISO 8601 format for dates and times. Otherwise, fall back to the Active Support legacy format.
-  mattr_accessor :use_standard_json_time_format
-
-  class << self
-    def escape_html_entities_in_json
-      @escape_html_entities_in_json
-    end
-
-    def escape_html_entities_in_json=(value)
-      ActiveSupport::JSON::Encoding.escape_regex = \
-        if value
-          /[\010\f\n\r\t"\\><&]/
-        else
-          /[\010\f\n\r\t"\\]/
-        end
-      @escape_html_entities_in_json = value
-    end
-  end
-end
-
-require 'active_support/json/encoding'
 require 'active_support/json/decoding'
+require 'active_support/json/encoding'

data/lib/active_support/json/backends/jsongem.rb

@@ -0,0 +1,38 @@
+require 'json' unless defined?(JSON)
+
+module ActiveSupport
+  module JSON
+    ParseError = ::JSON::ParserError unless const_defined?(:ParseError)
+
+    module Backends
+      module JSONGem
+        extend self
+
+        # Converts a JSON string into a Ruby object.
+        def decode(json)
+          data = ::JSON.parse(json)
+          if ActiveSupport.parse_json_times
+            convert_dates_from(data)
+          else
+            data
+          end
+        end
+
+      private
+        def convert_dates_from(data)
+          case data
+            when DATE_REGEX
+              DateTime.parse(data)
+            when Array
+              data.map! { |d| convert_dates_from(d) }
+            when Hash
+              data.each do |key, value|
+                data[key] = convert_dates_from(value)
+              end
+            else data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/json/backends/yaml.rb

@@ -0,0 +1,85 @@
+require 'active_support/core_ext/string/starts_ends_with'
+
+module ActiveSupport
+  module JSON
+    unless const_defined?(:ParseError)
+      class ParseError < StandardError
+      end
+    end
+
+    module Backends
+      module Yaml
+        extend 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
+          # Ensure that ":" and "," are always followed by a space
+          def convert_json_to_yaml(json) #:nodoc:
+            require 'strscan' unless defined? ::StringScanner
+            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(/\\([\\\/]|u[[:xdigit:]]{4})/) do
+                ustr = $1
+                if ustr.start_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.start_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
+          end
+      end
+    end
+  end
+end