activesupport 3.2.22.5 → 4.0.0.beta1

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

@@ -17,8 +17,8 @@ class Array
   #     args.extract_options!
   #   end
   #
-  #   options(1, 2)           # => {}
-  #   options(1, 2, :a => :b) # => {:a=>:b}
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
   def extract_options!
     if last.is_a?(Hash) && last.extractable_options?
       pop

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

@@ -1,21 +1,22 @@
-require 'enumerator'
-
 class Array
   # Splits or iterates over the array in groups of size +number+,
   # padding any remaining slots with +fill_with+ unless it is +false+.
   #
-  #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|group| p group}
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3) {|group| p group}
   #   ["1", "2", "3"]
   #   ["4", "5", "6"]
-  #   ["7", nil, nil]
+  #   ["7", "8", "9"]
+  #   ["10", nil, nil]
   #
-  #   %w(1 2 3).in_groups_of(2, ' ') {|group| p group}
+  #   %w(1 2 3 4 5).in_groups_of(2, ' ') {|group| p group}
   #   ["1", "2"]
-  #   ["3", " "]
+  #   ["3", "4"]
+  #   ["5", " "]
   #
-  #   %w(1 2 3).in_groups_of(2, false) {|group| p group}
+  #   %w(1 2 3 4 5).in_groups_of(2, false) {|group| p group}
   #   ["1", "2"]
-  #   ["3"]
+  #   ["3", "4"]
+  #   ["5"]
   def in_groups_of(number, fill_with = nil)
     if fill_with == false
       collection = self
@@ -44,10 +45,10 @@ class Array
   #   ["5", "6", "7", nil]
   #   ["8", "9", "10", nil]
   #
-  #   %w(1 2 3 4 5 6 7).in_groups(3, ' ') {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5", " "]
-  #   ["6", "7", " "]
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3, ' ') {|group| p group}
+  #   ["1", "2", "3", "4"]
+  #   ["5", "6", "7", " "]
+  #   ["8", "9", "10", " "]
   #
   #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
   #   ["1", "2", "3"]
@@ -57,7 +58,7 @@ class Array
     # size / number gives minor group size;
     # size % number gives how many objects need extra accommodation;
     # each group hold either division or division + 1 items.
-    division = size / number
+    division = size.div number
     modulo = size % number
 
     # create a new array avoiding dup
@@ -66,9 +67,9 @@ class Array
 
     number.times do |index|
       length = division + (modulo > 0 && modulo > index ? 1 : 0)
-      padding = fill_with != false &&
-        modulo > 0 && length == division ? 1 : 0
-      groups << slice(start, length).concat([fill_with] * padding)
+      groups << last_group = slice(start, length)
+      last_group << fill_with if fill_with != false &&
+        modulo > 0 && length == division
       start += length
     end
 
@@ -82,13 +83,11 @@ class Array
   # Divides the array into one or more subarrays based on a delimiting +value+
   # or the result of an optional block.
   #
-  #   [1, 2, 3, 4, 5].split(3)                # => [[1, 2], [4, 5]]
-  #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
-  def split(value = nil)
-    using_block = block_given?
-
+  #   [1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
+  #   (1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
+  def split(value = nil, &block)
     inject([[]]) do |results, element|
-      if (using_block && yield(element)) || (value == element)
+      if block && block.call(element) || value == element
         results << []
       else
         results.last << element

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

@@ -1,16 +1,19 @@
 class Array
-  # Returns an unique array based on the criteria given as a +Proc+.
+  # *DEPRECATED*: Use +Array#uniq+ instead.
   #
-  #   [1, 2, 3, 4].uniq_by { |i| i.odd? } # => [1, 2]
+  # Returns a unique array based on the criteria in the block.
   #
-  def uniq_by
-    hash, array = {}, []
-    each { |i| hash[yield(i)] ||= (array << i) }
-    array
+  #   [1, 2, 3, 4].uniq_by { |i| i.odd? } # => [1, 2]
+  def uniq_by(&block)
+    ActiveSupport::Deprecation.warn 'uniq_by is deprecated. Use Array#uniq instead'
+    uniq(&block)
   end
 
