depengine 0.0.31 → 3.0.0

data/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/json/encoders/true_class.rb

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

data/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/json/encoding.rb

@@ -1,111 +0,0 @@
-# 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 = {
-        "\x00" => '\u0000', "\x01" => '\u0001', "\x02" => '\u0002',
-        "\x03" => '\u0003', "\x04" => '\u0004', "\x05" => '\u0005',
-        "\x06" => '\u0006', "\x07" => '\u0007', "\x0B" => '\u000B',
-        "\x0E" => '\u000E', "\x0F" => '\u000F', "\x10" => '\u0010',
-        "\x11" => '\u0011', "\x12" => '\u0012', "\x13" => '\u0013',
-        "\x14" => '\u0014', "\x15" => '\u0015', "\x16" => '\u0016',
-        "\x17" => '\u0017', "\x18" => '\u0018', "\x19" => '\u0019',
-        "\x1A" => '\u001A', "\x1B" => '\u001B', "\x1C" => '\u001C',
-        "\x1D" => '\u001D', "\x1E" => '\u001E', "\x1F" => '\u001F',
-        "\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
-              /[\x00-\x1F"\\><&]/
-            else
-              /[\x00-\x1F"\\]/
-            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/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/json/variable.rb

@@ -1,10 +0,0 @@
-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/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/locale/en.yml

@@ -1,33 +0,0 @@
-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/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/memoizable.rb

@@ -1,100 +0,0 @@
-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__ + 1
-          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/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/message_encryptor.rb

@@ -1,70 +0,0 @@
-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/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/message_verifier.rb

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

data/etc/isolate/ruby-1.8/gems/activesupport-2.3.8/lib/active_support/multibyte.rb

@@ -1,57 +0,0 @@
-# encoding: utf-8
-
-module ActiveSupport #:nodoc:
-  module Multibyte
-    # A list of all available normalization forms. See http://www.unicode.org/reports/tr15/tr15-29.html for more
-    # information about normalization.
-    NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
-
-    # The Unicode version that is supported by the implementation
-    UNICODE_VERSION = '5.1.0'
-
-    # The default normalization used for operations that require normalization. It can be set to any of the
-    # normalizations in NORMALIZATION_FORMS.
-    #
-    # Example:
-    #   ActiveSupport::Multibyte.default_normalization_form = :c
-    mattr_accessor :default_normalization_form
-    self.default_normalization_form = :kc
-
-    # The proxy class returned when calling mb_chars. You can use this accessor to configure your own proxy
-    # class so you can support other encodings. See the ActiveSupport::Multibyte::Chars implementation for
-    # an example how to do this.
-    #
-    # Example:
-    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
-    def self.proxy_class=(klass)
-      @proxy_class = klass
-    end
-
-    # Returns the currect proxy class
-    def self.proxy_class
-      @proxy_class ||= ActiveSupport::Multibyte::Chars
-    end
-
-    # Regular expressions that describe valid byte sequences for a character
-    VALID_CHARACTER = {
-      # Borrowed from the Kconv library by Shinji KONO - (also as seen on the W3C site)
-      'UTF-8' => /\A(?:
-                  [\x00-\x7f]                                         |
-                  [\xc2-\xdf] [\x80-\xbf]                             |
-                  \xe0        [\xa0-\xbf] [\x80-\xbf]                 |
-                  [\xe1-\xef] [\x80-\xbf] [\x80-\xbf]                 |
-                  \xf0        [\x90-\xbf] [\x80-\xbf] [\x80-\xbf]     |
-                  [\xf1-\xf3] [\x80-\xbf] [\x80-\xbf] [\x80-\xbf]     |
-                  \xf4        [\x80-\x8f] [\x80-\xbf] [\x80-\xbf])\z /xn,
-      # Quick check for valid Shift-JIS characters, disregards the odd-even pairing
-      'Shift_JIS' => /\A(?:
-                  [\x00-\x7e \xa1-\xdf]                                     |
-                  [\x81-\x9f \xe0-\xef] [\x40-\x7e \x80-\x9e \x9f-\xfc])\z /xn
-    }
-  end
-end
-
-require 'active_support/multibyte/chars'
-require 'active_support/multibyte/exceptions'
-require 'active_support/multibyte/unicode_database'
-require 'active_support/multibyte/utils'