csd 0.1.5 → 0.1.6

data/lib/active_support/dependencies/autoload.rb

@@ -1,50 +0,0 @@
-require "active_support/inflector/methods"
-require "active_support/lazy_load_hooks"
-
-module ActiveSupport
-  module Autoload
-    @@autoloads = {}
-    @@under_path = nil
-    @@at_path = nil
-    @@eager_autoload = false
-
-    def autoload(const_name, path = @@at_path)
-      full = [self.name, @@under_path, const_name.to_s, path].compact.join("::")
-      location = path || Inflector.underscore(full)
-
-      if @@eager_autoload
-        @@autoloads[const_name] = location
-      end
-      super const_name, location
-    end
-
-    def autoload_under(path)
-      @@under_path, old_path = path, @@under_path
-      yield
-    ensure
-      @@under_path = old_path
-    end
-
-    def autoload_at(path)
-      @@at_path, old_path = path, @@at_path
-      yield
-    ensure
-      @@at_path = old_path
-    end
-
-    def eager_autoload
-      old_eager, @@eager_autoload = @@eager_autoload, true
-      yield
-    ensure
-      @@eager_autoload = old_eager
-    end
-
-    def self.eager_autoload!
-      @@autoloads.values.each { |file| require file }
-    end
-
-    def autoloads
-      @@autoloads
-    end
-  end
-end

data/lib/active_support/deprecation.rb

@@ -1,18 +0,0 @@
-require 'active_support/deprecation/behaviors'
-require 'active_support/deprecation/reporting'
-require 'active_support/deprecation/method_wrappers'
-require 'active_support/deprecation/proxy_wrappers'
-
-module ActiveSupport
-  module Deprecation #:nodoc:
-    class << self
-      # The version the deprecated behavior will be removed, by default.
-      attr_accessor :deprecation_horizon
-    end
-    self.deprecation_horizon = '3.0'
-
-    # By default, warnings are not silenced and debugging is off.
-    self.silenced = false
-    self.debug = false
-  end
-end

data/lib/active_support/deprecation/behaviors.rb

@@ -1,38 +0,0 @@
-module ActiveSupport
-  module Deprecation
-    class << self
-      # Behavior is a block that takes a message argument.
-      attr_writer :behavior
-
-      # Whether to print a backtrace along with the warning.
-      attr_accessor :debug
-
-      def behavior
-        @behavior ||= default_behavior
-      end
-
-      def default_behavior
-        Deprecation::DEFAULT_BEHAVIORS[defined?(Rails.env) ? Rails.env.to_s : 'test']
-      end
-    end
-
-    # Default warning behaviors per Rails.env. Ignored in production.
-    DEFAULT_BEHAVIORS = {
-      'test' => Proc.new { |message, callstack|
-         $stderr.puts(message)
-         $stderr.puts callstack.join("\n  ") if debug
-       },
-      'development' => Proc.new { |message, callstack|
-         logger =
-           if defined?(Rails) && Rails.logger
-             Rails.logger
-           else
-             require 'logger'
-             Logger.new($stderr)
-           end
-         logger.warn message
-         logger.debug callstack.join("\n  ") if debug
-       }
-    }
-  end
-end

data/lib/active_support/deprecation/method_wrappers.rb

