activesupport 3.2.22.5 → 4.0.0.beta1

data/lib/active_support/base64.rb

@@ -1,54 +0,0 @@
-require 'active_support/deprecation'
-
-begin
-  require 'base64'
-rescue LoadError
-  # The Base64 module isn't available in earlier versions of Ruby 1.9.
-  module Base64
-    # Encodes a string to its base 64 representation. Each 60 characters of
-    # output is separated by a newline character.
-    #
-    #  ActiveSupport::Base64.encode64("Original unencoded string")
-    #  # => "T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw==\n"
-    def self.encode64(data)
-      [data].pack("m")
-    end
-
-    # Decodes a base 64 encoded string to its original representation.
-    #
-    #  ActiveSupport::Base64.decode64("T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw==")
-    #  # => "Original unencoded string"
-    def self.decode64(data)
-      data.unpack("m").first
-    end
-  end
-end
-
-unless Base64.respond_to?(:strict_encode64)
-  # Included in Ruby 1.9
-  def Base64.strict_encode64(value)
-    encode64(value).gsub(/\n/, '')
-  end
-end
-
-module ActiveSupport
-  module Base64
-    def self.encode64(value)
-      ActiveSupport::Deprecation.warn "ActiveSupport::Base64.encode64 " \
-        "is deprecated. Use Base64.encode64 instead", caller
-      ::Base64.encode64(value)
-    end
-
-    def self.decode64(value)
-      ActiveSupport::Deprecation.warn "ActiveSupport::Base64.decode64 " \
-        "is deprecated. Use Base64.decode64 instead", caller
-      ::Base64.decode64(value)
-    end
-
-    def self.encode64s(value)
-      ActiveSupport::Deprecation.warn "ActiveSupport::Base64.encode64s " \
-        "is deprecated. Use Base64.strict_encode64 instead", caller
-      ::Base64.strict_encode64(value)
-    end
-  end
-end

data/lib/active_support/core_ext/array/random_access.rb

@@ -1,30 +0,0 @@
-class Array
-  # Backport of Array#sample based on Marc-Andre Lafortune's https://github.com/marcandre/backports/
-  # Returns a random element or +n+ random elements from the array.
-  # If the array is empty and +n+ is nil, returns <tt>nil</tt>.
-  # If +n+ is passed and its value is less than 0, it raises an +ArgumentError+ exception.
-  # If the value of +n+ is equal or greater than 0 it returns <tt>[]</tt>.
-  #
-  #   [1,2,3,4,5,6].sample     # => 4
-  #   [1,2,3,4,5,6].sample(3)  # => [2, 4, 5]
-  #   [1,2,3,4,5,6].sample(-3) # => ArgumentError: negative array size
-  #              [].sample     # => nil
-  #              [].sample(3)  # => []
-  def sample(n=nil)
-    return self[Kernel.rand(size)] if n.nil?
-    n = n.to_int
-  rescue Exception => e
-    raise TypeError, "Coercion error: #{n.inspect}.to_int => Integer failed:\n(#{e.message})"
-  else
-    raise TypeError, "Coercion error: obj.to_int did NOT return an Integer (was #{n.class})" unless n.kind_of? Integer
-    raise ArgumentError, "negative array size" if n < 0
-    n = size if n > size
-    result = Array.new(self)
-    n.times do |i|
-      r = i + Kernel.rand(size - i)
-      result[i], result[r] = result[r], result[i]
-    end
-    result[n..size] = []
-    result
-  end unless method_defined? :sample
-end

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

@@ -1,33 +0,0 @@
-# Date memoizes some instance methods using metaprogramming to wrap
-# the methods with one that caches the result in an instance variable.
-#
-# If a Date is frozen but the memoized method hasn't been called, the
-# first call will result in a frozen object error since the memo
-# instance variable is uninitialized.
-#
-# Work around by eagerly memoizing before the first freeze.
-#
-# Ruby 1.9 uses a preinitialized instance variable so it's unaffected.
-# This hack is as close as we can get to feature detection:
-if RUBY_VERSION < '1.9'
-  require 'date'
-  begin
-    ::Date.today.freeze.jd
-  rescue => frozen_object_error
-    if frozen_object_error.message =~ /frozen/
-      class Date #:nodoc:
-        def freeze
-          unless frozen?
-            self.class.private_instance_methods(false).each do |m|
-              if m.to_s =~ /\A__\d+__\Z/
-                instance_variable_set(:"@#{m}", [send(m)])
-              end
-            end
-          end
-
-          super
-        end
-      end
-    end
-  end
-end

data/lib/active_support/core_ext/exception.rb

@@ -1,3 +0,0 @@
-module ActiveSupport
-  FrozenObjectError = RUBY_VERSION < '1.9' ? TypeError : RuntimeError
-end

