activesupport_csi 2.3.5.p6

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

@@ -0,0 +1,22 @@
+class Date
+  # 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::JSON::Encoding.use_standard_json_time_format = true
+  #   Date.new(2005,2,1).to_json
+  #   # => "2005-02-01"
+  #
+  #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
+  #   Date.new(2005,2,1).to_json
+  #   # => "2005/02/01"
+  def as_json(options = nil)
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      strftime("%Y-%m-%d")
+    else
+      strftime("%Y/%m/%d")
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+class DateTime
+  # 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::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::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 as_json(options = nil)
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      xmlschema
+    else
+      strftime('%Y/%m/%d %H:%M:%S %z')
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Enumerable
+  # 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

@@ -0,0 +1,7 @@
+class FalseClass
+  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

@@ -0,0 +1,56 @@
+require 'active_support/core_ext/array/wrapper'
+
+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 = nil) #:nodoc:
+    hash = as_json(options)
+
+    result = '{'
+    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

@@ -0,0 +1,7 @@
+class NilClass
+  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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,10 @@
+class Object
+  # Dumps object in JSON (JavaScript Object Notation). See www.json.org for more info.
+  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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+class String
+  def to_json(options = nil) #:nodoc:
+    ActiveSupport::JSON::Encoding.escape(self)
+  end
+
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+class Time
+  # 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::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::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 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)})
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+class TrueClass
+  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

@@ -0,0 +1,102 @@
+# 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
+    # 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
+
+    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'
+require 'active_support/json/encoders/enumerable'
+require 'active_support/json/encoders/false_class'
+require 'active_support/json/encoders/hash'
+require 'active_support/json/encoders/nil_class'
+require 'active_support/json/encoders/numeric'
+require 'active_support/json/encoders/object'
+require 'active_support/json/encoders/regexp'
+require 'active_support/json/encoders/string'
+require 'active_support/json/encoders/symbol'
+require 'active_support/json/encoders/time'
+require 'active_support/json/encoders/true_class'

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/json.rb

@@ -0,0 +1,2 @@
+require 'active_support/json/decoding'
+require 'active_support/json/encoding'

data/lib/active_support/locale/en.yml

@@ -0,0 +1,33 @@
+en:
+  date:
+    formats:
+      # Use the strftime parameters for formats.
+      # When no format has been given, it uses default.
+      # You can provide other formats here if you like!
+      default: "%Y-%m-%d"
+      short: "%b %d"
+      long: "%B %d, %Y"
+      
+    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
+    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
+      
+    # Don't forget the nil at the beginning; there's no such thing as a 0th month
+    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
+    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
+    # Used in date_select and datime_select.
+    order: [ :year, :month, :day ]
+
+  time:
+    formats:
+      default: "%a, %d %b %Y %H:%M:%S %z"
+      short: "%d %b %H:%M"
+      long: "%B %d, %Y %H:%M"
+    am: "am"
+    pm: "pm"
+      
+# Used in array.to_sentence.
+  support:
+    array:
+      words_connector: ", "
+      two_words_connector: " and "
+      last_word_connector: ", and "

data/lib/active_support/memoizable.rb