-  # Same as uniq_by, but modifies self.
-  def uniq_by!
-    replace(uniq_by{ |i| yield(i) })
+  # *DEPRECATED*: Use +Array#uniq!+ instead.
+  #
+  # Same as +uniq_by+, but modifies +self+.
+  def uniq_by!(&block)
+    ActiveSupport::Deprecation.warn 'uniq_by! is deprecated. Use Array#uniq! instead'
+    uniq!(&block)
   end
 end

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

@@ -7,35 +7,32 @@ class Array
   # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
   # * Otherwise, returns an array with the argument as its single element.
   #
-  #   Array.wrap(nil)       # => []
-  #   Array.wrap([1, 2, 3]) # => [1, 2, 3]
-  #   Array.wrap(0)         # => [0]
+  #     Array.wrap(nil)       # => []
+  #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
+  #     Array.wrap(0)         # => [0]
   #
   # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
   #
   # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
-  # moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
-  # such a +nil+ right away.
+  #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+  #   such a +nil+ right away.
   # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
-  # raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+  #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
   # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
   #
   # The last point is particularly worth comparing for some enumerables:
   #
-  #   Array(:foo => :bar)      # => [[:foo, :bar]]
-  #   Array.wrap(:foo => :bar) # => [{:foo => :bar}]
-  #
-  #   Array("foo\nbar")        # => ["foo\n", "bar"], in Ruby 1.8
-  #   Array.wrap("foo\nbar")   # => ["foo\nbar"]
+  #   Array(foo: :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]
   #
   # There's also a related idiom that uses the splat operator:
   #
   #   [*object]
   #
-  # which returns <tt>[nil]</tt> for +nil+, and calls to <tt>Array(object)</tt> otherwise.
+  # which for +nil+ returns <tt>[]</tt>, and calls to <tt>Array(object)</tt> otherwise.
   #
-  # Thus, in this case the behavior is different for +nil+, and the differences with
-  # <tt>Kernel#Array</tt> explained above apply to the rest of +object+s.
+  # Thus, in this case the behavior may be different for +nil+, and the differences with
+  # <tt>Kernel#Array</tt> explained above apply to the rest of <tt>object</tt>s.
   def self.wrap(object)
     if object.nil?
       []

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

@@ -1,31 +1,9 @@
 require 'bigdecimal'
-
-begin
-  require 'psych'
-rescue LoadError
-end
-
 require 'yaml'
 
 class BigDecimal
-  YAML_TAG = 'tag:yaml.org,2002:float'
   YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
 
-  # This emits the number without any scientific notation.
-  # This is better than self.to_f.to_s since it doesn't lose precision.
-  #
-  # Note that reconstituting YAML floats to native floats may lose precision.
-  def to_yaml(opts = {})
-    return super if
-      (defined?(YAML::ENGINE) && !YAML::ENGINE.syck?) ||
-      (defined?(Psych) && YAML == Psych)
-
-    YAML.quick_emit(nil, opts) do |out|
-      string = to_s
-      out.scalar(YAML_TAG, YAML_MAPPING[string] || string, :plain)
-    end
-  end
-
   def encode_with(coder)
     string = to_s
     coder.represent_scalar(nil, YAML_MAPPING[string] || string)
@@ -39,8 +17,13 @@ class BigDecimal
   end
 
   DEFAULT_STRING_FORMAT = 'F'
-  def to_formatted_s(format = DEFAULT_STRING_FORMAT)
-    _original_to_s(format)
+  def to_formatted_s(*args)
+    if args[0].is_a?(Symbol)
+      super
+    else
+      format = args[0] || DEFAULT_STRING_FORMAT
+      _original_to_s(format)
+    end
   end
   alias_method :_original_to_s, :to_s
   alias_method :to_s, :to_formatted_s

data/lib/active_support/core_ext/class/attribute.rb

@@ -57,19 +57,25 @@ class Class
   #   object.setting          # => false
   #   Base.setting            # => true
   #
-  # To opt out of the instance reader method, pass :instance_reader => false.
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   object.setting          # => NoMethodError
   #   object.setting?         # => NoMethodError
   #
-  # To opt out of the instance writer method, pass :instance_writer => false.
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
   #
   #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
   def class_attribute(*attrs)
     options = attrs.extract_options!
-    instance_reader = instance_reader = options.fetch(:instance_reader, true)
-    instance_writer = options.fetch(:instance_writer, true)
+    # double assignment is used to avoid "assigned but unused variable" warning
+    instance_reader = instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
 