data/lib/active_support/core_ext/file/path.rb

@@ -1,5 +0,0 @@
-class File
-  unless File.allocate.respond_to?(:to_path)
-    alias to_path path
-  end
-end

data/lib/active_support/core_ext/float.rb

@@ -1 +0,0 @@
-require 'active_support/core_ext/float/rounding'

data/lib/active_support/core_ext/float/rounding.rb

@@ -1,19 +0,0 @@
-class Float
-  alias precisionless_round round
-  private :precisionless_round
-
-  # Rounds the float with the specified precision.
-  #
-  #   x = 1.337
-  #   x.round    # => 1
-  #   x.round(1) # => 1.3
-  #   x.round(2) # => 1.34
-  def round(precision = nil)
-    if precision
-      magnitude = 10.0 ** precision
-      (self * magnitude).round / magnitude
-    else
-      precisionless_round
-    end
-  end
-end if RUBY_VERSION < '1.9'

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

@@ -1,18 +0,0 @@
-class Hash
-  # Returns a deep copy of hash.
-  #
-  #   hash = { :a => { :b => 'b' } }
-  #   dup  = hash.deep_dup
-  #   dup[:a][:c] = 'c'
-  #
-  #   hash[:a][:c] #=> nil
-  #   dup[:a][:c]  #=> "c"
-  def deep_dup
-    duplicate = self.dup
-    duplicate.each_pair do |k,v|
-      tv = duplicate[k]
-      duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
-    end
-    duplicate
-  end
-end

data/lib/active_support/core_ext/io.rb

@@ -1,15 +0,0 @@
-if RUBY_VERSION < '1.9.2'
-
-# :stopdoc:
-class IO
-  def self.binread(name, length = nil, offset = nil)
-    return File.read name unless length || offset
-    File.open(name, 'rb') { |f|
-      f.seek offset if offset
-      f.read length
-    }
-  end
-end
-# :startdoc:
-
-end

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

@@ -1,14 +0,0 @@
-class Module
-  if instance_methods[0].is_a?(Symbol)
-    def instance_method_names(*args)
-      instance_methods(*args).map(&:to_s)
-    end
-
-    def method_names(*args)
-      methods(*args).map(&:to_s)
-    end
-  else
-    alias_method :instance_method_names, :instance_methods
-    alias_method :method_names, :methods
-  end
-end

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

@@ -1,45 +0,0 @@
-require 'thread'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/module/deprecation'
-
-class Module
-  # Synchronize access around a method, delegating synchronization to a
-  # particular mutex. A mutex (either a Mutex, or any object that responds to
-  # #synchronize and yields to a block) must be provided as a final :with option.
-  # The :with option should be a symbol or string, and can represent a method,
-  # constant, or instance or class variable.
-  # Example:
-  #   class SharedCache
-  #     @@lock = Mutex.new
-  #     def expire
-  #       ...
-  #     end
-  #     synchronize :expire, :with => :@@lock
-  #   end
-  def synchronize(*methods)
-    options = methods.extract_options!
-    unless options.is_a?(Hash) && with = options[:with]
-      raise ArgumentError, "Synchronization needs a mutex. Supply an options hash with a :with key as the last argument (e.g. synchronize :hello, :with => :@mutex)."
-    end
-
-    methods.each do |method|
-      aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
-
-      if method_defined?("#{aliased_method}_without_synchronization#{punctuation}")
-        raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
-      end
-
-      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
-          #{with}.synchronize do                                                    #   @@lock.synchronize do
-            #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)
-          end                                                                       #   end
-        end                                                                         # end
-      EOS
-
-      alias_method_chain method, :synchronization
-    end
-  end
-  deprecate :synchronize
-end

data/lib/active_support/core_ext/process.rb

@@ -1 +0,0 @@
-require 'active_support/core_ext/process/daemon'

data/lib/active_support/core_ext/process/daemon.rb

@@ -1,23 +0,0 @@
-module Process
-  def self.daemon(nochdir = nil, noclose = nil)
-    exit if fork                     # Parent exits, child continues.
-    Process.setsid                   # Become session leader.
-    exit if fork                     # Zap session leader. See [1].
-
-    unless nochdir
-      Dir.chdir "/"                  # Release old working directory.
-    end
-
-    File.umask 0000                  # Ensure sensible umask. Adjust as needed.
-
-    unless noclose
-      STDIN.reopen "/dev/null"       # Free file descriptors and
-      STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
-      STDERR.reopen '/dev/null', 'a'
-    end
-
-    trap("TERM") { exit }
-
-    return 0
-  end unless respond_to?(:daemon)
-end

data/lib/active_support/core_ext/range/blockless_step.rb

@@ -1,29 +0,0 @@
-require 'active_support/core_ext/module/aliasing'
-
-class Range
-  begin
-    (1..2).step
-  # Range#step doesn't return an Enumerator
-  rescue LocalJumpError
-    # Return an array when step is called without a block.
-    def step_with_blockless(*args, &block)
-      if block_given?
-        step_without_blockless(*args, &block)
-      else
-        array = []
-        step_without_blockless(*args) { |step| array << step }
-        array
-      end
-    end
-  else
-    def step_with_blockless(*args, &block) #:nodoc:
-      if block_given?
-        step_without_blockless(*args, &block)
-      else
-        step_without_blockless(*args).to_a
-      end
-    end
-  end
-
-  alias_method_chain :step, :blockless
-end

data/lib/active_support/core_ext/range/cover.rb

@@ -1,3 +0,0 @@
-class Range
-  alias_method(:cover?, :include?) unless instance_methods.include?(:cover?)
-end

data/lib/active_support/core_ext/rexml.rb

@@ -1,46 +0,0 @@
-require 'active_support/core_ext/kernel/reporting'
-
-# Fixes the rexml vulnerability disclosed at:
-# http://www.ruby-lang.org/en/news/2008/08/23/dos-vulnerability-in-rexml/
-# This fix is identical to rexml-expansion-fix version 1.0.1.
-#
-# We still need to distribute this fix because albeit the REXML
-# in recent 1.8.7s is patched, it wasn't in early patchlevels.
-require 'rexml/rexml'
-
-# Earlier versions of rexml defined REXML::Version, newer ones REXML::VERSION
-unless (defined?(REXML::VERSION) ? REXML::VERSION : REXML::Version) > "3.1.7.2"
-  silence_warnings { require 'rexml/document' }
-
-  # REXML in 1.8.7 has the patch but early patchlevels didn't update Version from 3.1.7.2.
-  unless REXML::Document.respond_to?(:entity_expansion_limit=)
-    silence_warnings { require 'rexml/entity' }
-
-    module REXML #:nodoc:
-      class Entity < Child #:nodoc:
-        undef_method :unnormalized
-        def unnormalized
-          document.record_entity_expansion! if document
-          v = value()
-          return nil if v.nil?
-          @unnormalized = Text::unnormalize(v, parent)
-          @unnormalized
-        end
-      end
-      class Document < Element #:nodoc:
-        @@entity_expansion_limit = 10_000
-        def self.entity_expansion_limit= val
-          @@entity_expansion_limit = val
-        end
-
-        def record_entity_expansion!
-          @number_of_expansions ||= 0
-          @number_of_expansions += 1
-          if @number_of_expansions > @@entity_expansion_limit
-            raise "Number of entity expansions exceeded, processing aborted."
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,2 +0,0 @@
-require 'active_support/i18n'
-require 'i18n/core_ext/string/interpolate'

data/lib/active_support/core_ext/time/publicize_conversion_methods.rb

@@ -1,10 +0,0 @@
-require 'date'
-
-class Time
-  # Ruby 1.8-cvs and early 1.9 series define private Time#to_date
-  %w(to_date to_datetime).each do |method|
-    if private_instance_methods.include?(method) || private_instance_methods.include?(method.to_sym)
-      public method
-    end
-  end
-end

data/lib/active_support/memoizable.rb

@@ -1,116 +0,0 @@
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/deprecation'
-
-module ActiveSupport
-  module Memoizable
-    def self.extended(base)
-      ActiveSupport::Deprecation.warn "ActiveSupport::Memoizable is deprecated and will be removed in future releases," \
-        "simply use Ruby memoization pattern instead.", caller
-      super
-    end
-
-    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)
-        syms.each do |sym|
-          (methods + private_methods + protected_methods).each do |m|
-            if m.to_s =~ /^_unmemoized_(#{sym.to_s.gsub(/\?\Z/, '\?')})/
-              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}]                            #       @_memoized_mime_type = [_unmemoized_mime_type]
-              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?
-              args_length = method(:#{original_method}).arity                      #     args_length = method(:_unmemoized_mime_type).arity
-              if args.length == args_length + 1 &&                                 #     if args.length == args_length + 1 &&
-                (args.last == true || args.last == :reload)                        #       (args.last == true || args.last == :reload)
-                reload = args.pop                                                  #       reload = args.pop
-              end                                                                  #     end
-                                                                                   #
-              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)               #         @_memoized_mime_type[args] = _unmemoized_mime_type(*args)
-                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
-          elsif protected_method_defined?(#{original_method.inspect})              # elsif protected_method_defined?(:_unmemoized_mime_type)
-            protected #{symbol.inspect}                                            #   protected :mime_type
-          end                                                                      # end
-        EOS
-      end
-    end
-  end
-end