@@ -0,0 +1,100 @@
+module ActiveSupport
+  module Memoizable
+    def self.memoized_ivar_for(symbol)
+      "@_memoized_#{symbol.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}".to_sym
+    end
+
+    module InstanceMethods
+      def self.included(base)
+        base.class_eval do
+          unless base.method_defined?(:freeze_without_memoizable)
+            alias_method_chain :freeze, :memoizable
+          end
+        end
+      end
+
+      def freeze_with_memoizable
+        memoize_all unless frozen?
+        freeze_without_memoizable
+      end
+
+      def memoize_all
+        prime_cache ".*"
+      end
+
+      def unmemoize_all
+        flush_cache ".*"
+      end
+
+      def prime_cache(*syms)
+        syms.each do |sym|
+          methods.each do |m|
+            if m.to_s =~ /^_unmemoized_(#{sym})/
+              if method(m).arity == 0
+                __send__($1)
+              else
+                ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
+                instance_variable_set(ivar, {})
+              end
+            end
+          end
+        end
+      end
+
+      def flush_cache(*syms, &block)
+        syms.each do |sym|
+          (methods + private_methods + protected_methods).each do |m|
+            if m.to_s =~ /^_unmemoized_(#{sym})/
+              ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
+              instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
+            end
+          end
+        end
+      end
+    end
+
+    def memoize(*symbols)
+      symbols.each do |symbol|
+        original_method = :"_unmemoized_#{symbol}"
+        memoized_ivar = ActiveSupport::Memoizable.memoized_ivar_for(symbol)
+
+        class_eval <<-EOS, __FILE__, __LINE__
+          include InstanceMethods                                                  # include InstanceMethods
+                                                                                   #
+          if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)
+            raise "Already memoized #{symbol}"                                     #   raise "Already memoized mime_type"
+          end                                                                      # end
+          alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type
+                                                                                   #
+          if instance_method(:#{symbol}).arity == 0                                # if instance_method(:mime_type).arity == 0
+            def #{symbol}(reload = false)                                          #   def mime_type(reload = false)
+              if reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?  #     if reload || !defined?(@_memoized_mime_type) || @_memoized_mime_type.empty?
+                #{memoized_ivar} = [#{original_method}.freeze]                     #       @_memoized_mime_type = [_unmemoized_mime_type.freeze]
+              end                                                                  #     end
+              #{memoized_ivar}[0]                                                  #     @_memoized_mime_type[0]
+            end                                                                    #   end
+          else                                                                     # else
+            def #{symbol}(*args)                                                   #   def mime_type(*args)
+              #{memoized_ivar} ||= {} unless frozen?                               #     @_memoized_mime_type ||= {} unless frozen?
+              reload = args.pop if args.last == true || args.last == :reload       #     reload = args.pop if args.last == true || args.last == :reload
+                                                                                   #
+              if defined?(#{memoized_ivar}) && #{memoized_ivar}                    #     if defined?(@_memoized_mime_type) && @_memoized_mime_type
+                if !reload && #{memoized_ivar}.has_key?(args)                      #       if !reload && @_memoized_mime_type.has_key?(args)
+                  #{memoized_ivar}[args]                                           #         @_memoized_mime_type[args]
+                elsif #{memoized_ivar}                                             #       elsif @_memoized_mime_type
+                  #{memoized_ivar}[args] = #{original_method}(*args).freeze        #         @_memoized_mime_type[args] = _unmemoized_mime_type(*args).freeze
+                end                                                                #       end
+              else                                                                 #     else
+                #{original_method}(*args)                                          #       _unmemoized_mime_type(*args)
+              end                                                                  #     end
+            end                                                                    #   end
+          end                                                                      # end
+                                                                                   #
+          if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)
+            private #{symbol.inspect}                                              #   private :mime_type
+          end                                                                      # end
+        EOS
+      end
+    end
+  end
+end

data/lib/active_support/message_encryptor.rb

@@ -0,0 +1,70 @@
+require 'openssl'
+
+module ActiveSupport
+  # MessageEncryptor is a simple way to encrypt values which get stored somewhere 
+  # you don't trust.
+  # 
+  # The cipher text and initialization vector are base64 encoded and returned to you.
+  #
+  # This can be used in situations similar to the MessageVerifier, but where you don't
+  # want users to be able to determine the value of the payload.
+  class MessageEncryptor
+    class InvalidMessage < StandardError; end
+    OpenSSLCipherError = OpenSSL::Cipher.const_defined?(:CipherError) ? OpenSSL::Cipher::CipherError : OpenSSL::CipherError
+
+    def initialize(secret, cipher = 'aes-256-cbc')
+      @secret = secret
+      @cipher = cipher
+    end
+    
+    def encrypt(value)
+      cipher = new_cipher
+      # Rely on OpenSSL for the initialization vector
+      iv = cipher.random_iv
+      
+      cipher.encrypt 
+      cipher.key = @secret
+      cipher.iv  = iv
+      
+      encrypted_data = cipher.update(Marshal.dump(value)) 
+      encrypted_data << cipher.final
+
+      [encrypted_data, iv].map {|v| ActiveSupport::Base64.encode64s(v)}.join("--")
+    end
+    
+    def decrypt(encrypted_message)
+      cipher = new_cipher
+      encrypted_data, iv = encrypted_message.split("--").map {|v| ActiveSupport::Base64.decode64(v)}
+      
+      cipher.decrypt
+      cipher.key = @secret
+      cipher.iv  = iv
+
+      decrypted_data = cipher.update(encrypted_data)
+      decrypted_data << cipher.final
+      
+      Marshal.load(decrypted_data)
+    rescue OpenSSLCipherError, TypeError
+      raise InvalidMessage
+    end
+    
+    def encrypt_and_sign(value)
+      verifier.generate(encrypt(value))
+    end
+    
+    def decrypt_and_verify(value)
+      decrypt(verifier.verify(value))
+    end
+    
+    
+    
+    private 
+      def new_cipher
+        OpenSSL::Cipher::Cipher.new(@cipher)
+      end
+      
+      def verifier
+        MessageVerifier.new(@secret)
+      end
+  end
+end

data/lib/active_support/message_verifier.rb

@@ -0,0 +1,79 @@
+module ActiveSupport
+  # MessageVerifier makes it easy to generate and verify messages which are signed
+  # to prevent tampering.
+  # 
+  # This is useful for cases like remember-me tokens and auto-unsubscribe links where the
+  # session store isn't suitable or available.
+  #
+  # Remember Me:
+  #   cookies[:remember_me] = @verifier.generate([@user.id, 2.weeks.from_now])
+  # 
+  # In the authentication filter:
+  #
+  #   id, time = @verifier.verify(cookies[:remember_me])
+  #   if time < Time.now
+  #     self.current_user = User.find(id)
+  #   end
+  # 
+  class MessageVerifier
+    class InvalidSignature < StandardError; end
+    
+    def initialize(secret, digest = 'SHA1')
+      @secret = secret
+      @digest = digest
+    end
+    
+    def verify(signed_message)
+      raise InvalidSignature if signed_message.blank?
+
+      data, digest = signed_message.split("--")
+      if data.present? && digest.present? && secure_compare(digest, generate_digest(data))
+        Marshal.load(ActiveSupport::Base64.decode64(data))
+      else
+        raise InvalidSignature
+      end
+    end
+    
+    def generate(value)
+      data = ActiveSupport::Base64.encode64s(Marshal.dump(value))
+      "#{data}--#{generate_digest(data)}"
+    end
+    
+    private
+      if "foo".respond_to?(:force_encoding)
+        # constant-time comparison algorithm to prevent timing attacks
+        def secure_compare(a, b)
+          a = a.dup.force_encoding(Encoding::BINARY)
+          b = b.dup.force_encoding(Encoding::BINARY)
+
+          if a.length == b.length
+            result = 0
+            for i in 0..(a.length - 1)
+              result |= a[i].ord ^ b[i].ord
+            end
+            result == 0
+          else
+            false
+          end
+        end
+      else
+        # For <= 1.8.6
+        def secure_compare(a, b)
+          if a.length == b.length
+            result = 0
+            for i in 0..(a.length - 1)
+              result |= a[i] ^ b[i]
+            end
+            result == 0
+          else
+            false
+          end
+        end
+      end
+
+      def generate_digest(data)
+        require 'openssl' unless defined?(OpenSSL)
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new(@digest), @secret, data)
+      end
+  end
+end