activesupport-refinements 0.0.1

data/lib/active_support/refinements/core_ext/date_time.rb

@@ -0,0 +1,4 @@
+require 'active_support/refinements/core_ext/date_time/acts_like'
+require 'active_support/refinements/core_ext/date_time/calculations'
+require 'active_support/refinements/core_ext/date_time/conversions'
+require 'active_support/refinements/core_ext/date_time/zones'

data/lib/active_support/refinements/core_ext/date_time/acts_like.rb

@@ -0,0 +1,15 @@
+module DateTimeExt; end; module DateTimeExt::ActsLike
+require 'active_support/refinements/core_ext/object/acts_like'
+
+refine DateTime do
+  # Duck-types as a Date-like class. See Object#acts_like?.
+  def acts_like_date?
+    true
+  end
+
+  # Duck-types as a Time-like class. See Object#acts_like?.
+  def acts_like_time?
+    true
+  end
+end
+end

data/lib/active_support/refinements/core_ext/date_time/calculations.rb

@@ -0,0 +1,143 @@
+module DateTimeExt; end; module DateTimeExt::Calculations
+require 'active_support/deprecation'
+
+refine DateTime do
+  class << self
+    # *DEPRECATED*: Use +DateTime.civil_from_format+ directly.
+    def local_offset
+      ActiveSupport::Deprecation.warn 'DateTime.local_offset is deprecated. Use DateTime.civil_from_format directly.', caller
+
+      ::Time.local(2012).utc_offset.to_r / 86400
+    end
+
+    # Returns <tt>Time.zone.now.to_datetime</tt> when <tt>Time.zone</tt> or
+    # <tt>config.time_zone</tt> are set, otherwise returns
+    # <tt>Time.now.to_datetime</tt>.
+    def current
+      ::Time.zone ? ::Time.zone.now.to_datetime : ::Time.now.to_datetime
+    end
+  end
+
+  # Tells whether the DateTime object's datetime lies in the past.
+  def past?
+    self < ::DateTime.current
+  end
+
+  # Tells whether the DateTime object's datetime lies in the future.
+  def future?
+    self > ::DateTime.current
+  end
+
+  # Seconds since midnight: DateTime.now.seconds_since_midnight.
+  def seconds_since_midnight
+    sec + (min * 60) + (hour * 3600)
+  end
+
+  # Returns a new DateTime where one or more of the elements have been changed
+  # according to the +options+ parameter. The time options (<tt>:hour</tt>,
+  # <tt>:minute</tt>, <tt>:sec</tt>) reset cascadingly, so if only the hour is
+  # passed, then minute and sec is set to 0. If the hour and minute is passed,
+  # then sec is set to 0. The +options+ parameter takes a hash with any of these
+  # keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>, <tt>:hour</tt>,
+  # <tt>:min</tt>, <tt>:sec</tt>, <tt>:offset</tt>, <tt>:start</tt>.
+  #
+  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => DateTime.new(2012, 8, 1, 22, 35, 0)
+  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => DateTime.new(1981, 8, 1, 22, 35, 0)
+  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => DateTime.new(1981, 8, 29, 0, 0, 0)
+  def change(options)
+    ::DateTime.civil(
+      options.fetch(:year, year),
+      options.fetch(:month, month),
+      options.fetch(:day, day),
+      options.fetch(:hour, hour),
+      options.fetch(:min, options[:hour] ? 0 : min),
+      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec),
+      options.fetch(:offset, offset),
+      options.fetch(:start, start)
+    )
+  end
+
+  # Uses Date to provide precise Time calculations for years, months, and days.
+  # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
+  # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
+  # <tt>:minutes</tt>, <tt>:seconds</tt>.
+  def advance(options)
+    d = to_date.advance(options)
+    datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
+    seconds_to_advance = \
+      options.fetch(:seconds, 0) +
+      options.fetch(:minutes, 0) * 60 +
+      options.fetch(:hours, 0) * 3600
+
+    if seconds_to_advance.zero?
+      datetime_advanced_by_date
+    else
+      datetime_advanced_by_date.since seconds_to_advance
+    end
+  end
+
+  # Returns a new DateTime representing the time a number of seconds ago.
+  # Do not use this method in combination with x.months, use months_ago instead!
+  def ago(seconds)
+    since(-seconds)
+  end
+
+  # Returns a new DateTime representing the time a number of seconds since the
+  # instance time. Do not use this method in combination with x.months, use
+  # months_since instead!
+  def since(seconds)
+    self + Rational(seconds.round, 86400)
+  end
+#  alias :in :since
+
+  # Returns a new DateTime representing the start of the day (0:00).
+  def beginning_of_day
+    change(:hour => 0)
+  end
+#  alias :midnight :beginning_of_day
+#  alias :at_midnight :beginning_of_day
+#  alias :at_beginning_of_day :beginning_of_day
+
+  # Returns a new DateTime representing the end of the day (23:59:59).
+  def end_of_day
+    change(:hour => 23, :min => 59, :sec => 59)
+  end
+
+  # Returns a new DateTime representing the start of the hour (hh:00:00).
+  def beginning_of_hour
+    change(:min => 0)
+  end
+#  alias :at_beginning_of_hour :beginning_of_hour
+
+  # Returns a new DateTime representing the end of the hour (hh:59:59).
+  def end_of_hour
+    change(:min => 59, :sec => 59)
+  end
+
+  # Adjusts DateTime to UTC by adding its offset value; offset is set to 0.
+  #
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))     # => Mon, 21 Feb 2005 10:11:12 -0600
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 +0000
+  def utc
+    new_offset(0)
+  end
+#  alias_method :getutc, :utc
+
+  # Returns +true+ if <tt>offset == 0</tt>.
+  def utc?
+    offset == 0
+  end
+
+  # Returns the offset value in seconds.
+  def utc_offset
+    (offset * 86400).to_i
+  end
+
+  # Layers additional behavior on DateTime#<=> so that Time and
+  # ActiveSupport::TimeWithZone instances can be compared with a DateTime.
+  def <=>(other)
+    super other.to_datetime
+  end
+
+end
+end

data/lib/active_support/refinements/core_ext/date_time/conversions.rb

@@ -0,0 +1,93 @@
+module DateTimeExt; end; module DateTimeExt::Conversions
+require 'active_support/inflector/methods'
+require 'active_support/refinements/core_ext/time/conversions'
+require 'active_support/refinements/core_ext/date_time/calculations'
+require 'active_support/values/time_zone'
+
+refine DateTime do
+  # Convert to a formatted string. See Time::DATE_FORMATS for predefined formats.
+  #
+  # This method is aliased to <tt>to_s</tt>.
+  #
+  # === Examples
+  #   datetime = DateTime.civil(2007, 12, 4, 0, 0, 0, 0)   # => Tue, 04 Dec 2007 00:00:00 +0000
+  #
+  #   datetime.to_formatted_s(:db)            # => "2007-12-04 00:00:00"
+  #   datetime.to_s(:db)                      # => "2007-12-04 00:00:00"
+  #   datetime.to_s(:number)                  # => "20071204000000"
+  #   datetime.to_formatted_s(:short)         # => "04 Dec 00:00"
+  #   datetime.to_formatted_s(:long)          # => "December 04, 2007 00:00"
+  #   datetime.to_formatted_s(:long_ordinal)  # => "December 4th, 2007 00:00"
+  #   datetime.to_formatted_s(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
+  #
+  # == Adding your own datetime formats to to_formatted_s
+  # DateTime formats are shared with Time. You can add your own to the
+  # Time::DATE_FORMATS hash. Use the format name as the hash key and
+  # either a strftime string or Proc instance that takes a time or
+  # datetime argument as the value.
+  #
+  #   # config/initializers/time_formats.rb
+  #   Time::DATE_FORMATS[:month_and_year] = '%B %Y'
+  #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
+  def to_formatted_s(format = :default)
+    if formatter = ::Time::DATE_FORMATS[format]
+      formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+    else
+      to_default_s
+    end
+  end
+#  alias_method :to_default_s, :to_s if instance_methods(false).include?(:to_s)
+#  alias_method :to_s, :to_formatted_s
+
+  #
+  #   datetime = DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-6, 24))
+  #   datetime.formatted_offset         # => "-06:00"
+  #   datetime.formatted_offset(false)  # => "-0600"
+  def formatted_offset(colon = true, alternate_utc_string = nil)
+    utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
+  end
+
+  # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005 14:30:00 +0000".
+  def readable_inspect
+    to_s(:rfc822)
+  end
+#  alias_method :default_inspect, :inspect
+#  alias_method :inspect, :readable_inspect
+
+  # Returns DateTime with local offset for given year if format is local else
+  # offset is zero.
+  #
+  #   DateTime.civil_from_format :local, 2012
+  #   # => Sun, 01 Jan 2012 00:00:00 +0300
+  #   DateTime.civil_from_format :local, 2012, 12, 17
+  #   # => Mon, 17 Dec 2012 00:00:00 +0000
+  def self.civil_from_format(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0)
+    if utc_or_local.to_sym == :local
+      offset = ::Time.local(year, month, day).utc_offset.to_r / 86400
+    else
+      offset = 0
+    end
+    civil(year, month, day, hour, min, sec, offset)
+  end
+
+  # Converts +self+ to a floating-point number of seconds since the Unix epoch.
+  def to_f
+    seconds_since_unix_epoch.to_f
+  end
+
+  # Converts +self+ to an integer number of seconds since the Unix epoch.
+  def to_i
+    seconds_since_unix_epoch.to_i
+  end
+
+  private
+
+  def offset_in_seconds
+    (offset * 86400).to_i
+  end
+
+  def seconds_since_unix_epoch
+    (jd - 2440588) * 86400 - offset_in_seconds + seconds_since_midnight
+  end
+end
+end

data/lib/active_support/refinements/core_ext/date_time/zones.rb

@@ -0,0 +1,26 @@
+module DateTimeExt; end; module DateTimeExt::Zones
+require 'active_support/refinements/core_ext/time/zones'
+
+refine DateTime do
+  # Returns the simultaneous time in <tt>Time.zone</tt>.
+  #
+  #   Time.zone = 'Hawaii'             # => 'Hawaii'
+  #   DateTime.new(2000).in_time_zone  # => Fri, 31 Dec 1999 14:00:00 HST -10:00
+  #
+  # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt>
+  # as the local zone instead of the operating system's time zone.
+  #
+  # You can also pass in a TimeZone instance or string that identifies a TimeZone
+  # as an argument, and the conversion will be based on that zone instead of
+  # <tt>Time.zone</tt>.
+  #
+  #   DateTime.new(2000).in_time_zone('Alaska') # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
+  def in_time_zone(zone = ::Time.zone)
+    if zone
+      ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone))
+    else
+      self
+    end
+  end
+end
+end

data/lib/active_support/refinements/core_ext/enumerable.rb

@@ -0,0 +1,82 @@
+module EnumerableExt
+refine Enumerable do
+  # Calculates a sum from the elements.
+  #
+  #  payments.sum { |p| p.price * p.tax_rate }
+  #  payments.sum(&:price)
+  #
+  # The latter is a shortcut for:
+  #
+  #  payments.inject(0) { |sum, p| sum + p.price }
+  #
+  # It can also calculate the sum without the use of a block.
+  #
+  #  [5, 15, 10].sum # => 30
+  #  ['foo', 'bar'].sum # => "foobar"
+  #  [[1, 2], [3, 1, 5]].sum => [1, 2, 3, 1, 5]
+  #
+  # The default sum of an empty list is zero. You can override this default:
+  #
+  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
+  def sum(identity = 0, &block)
+    if block_given?
+      map(&block).sum(identity)
+    else
+      inject { |sum, element| sum + element } || identity
+    end
+  end
+
+  # Convert an enumerable to a hash.
+  #
+  #   people.index_by(&:login)
+  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
+  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
+  def index_by
+    if block_given?
+      Hash[map { |elem| [yield(elem), elem] }]
+    else
+      to_enum :index_by
+    end
+  end
+
+  # Returns +true+ if the enumerable has more than 1 element. Functionally
+  # equivalent to <tt>enum.to_a.size > 1</tt>. Can be called with a block too,
+  # much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns +true+
+  # if more than one person is over 26.
+  def many?
+    cnt = 0
+    if block_given?
+      any? do |element|
+        cnt += 1 if yield element
+        cnt > 1
+      end
+    else
+      any? { (cnt += 1) > 1 }
+    end
+  end
+
+  # The negative of the <tt>Enumerable#include?</tt>. Returns +true+ if the
+  # collection does not include the object.
+  def exclude?(object)
+    !include?(object)
+  end
+end
+
+refine Range do
+  # Optimize range sum to use arithmetic progression if a block is not given and
+  # we have a range of numeric values.
+  def sum(identity = 0)
+    if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
+      super
+    else
+      actual_last = exclude_end? ? (last - 1) : last
+      if actual_last >= first
+        (actual_last - first + 1) * (actual_last + first) / 2
+      else
+        identity
+      end
+    end
+  end
+end
+end