+    # We use class_eval here rather than define_method because class_attribute
+    # may be used in a performance sensitive context therefore the overhead that
+    # define_method introduces may become significant.
     attrs.each do |name|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def self.#{name}() nil end
@@ -109,9 +115,7 @@ class Class
   end
 
   private
-    unless respond_to?(:singleton_class?)
-      def singleton_class?
-        ancestors.first != self
-      end
+    def singleton_class?
+      ancestors.first != self
     end
 end

data/lib/active_support/core_ext/class/attribute_accessors.rb

@@ -21,17 +21,18 @@ class Class
   #   end
   #   # => NameError: invalid attribute name
   #
-  # If you want to opt out the instance reader method, you can pass <tt>:instance_reader => false</tt>
-  # or <tt>:instance_accessor => false</tt>.
+  # If you want to opt out the instance reader method, you can pass <tt>instance_reader: false</tt>
+  # or <tt>instance_accessor: false</tt>.
   #
   #   class Person
-  #     cattr_reader :hair_colors, :instance_reader => false
+  #     cattr_reader :hair_colors, instance_reader: false
   #   end
   #
   #   Person.new.hair_colors # => NoMethodError
   def cattr_reader(*syms)
     options = syms.extract_options!
     syms.each do |sym|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         unless defined? @@#{sym}
           @@#{sym} = nil
@@ -71,11 +72,11 @@ class Class
   #   end
   #   # => NameError: invalid attribute name
   #
-  # If you want to opt out the instance writer method, pass <tt>:instance_writer => false</tt>
-  # or <tt>:instance_accessor => false</tt>.
+  # If you want to opt out the instance writer method, pass <tt>instance_writer: false</tt>
+  # or <tt>instance_accessor: false</tt>.
   #
   #   class Person
-  #     cattr_writer :hair_colors, :instance_writer => false
+  #     cattr_writer :hair_colors, instance_writer: false
   #   end
   #
   #   Person.new.hair_colors = [:blonde, :red] # => NoMethodError
@@ -92,6 +93,7 @@ class Class
   def cattr_writer(*syms)
     options = syms.extract_options!
     syms.each do |sym|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         unless defined? @@#{sym}
           @@#{sym} = nil
@@ -109,7 +111,7 @@ class Class
           end
         EOS
       end
-      self.send("#{sym}=", yield) if block_given?
+      send("#{sym}=", yield) if block_given?
     end
   end
 
@@ -133,20 +135,20 @@ class Class
   #   Male.hair_colors << :blue
   #   Person.hair_colors # => [:brown, :black, :blonde, :red, :blue]
   #
-  # To opt out of the instance writer method, pass <tt>:instance_writer => false</tt>.
-  # To opt out of the instance reader method, pass <tt>:instance_reader => false</tt>.
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   class Person
-  #     cattr_accessor :hair_colors, :instance_writer => false, :instance_reader => false
+  #     cattr_accessor :hair_colors, instance_writer: false, instance_reader: false
   #   end
   #
   #   Person.new.hair_colors = [:brown]  # => NoMethodError
   #   Person.new.hair_colors             # => NoMethodError
   #
-  # Or pass <tt>:instance_accessor => false</tt>, to opt out both instance methods.
+  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
   #
   #   class Person
-  #     cattr_accessor :hair_colors, :instance_accessor => false
+  #     cattr_accessor :hair_colors, instance_accessor: false
   #   end
   #
   #   Person.new.hair_colors = [:brown]  # => NoMethodError

data/lib/active_support/core_ext/class/delegating_attributes.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/remove_method'
 
@@ -22,23 +20,21 @@ class Class
     define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
   end
 
-private
-
-  # Take the object being set and store it in a method. This gives us automatic
-  # inheritance behavior, without having to store the object in an instance
-  # variable and look up the superclass chain manually.
-  def _stash_object_in_method(object, method, instance_reader = true)
-    singleton_class.remove_possible_method(method)
-    singleton_class.send(:define_method, method) { object }
-    remove_possible_method(method)
-    define_method(method) { object } if instance_reader
-  end
-
-  def _superclass_delegating_accessor(name, options = {})
-    singleton_class.send(:define_method, "#{name}=") do |value|
-      _stash_object_in_method(value, name, options[:instance_reader] != false)
+  private
+    # Take the object being set and store it in a method. This gives us automatic
+    # inheritance behavior, without having to store the object in an instance
+    # variable and look up the superclass chain manually.
+    def _stash_object_in_method(object, method, instance_reader = true)
+      singleton_class.remove_possible_method(method)
+      singleton_class.send(:define_method, method) { object }
+      remove_possible_method(method)
+      define_method(method) { object } if instance_reader
     end
-    send("#{name}=", nil)
-  end
 
+    def _superclass_delegating_accessor(name, options = {})
+      singleton_class.send(:define_method, "#{name}=") do |value|
+        _stash_object_in_method(value, name, options[:instance_reader] != false)
+      end
+      send("#{name}=", nil)
+    end
 end

data/lib/active_support/core_ext/class/subclasses.rb

@@ -1,19 +1,19 @@
 require 'active_support/core_ext/module/anonymous'
 require 'active_support/core_ext/module/reachable'
 
-class Class #:nodoc:
+class Class
   begin
     ObjectSpace.each_object(Class.new) {}
 
-    def descendants
+    def descendants # :nodoc:
       descendants = []
-      ObjectSpace.each_object(class << self; self; end) do |k|
+      ObjectSpace.each_object(singleton_class) do |k|
         descendants.unshift k unless k == self
       end
       descendants
     end
   rescue StandardError # JRuby
-    def descendants
+    def descendants # :nodoc:
       descendants = []
       ObjectSpace.each_object(Class) do |k|
         descendants.unshift k if k < self
@@ -25,7 +25,13 @@ class Class #:nodoc:
 
   # Returns an array with the direct children of +self+.
   #
-  #   Integer.subclasses # => [Bignum, Fixnum]
+  #   Integer.subclasses # => [Fixnum, Bignum]
+  #
+  #   class Foo; end
+  #   class Bar < Foo; end
+  #   class Baz < Bar; end
+  #
+  #   Foo.subclasses # => [Bar]
   def subclasses
     subclasses, chain = [], descendants
     chain.each do |k|

data/lib/active_support/core_ext/date.rb

@@ -0,0 +1,6 @@
+require 'active_support/core_ext/date/acts_like'
+require 'active_support/core_ext/date/calculations'
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/date/zones'
+require 'active_support/core_ext/date/infinite_comparable'
+

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

@@ -3,29 +3,35 @@ require 'active_support/duration'
 require 'active_support/core_ext/object/acts_like'
 require 'active_support/core_ext/date/zones'
 require 'active_support/core_ext/time/zones'
+require 'active_support/core_ext/date_and_time/calculations'
 
 class Date
-  DAYS_INTO_WEEK = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6 }
+  include DateAndTime::Calculations
 
-  if RUBY_VERSION < '1.9'
-    undef :>>
+  class << self
+    attr_accessor :beginning_of_week_default
 
-    # Backported from 1.9. The one in 1.8 leads to incorrect next_month and
-    # friends for dates where the calendar reform is involved. It additionally
-    # prevents an infinite loop fixed in r27013.
-    def >>(n)
-      y, m = (year * 12 + (mon - 1) + n).divmod(12)
-      m,   = (m + 1)                    .divmod(1)
-      d = mday
-      until jd2 = self.class.valid_civil?(y, m, d, start)
-        d -= 1
-        raise ArgumentError, 'invalid date' unless d > 0
-      end
-      self + (jd2 - jd)
+    # Returns the week start (e.g. :monday) for the current request, if this has been set (via Date.beginning_of_week=).
+    # If <tt>Date.beginning_of_week</tt> has not been set for the current request, returns the week start specified in <tt>config.beginning_of_week</tt>.
+    # If no config.beginning_of_week was specified, returns :monday.
+    def beginning_of_week
+      Thread.current[:beginning_of_week] || beginning_of_week_default || :monday
+    end
+
+    # Sets <tt>Date.beginning_of_week</tt> to a week start (e.g. :monday) for current request/thread.
+    #
+    # This method accepts any of the following day symbols:
+    # :monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday
+    def beginning_of_week=(week_start)
+      Thread.current[:beginning_of_week] = find_beginning_of_week!(week_start)
+    end
+
+    # Returns week start day symbol (e.g. :monday), or raises an ArgumentError for invalid day symbol.
+    def find_beginning_of_week!(week_start)
+      raise ArgumentError, "Invalid beginning of week: #{week_start}" unless ::Date::DAYS_INTO_WEEK.key?(week_start)
+      week_start
     end
