csd 0.1.5 → 0.1.6

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

@@ -1,10 +0,0 @@
-require 'active_support/core_ext/module/anonymous'
-require 'active_support/core_ext/string/inflections'
-
-class Module
-  def reachable? #:nodoc:
-    !anonymous? && name.constantize.equal?(self)
-  rescue NameError
-    false
-  end
-end

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

@@ -1,6 +0,0 @@
-class Module
-  def remove_possible_method(method)
-    remove_method(method)
-  rescue NameError
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/array/extract_options'
-
-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
-end

data/lib/active_support/core_ext/name_error.rb

@@ -1,18 +0,0 @@
-class NameError
-  # Extract the name of the missing constant from the exception message.
-  def missing_name
-    if /undefined local variable or method/ !~ message
-      $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
-    end
-  end
-
-  # Was this exception raised because the given name was missing?
-  def missing_name?(name)
-    if name.is_a? Symbol
-      last_name = (missing_name || '').split('::').last
-      last_name == name.to_s
-    else
-      missing_name == name.to_s
-    end
-  end
-end

data/lib/active_support/core_ext/numeric.rb

@@ -1,2 +0,0 @@
-require 'active_support/core_ext/numeric/bytes'
-require 'active_support/core_ext/numeric/time'

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

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

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

@@ -1,77 +0,0 @@
-require 'active_support/duration'
-
-class Numeric
-  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
-  #
-  # These methods use Time#advance for precise date calculations when using from_now, ago, etc. 
-  # as well as adding or subtracting their results from a Time object. For example:
-  #
-  #   # equivalent to Time.now.advance(:months => 1)
-  #   1.month.from_now
-  #
-  #   # equivalent to Time.now.advance(:years => 2)
-  #   2.years.from_now
-  #
-  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
-  #   (4.months + 5.years).from_now
-  # 
-  # While these methods provide precise calculation when used as in the examples above, care
-  # should be taken to note that this is not true if the result of `months', `years', etc is
-  # converted before use:
-  #
-  #   # equivalent to 30.days.to_i.from_now
-  #   1.month.to_i.from_now
-  #
-  #   # equivalent to 365.25.days.to_f.from_now
-  #   1.year.to_f.from_now
-  #
-  # In such cases, Ruby's core 
-  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and 
-  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
-  # date and time arithmetic
-  def seconds
-    ActiveSupport::Duration.new(self, [[:seconds, self]])
-  end
-  alias :second :seconds
-
-  def minutes
-    ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
-  end
-  alias :minute :minutes  
-  
-  def hours
-    ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
-  end
-  alias :hour :hours
-  
-  def days
-    ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
-  end
-  alias :day :days
-
-  def weeks
-    ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
-  end
-  alias :week :weeks
-  
-  def fortnights
-    ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
-  end
-  alias :fortnight :fortnights
-  
-  # Reads best without arguments:  10.minutes.ago
-  def ago(time = ::Time.now)
-    time - self
-  end
-
-  # Reads best with argument:  10.minutes.until(time)
-  alias :until :ago
-
-  # Reads best with argument:  10.minutes.since(time)
-  def since(time = ::Time.now)
-    time + self
-  end
-
-  # Reads best without arguments:  10.minutes.from_now
-  alias :from_now :since
-end

data/lib/active_support/core_ext/object.rb

@@ -1,14 +0,0 @@
-require 'active_support/core_ext/object/acts_like'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/object/try'
-
-require 'active_support/core_ext/object/conversions'
-require 'active_support/core_ext/object/instance_variables'
-require 'active_support/core_ext/object/misc'
-require 'active_support/core_ext/object/extending'
-
-require 'active_support/core_ext/object/returning'
-require 'active_support/core_ext/object/to_param'
-require 'active_support/core_ext/object/to_query'
-require 'active_support/core_ext/object/with_options'

data/lib/active_support/core_ext/object/acts_like.rb

@@ -1,10 +0,0 @@
-class Object
-  # A duck-type assistant method. For example, Active Support extends Date
-  # to define an acts_like_date? method, and extends Time to define
-  # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
-  # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
-  # we want to act like Time simply need to define an acts_like_time? method.
-  def acts_like?(duck)
-    respond_to? :"acts_like_#{duck}?"
-  end
-end

data/lib/active_support/core_ext/object/blank.rb

@@ -1,76 +0,0 @@
-class Object
-  # An object is blank if it's false, empty, or a whitespace string.
-  # For example, "", "   ", +nil+, [], and {} are blank.
-  #
-  # This simplifies:
-  #
-  #   if !address.nil? && !address.empty?
-  #
-  # ...to:
-  #
-  #   if !address.blank?
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-
-  # An object is present if it's not blank.
-  def present?
-    !blank?
-  end
-  
-  # Returns object if it's #present? otherwise returns nil.
-  # object.presence is equivalent to object.present? ? object : nil.
-  #
-  # This is handy for any representation of objects where blank is the same
-  # as not present at all.  For example, this simplifies a common check for
-  # HTTP POST/query parameters:
-  #
-  #   state   = params[:state]   if params[:state].present?
-  #   country = params[:country] if params[:country].present?
-  #   region  = state || country || 'US'
-  #
-  # ...becomes:
-  #
-  #   region = params[:state].presence || params[:country].presence || 'US'
-  def presence
-    self if present?
-  end
-end
-
-class NilClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class FalseClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class TrueClass #:nodoc:
-  def blank?
-    false
-  end
-end
-
-class Array #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-class Hash #:nodoc:
-  alias_method :blank?, :empty?
-end
-
-class String #:nodoc:
-  def blank?
-    self !~ /\S/
-  end
-end
-
-class Numeric #:nodoc:
-  def blank?
-    false
-  end
-end

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

@@ -1,4 +0,0 @@
-require 'active_support/core_ext/object/to_param'
-require 'active_support/core_ext/object/to_query'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/hash/conversions'

data/lib/active_support/core_ext/object/duplicable.rb

@@ -1,65 +0,0 @@
-# Most objects are cloneable, but not all. For example you can't dup +nil+:
-#
-#   nil.dup # => TypeError: can't dup NilClass
-#
-# Classes may signal their instances are not duplicable removing +dup+/+clone+
-# or raising exceptions from them. So, to dup an arbitrary object you normally
-# use an optimistic approach and are ready to catch an exception, say:
-#
-#   arbitrary_object.dup rescue object
-#
-# Rails dups objects in a few critical spots where they are not that arbitrary.
-# That rescue is very expensive (like 40 times slower than a predicate), and it
-# is often triggered.
-#
-# That's why we hardcode the following cases and check duplicable? instead of
-# using that rescue idiom.
-class Object
-  # Can you safely .dup this object?
-  # False for nil, false, true, symbols, numbers, class and module objects; true otherwise.
-  def duplicable?
-    true
-  end
-end
-
-class NilClass #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class FalseClass #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class TrueClass #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class Symbol #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class Numeric #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class Class #:nodoc:
-  def duplicable?
-    false
-  end
-end
-
-class Module #:nodoc:
-  def duplicable?
-    false
-  end
-end

data/lib/active_support/core_ext/object/extending.rb

@@ -1,11 +0,0 @@
-require 'active_support/core_ext/class/subclasses'
-
-class Object
-  # Exclude this class unless it's a subclass of our supers and is defined.
-  # We check defined? in case we find a removed class that has yet to be
-  # garbage collected. This also fails for anonymous classes -- please
-  # submit a patch if you have a workaround.
-  def subclasses_of(*superclasses) #:nodoc:
-    Class.subclasses_of(*superclasses)
-  end
-end

data/lib/active_support/core_ext/object/instance_variables.rb

@@ -1,67 +0,0 @@
-class Object
-  # Returns a hash that maps instance variable names without "@" to their
-  # corresponding values. Keys are strings both in Ruby 1.8 and 1.9.
-  #
-  #   class C
-  #     def initialize(x, y)
-  #       @x, @y = x, y
-  #     end
-  #   end
-  #   
-  #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
-  def instance_values #:nodoc:
-    instance_variables.inject({}) do |values, name|
-      values[name.to_s[1..-1]] = instance_variable_get(name)
-      values
-    end
-  end
-
-  # Returns an array of instance variable names including "@". They are strings
-  # both in Ruby 1.8 and 1.9.
-  #
-  #   class C
-  #     def initialize(x, y)
-  #       @x, @y = x, y
-  #     end
-  #   end
-  #   
-  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
-  if RUBY_VERSION >= '1.9'
-    def instance_variable_names
-      instance_variables.map { |var| var.to_s }
-    end
-  else
-    alias_method :instance_variable_names, :instance_variables
-  end
-
-  # Copies the instance variables of +object+ into +self+.
-  #
-  # Instance variable names in the +exclude+ array are ignored. If +object+
-  # responds to <tt>protected_instance_variables</tt> the ones returned are
-  # also ignored. For example, Rails controllers implement that method.
-  #
-  # In both cases strings and symbols are understood, and they have to include
-  # the at sign.
-  #
-  #   class C
-  #     def initialize(x, y, z)
-  #       @x, @y, @z = x, y, z
-  #     end
-  #   
-  #     def protected_instance_variables
-  #       %w(@z)
-  #     end
-  #   end
-  #   
-  #   a = C.new(0, 1, 2)
-  #   b = C.new(3, 4, 5)
-  #   
-  #   a.copy_instance_variables_from(b, [:@y])
-  #   # a is now: @x = 3, @y = 1, @z = 2
-  def copy_instance_variables_from(object, exclude = []) #:nodoc:
-    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
-
-    vars = object.instance_variables.map(&:to_s) - exclude.map(&:to_s)
-    vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
-  end
-end