data/lib/active_support/refinements/core_ext/exception.rb

@@ -0,0 +1,5 @@
+module ExceptionExt
+refine ActiveSupport do
+  FrozenObjectError = RuntimeError
+end
+end

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

@@ -0,0 +1 @@
+require 'active_support/refinements/core_ext/file/atomic'

data/lib/active_support/refinements/core_ext/file/atomic.rb

@@ -0,0 +1,60 @@
+module FileExt; end; module FileExt::Atomic
+require 'fileutils'
+
+refine File do
+  # Write to a file atomically. Useful for situations where you don't
+  # want other processes or threads to see half-written files.
+  #
+  #   File.atomic_write('important.file') do |file|
+  #     file.write('hello')
+  #   end
+  #
+  # If your temp directory is not on the same filesystem as the file you're
+  # trying to write, you can provide a different temporary directory.
+  #
+  #   File.atomic_write('/data/something.important', '/data/tmp') do |file|
+  #     file.write('hello')
+  #   end
+  def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
+    require 'tempfile' unless defined?(Tempfile)
+    require 'fileutils' unless defined?(FileUtils)
+
+    temp_file = Tempfile.new(basename(file_name), temp_dir)
+    temp_file.binmode
+    yield temp_file
+    temp_file.close
+
+    if File.exists?(file_name)
+      # Get original file permissions
+      old_stat = stat(file_name)
+    else
+      # If not possible, probe which are the default permissions in the
+      # destination directory.
+      old_stat = probe_stat_in(dirname(file_name))
+    end
+
+    # Overwrite original file with temp file
+    FileUtils.mv(temp_file.path, file_name)
+
+    # Set correct permissions on new file
+    chown(old_stat.uid, old_stat.gid, file_name)
+    chmod(old_stat.mode, file_name)
+  end
+
+  # Private utility method.
+  def self.probe_stat_in(dir) #:nodoc:
+    basename = [
+      '.permissions_check',
+      Thread.current.object_id,
+      Process.pid,
+      rand(1000000)
+    ].join('.')
+
+    file_name = join(dir, basename)
+    FileUtils.touch(file_name)
+    stat(file_name)
+  ensure
+    FileUtils.rm_f(file_name) if file_name
+  end
+end
+end

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

@@ -0,0 +1,8 @@
+require 'active_support/refinements/core_ext/hash/conversions'
+require 'active_support/refinements/core_ext/hash/deep_merge'
+require 'active_support/refinements/core_ext/hash/diff'
+require 'active_support/refinements/core_ext/hash/except'
+require 'active_support/refinements/core_ext/hash/indifferent_access'
+require 'active_support/refinements/core_ext/hash/keys'
+require 'active_support/refinements/core_ext/hash/reverse_merge'
+require 'active_support/refinements/core_ext/hash/slice'