-  end
 
-  class << self
     # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
     def yesterday
       ::Date.current.yesterday
@@ -42,37 +48,22 @@ class Date
     end
   end
 
-  # Returns true if the Date object's date lies in the past. Otherwise returns false.
-  def past?
-    self < ::Date.current
-  end
-
-  # Returns true if the Date object's date is today.
-  def today?
-    self.to_date == ::Date.current # we need the to_date because of DateTime
-  end
-
-  # Returns true if the Date object's date lies in the future.
-  def future?
-    self > ::Date.current
-  end
-
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
   # and then subtracts the specified number of seconds.
   def ago(seconds)
-    to_time_in_current_zone.since(-seconds)
+    in_time_zone.since(-seconds)
   end
 
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
   # and then adds the specified number of seconds
   def since(seconds)
-    to_time_in_current_zone.since(seconds)
+    in_time_zone.since(seconds)
   end
   alias :in :since
 
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
   def beginning_of_day
-    to_time_in_current_zone
+    in_time_zone
   end
   alias :midnight :beginning_of_day
   alias :at_midnight :beginning_of_day
@@ -80,8 +71,9 @@ class Date
 
   # Converts Date to a Time (or DateTime if necessary) with the time portion set to the end of the day (23:59:59)
   def end_of_day
-    to_time_in_current_zone.end_of_day
+    in_time_zone.end_of_day
   end
+  alias :at_end_of_day :end_of_day
 
   def plus_with_duration(other) #:nodoc:
     if ActiveSupport::Duration === other
@@ -116,161 +108,15 @@ class Date
   end
 
   # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
+  # The +options+ parameter is a hash with a combination of these keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>.
   #
-  # Examples:
-  #
-  #   Date.new(2007, 5, 12).change(:day => 1)                  # => Date.new(2007, 5, 1)
-  #   Date.new(2007, 5, 12).change(:year => 2005, :month => 1) # => Date.new(2005, 1, 12)
+  #   Date.new(2007, 5, 12).change(day: 1)               # => Date.new(2007, 5, 1)
+  #   Date.new(2007, 5, 12).change(year: 2005, month: 1) # => Date.new(2005, 1, 12)
   def change(options)
     ::Date.new(
-      options[:year]  || self.year,
-      options[:month] || self.month,
-      options[:day]   || self.day
+      options.fetch(:year, year),
+      options.fetch(:month, month),
+      options.fetch(:day, day)
     )
   end
-
-  # Returns a new Date/DateTime representing the time a number of specified weeks ago.
-  def weeks_ago(weeks)
-    advance(:weeks => -weeks)
-  end
-
-  # Returns a new Date/DateTime representing the time a number of specified months ago.
-  def months_ago(months)
-    advance(:months => -months)
-  end
-
-  # Returns a new Date/DateTime representing the time a number of specified months in the future.
-  def months_since(months)
-    advance(:months => months)
-  end
-
-  # Returns a new Date/DateTime representing the time a number of specified years ago.
-  def years_ago(years)
-    advance(:years => -years)
-  end
-
-  # Returns a new Date/DateTime representing the time a number of specified years in the future.
-  def years_since(years)
-    advance(:years => years)
-  end
-
-  # Shorthand for years_ago(1)
-  def prev_year
-    years_ago(1)
-  end unless method_defined?(:prev_year)
-
-  # Shorthand for years_since(1)
-  def next_year
-    years_since(1)
-  end unless method_defined?(:next_year)
-
-  # Shorthand for months_ago(1)
-  def prev_month
-    months_ago(1)
-  end unless method_defined?(:prev_month)
-
-  # Shorthand for months_since(1)
-  def next_month
-    months_since(1)
-  end unless method_defined?(:next_month)
-
-  # Returns number of days to start of this week. Week is assumed to start on
-  # +start_day+, default is +:monday+.
-  def days_to_week_start(start_day = :monday)
-    start_day_number = DAYS_INTO_WEEK[start_day]
-    current_day_number = wday != 0 ? wday - 1 : 6
-    (current_day_number - start_day_number) % 7
-  end
-
-  # Returns a new +Date+/+DateTime+ representing the start of this week. Week is
-  # assumed to start on +start_day+, default is +:monday+. +DateTime+ objects
-  # have their time set to 0:00.
-  def beginning_of_week(start_day = :monday)
-    days_to_start = days_to_week_start(start_day)
-    result = self - days_to_start
-    acts_like?(:time) ? result.midnight : result
-  end
-  alias :at_beginning_of_week :beginning_of_week
-
-  # Returns a new +Date+/+DateTime+ representing the start of this week. Week is
-  # assumed to start on a Monday. +DateTime+ objects have their time set to 0:00.
-  def monday
-    beginning_of_week
-  end
-
-  # Returns a new +Date+/+DateTime+ representing the end of this week. Week is
-  # assumed to start on +start_day+, default is +:monday+. +DateTime+ objects
-  # have their time set to 23:59:59.
-  def end_of_week(start_day = :monday)
-    days_to_end = 6 - days_to_week_start(start_day)
-    result = self + days_to_end.days
-    self.acts_like?(:time) ? result.end_of_day : result
-  end
-  alias :at_end_of_week :end_of_week
-
-  # Returns a new +Date+/+DateTime+ representing the end of this week. Week is
-  # assumed to start on a Monday. +DateTime+ objects have their time set to 23:59:59.
-  def sunday
-    end_of_week
-  end
-
-  # Returns a new +Date+/+DateTime+ representing the given +day+ in the previous
-  # week. Default is +:monday+. +DateTime+ objects have their time set to 0:00.
-  def prev_week(day = :monday)
-    result = (self - 7).beginning_of_week + DAYS_INTO_WEEK[day]
-    self.acts_like?(:time) ? result.change(:hour => 0) : result
-  end
-
-  # Returns a new Date/DateTime representing the start of the given day in next week (default is :monday).
-  def next_week(day = :monday)
-    result = (self + 7).beginning_of_week + DAYS_INTO_WEEK[day]
-    self.acts_like?(:time) ? result.change(:hour => 0) : result
-  end
-
-  # Returns a new ; DateTime objects will have time set to 0:00DateTime representing the start of the month (1st of the month; DateTime objects will have time set to 0:00)
-  def beginning_of_month
-    self.acts_like?(:time) ? change(:day => 1, :hour => 0) : change(:day => 1)
-  end
-  alias :at_beginning_of_month :beginning_of_month
-
-  # Returns a new Date/DateTime representing the end of the month (last day of the month; DateTime objects will have time set to 0:00)
-  def end_of_month
-    last_day = ::Time.days_in_month( self.month, self.year )
-    self.acts_like?(:time) ? change(:day => last_day, :hour => 23, :min => 59, :sec => 59) : change(:day => last_day)
-  end
-  alias :at_end_of_month :end_of_month
-
-  # Returns a new Date/DateTime representing the start of the quarter (1st of january, april, july, october; DateTime objects will have time set to 0:00)
-  def beginning_of_quarter
-    beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= self.month })
-  end
-  alias :at_beginning_of_quarter :beginning_of_quarter
-
-  # Returns a new Date/DateTime representing the end of the quarter (last day of march, june, september, december; DateTime objects will have time set to 23:59:59)
-  def end_of_quarter
-    beginning_of_month.change(:month => [3, 6, 9, 12].detect { |m| m >= self.month }).end_of_month
-  end
-  alias :at_end_of_quarter :end_of_quarter
-
-  # Returns a new Date/DateTime representing the start of the year (1st of january; DateTime objects will have time set to 0:00)
-  def beginning_of_year
-    self.acts_like?(:time) ? change(:month => 1, :day => 1, :hour => 0) : change(:month => 1, :day => 1)
-  end
-  alias :at_beginning_of_year :beginning_of_year
-
-  # Returns a new Time representing the end of the year (31st of december; DateTime objects will have time set to 23:59:59)
-  def end_of_year
-    self.acts_like?(:time) ? change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59) : change(:month => 12, :day => 31)
-  end
-  alias :at_end_of_year :end_of_year
-
-  # Convenience method which returns a new Date/DateTime representing the time 1 day ago
-  def yesterday
-    self - 1
-  end
-
-  # Convenience method which returns a new Date/DateTime representing the time 1 day since the instance time
-  def tomorrow
-    self + 1
-  end
 end