@@ -1,29 +0,0 @@
-require 'active_support/core_ext/module/deprecation'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/array/extract_options'
-
-module ActiveSupport
-  class << Deprecation
-    # Declare that a method has been deprecated.
-    def deprecate_methods(target_module, *method_names)
-      options = method_names.extract_options!
-      method_names += options.keys
-
-      method_names.each do |method_name|
-        target_module.alias_method_chain(method_name, :deprecation) do |target, punctuation|
-          target_module.module_eval(<<-end_eval, __FILE__, __LINE__ + 1)
-            def #{target}_with_deprecation#{punctuation}(*args, &block)
-              ::ActiveSupport::Deprecation.warn(
-                ::ActiveSupport::Deprecation.deprecated_method_warning(
-                  :#{method_name},
-                  #{options[method_name].inspect}),
-                caller
-              )
-              send(:#{target}_without_deprecation#{punctuation}, *args, &block)
-            end
-          end_eval
-        end
-      end
-    end
-  end
-end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -1,74 +0,0 @@
-require 'active_support/inflector'
-
-module ActiveSupport
-  module Deprecation
-    class DeprecationProxy #:nodoc:
-      instance_methods.each { |m| undef_method m unless m =~ /^__|^object_id$/ }
-
-      # Don't give a deprecation warning on inspect since test/unit and error
-      # logs rely on it for diagnostics.
-      def inspect
-        target.inspect
-      end
-
-      private
-        def method_missing(called, *args, &block)
-          warn caller, called, args
-          target.__send__(called, *args, &block)
-        end
-    end
-
-    class DeprecatedObjectProxy < DeprecationProxy #:nodoc:
-      def initialize(object, message)
-        @object = object
-        @message = message
-      end
-
-      private
-        def target
-          @object
-        end
-
-        def warn(callstack, called, args)
-          ActiveSupport::Deprecation.warn(@message, callstack)
-        end
-    end
-
-    # Stand-in for <tt>@request</tt>, <tt>@attributes</tt>, <tt>@params</tt>, etc.
-    # which emits deprecation warnings on any method call (except +inspect+).
-    class DeprecatedInstanceVariableProxy < DeprecationProxy #:nodoc:
-      def initialize(instance, method, var = "@#{method}")
-        @instance, @method, @var = instance, method, var
-      end
-
-      private
-        def target
-          @instance.__send__(@method)
-        end
-
-        def warn(callstack, called, args)
-          ActiveSupport::Deprecation.warn("#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}", callstack)
-        end
-    end
-
-    class DeprecatedConstantProxy < DeprecationProxy #:nodoc:
-      def initialize(old_const, new_const)
-        @old_const = old_const
-        @new_const = new_const
-      end
-
-      def class
-        target.class
-      end
-
-      private
-        def target
-          ActiveSupport::Inflector.constantize(@new_const.to_s)
-        end
-
-        def warn(callstack, called, args)
-          ActiveSupport::Deprecation.warn("#{@old_const} is deprecated! Use #{@new_const} instead.", callstack)
-        end
-    end
-  end
-end

data/lib/active_support/deprecation/reporting.rb

@@ -1,56 +0,0 @@
-module ActiveSupport
-  module Deprecation
-    class << self
-      attr_accessor :silenced
-
-      def warn(message = nil, callstack = caller)
-        if behavior && !silenced
-          behavior.call(deprecation_message(callstack, message), callstack)
-        end
-      end
-
-      # Silence deprecation warnings within the block.
-      def silence
-        old_silenced, @silenced = @silenced, true
-        yield
-      ensure
-        @silenced = old_silenced
-      end
-
-      def deprecated_method_warning(method_name, message = nil)
-        warning = "#{method_name} is deprecated and will be removed from Rails #{deprecation_horizon}"
-        case message
-          when Symbol then "#{warning} (use #{message} instead)"
-          when String then "#{warning} (#{message})"
-          else warning
-        end
-      end
-
-      private
-        def deprecation_message(callstack, message = nil)
-          message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
-          message += '.' unless message =~ /\.$/
-          "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
-        end
-
-        def deprecation_caller_message(callstack)
-          file, line, method = extract_callstack(callstack)
-          if file
-            if line && method
-              "(called from #{method} at #{file}:#{line})"
-            else
-              "(called from #{file}:#{line})"
-            end
-          end
-        end
-
-        def extract_callstack(callstack)
-          if md = callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
-            md.captures
-          else
-            callstack.first
-          end
-        end
-    end
-  end
-end

data/lib/active_support/duration.rb

@@ -1,105 +0,0 @@
-require 'active_support/basic_object'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/object/acts_like'
-
-module ActiveSupport
-  # Provides accurate date and time measurements using Date#advance and 
-  # Time#advance, respectively. It mainly supports the methods on Numeric,
-  # such as in this example:
-  #
-  #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
-  class Duration < BasicObject
-    attr_accessor :value, :parts
-
-    def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts
-    end
-
-    # Adds another Duration or a Numeric to this Duration. Numeric values
-    # are treated as seconds.
-    def +(other)
-      if Duration === other
-        Duration.new(value + other.value, @parts + other.parts)
-      else
-        Duration.new(value + other, @parts + [[:seconds, other]])
-      end
-    end
-
-    # Subtracts another Duration or a Numeric from this Duration. Numeric
-    # values are treated as seconds.
-    def -(other)
-      self + (-other)
-    end
-
-    def -@ #:nodoc:
-      Duration.new(-value, parts.map { |type,number| [type, -number] })
-    end
-
-    def is_a?(klass) #:nodoc:
-      Duration == klass || value.is_a?(klass)
-    end
-    alias :kind_of? :is_a?
-
-    # Returns true if <tt>other</tt> is also a Duration instance with the
-    # same <tt>value</tt>, or if <tt>other == value</tt>.
-    def ==(other)
-      if Duration === other
-        other.value == value
-      else
-        other == value
-      end
-    end
-
-    def self.===(other) #:nodoc:
-      other.is_a?(Duration)
-    rescue ::NoMethodError
-      false
-    end
-
-    # Calculates a new Time or Date that is as far in the future
-    # as this Duration represents.
-    def since(time = ::Time.current)
-      sum(1, time)
-    end
-    alias :from_now :since
-
-    # Calculates a new Time or Date that is as far in the past
-    # as this Duration represents.
-    def ago(time = ::Time.current)
-      sum(-1, time)
-    end
-    alias :until :ago
-
-    def inspect #:nodoc:
-      consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
-      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
-      parts = ["0 seconds"] if parts.empty?
-      parts.to_sentence(:locale => :en)
-    end
-
-    protected
-
-      def sum(sign, time = ::Time.current) #:nodoc:
-        parts.inject(time) do |t,(type,number)|
-          if t.acts_like?(:time) || t.acts_like?(:date)
-            if type == :seconds
-              t.since(sign * number)
-            else
-              t.advance(type => sign * number)
-            end
-          else
-            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
-          end
-        end
-      end
-
-    private
-
-      def method_missing(method, *args, &block) #:nodoc:
-        value.send(method, *args)
-      end
-  end
-end

data/lib/active_support/gzip.rb

@@ -1,25 +0,0 @@
-require 'zlib'
-require 'stringio'
-
-module ActiveSupport
-  # A convenient wrapper for the zlib standard library that allows compression/decompression of strings with gzip.
-  module Gzip
-    class Stream < StringIO
-      def close; rewind; end
-    end
-
-    # Decompresses a gzipped string.
-    def self.decompress(source)
-      Zlib::GzipReader.new(StringIO.new(source)).read
-    end
-
-    # Compresses a string using gzip.
-    def self.compress(source)
-      output = Stream.new
-      gz = Zlib::GzipWriter.new(output)
-      gz.write(source)
-      gz.close
-      output.string
-    end
-  end
-end

data/lib/active_support/hash_with_indifferent_access.rb

@@ -1,145 +0,0 @@
-require 'active_support/core_ext/hash/keys'
-
-# This class has dubious semantics and we only have it so that
-# people can write params[:key] instead of params['key']
-# and they get the same value for both keys.
-
-module ActiveSupport
-  class HashWithIndifferentAccess < Hash
-    def extractable_options?
-      true
-    end
-
-    def initialize(constructor = {})
-      if constructor.is_a?(Hash)
-        super()
-        update(constructor)
-      else
-        super(constructor)
-      end
-    end
-
-    def default(key = nil)
-      if key.is_a?(Symbol) && include?(key = key.to_s)
-        self[key]
-      else
-        super
-      end
-    end
-
-    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-    alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-    # Assigns a new value to the hash:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:key] = "value"
-    #
-    def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value))
-    end
-
-    # Updates the instantized hash with values from the second:
-    #
-    #   hash_1 = HashWithIndifferentAccess.new
-    #   hash_1[:key] = "value"
-    #
-    #   hash_2 = HashWithIndifferentAccess.new
-    #   hash_2[:key] = "New Value!"
-    #
-    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-    #
-    def update(other_hash)
-      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-      self
-    end
-
-    alias_method :merge!, :update
-
-    # Checks the hash for a key matching the argument passed in:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash["key"] = "value"
-    #   hash.key? :key  # => true
-    #   hash.key? "key" # => true
-    #
-    def key?(key)
-      super(convert_key(key))
-    end
-
-    alias_method :include?, :key?
-    alias_method :has_key?, :key?
-    alias_method :member?, :key?
-
-    # Fetches the value for the specified key, same as doing hash[key]
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    # Returns an array of the values at the specified indices:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:a] = "x"
-    #   hash[:b] = "y"
-    #   hash.values_at("a", "b") # => ["x", "y"]
-    #
-    def values_at(*indices)
-      indices.collect {|key| self[convert_key(key)]}
-    end
-
-    # Returns an exact copy of the hash.
-    def dup
-      HashWithIndifferentAccess.new(self)
-    end
-
-    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
-    # Does not overwrite the existing hash.
-    def merge(hash)
-      self.dup.update(hash)
-    end
-
-    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
-    def reverse_merge(other_hash)
-      super other_hash.with_indifferent_access
-    end
-
-    def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
-    end
-
-    # Removes a specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    def stringify_keys!; self end
-    def stringify_keys; dup end
-    undef :symbolize_keys!
-    def symbolize_keys; to_hash.symbolize_keys end
-    def to_options!; self end
-
-    # Convert to a Hash with String keys.
-    def to_hash
-      Hash.new(default).merge!(self)
-    end
-
-    protected
-      def convert_key(key)
-        key.kind_of?(Symbol) ? key.to_s : key
-      end
-
-      def convert_value(value)
-        case value
-        when Hash
-          value.with_indifferent_access
-        when Array
-          value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
-        else
-          value
-        end
-      end
-  end
-end
-
-HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess