automateit 0.71226.1 → 0.71230

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

@@ -0,0 +1,91 @@
+module InactiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # 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
+      module Time
+        def seconds
+          InactiveSupport::Duration.new(self, [[:seconds, self]])
+        end
+        alias :second :seconds
+
+        def minutes
+          InactiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
+        end
+        alias :minute :minutes  
+        
+        def hours
+          InactiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
+        end
+        alias :hour :hours
+        
+        def days
+          InactiveSupport::Duration.new(self * 24.hours, [[:days, self]])
+        end
+        alias :day :days
+
+        def weeks
+          InactiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
+        end
+        alias :week :weeks
+        
+        def fortnights
+          InactiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
+        end
+        alias :fortnight :fortnights
+        
+        def months
+          InactiveSupport::Duration.new(self * 30.days, [[:months, self]])
+        end
+        alias :month :months
+
+        def years
+          InactiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+        end
+        alias :year :years
+
+        # 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
+    end
+  end
+end

data/lib/inactive_support/core_ext/string/inflections.rb

@@ -0,0 +1,153 @@
+require 'inactive_support/inflector'
+
+module InactiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # String inflections define new methods on the String class to transform names for different purposes.
+      # For instance, you can figure out the name of a database from the name of a class.
+      #   "ScaleScore".tableize => "scale_scores"
+      module Inflections
+        # Returns the plural form of the word in the string.
+        #
+        # Examples
+        #   "post".pluralize #=> "posts"
+        #   "octopus".pluralize #=> "octopi"
+        #   "sheep".pluralize #=> "sheep"
+        #   "words".pluralize #=> "words"
+        #   "the blue mailman".pluralize #=> "the blue mailmen"
+        #   "CamelOctopus".pluralize #=> "CamelOctopi"
+        def pluralize
+          Inflector.pluralize(self)
+        end
+
+        # The reverse of pluralize, returns the singular form of a word in a string.
+        #
+        # Examples
+        #   "posts".singularize #=> "post"
+        #   "octopi".singularize #=> "octopus"
+        #   "sheep".singluarize #=> "sheep"
+        #   "word".singluarize #=> "word"
+        #   "the blue mailmen".singularize #=> "the blue mailman"
+        #   "CamelOctopi".singularize #=> "CamelOctopus"
+        def singularize
+          Inflector.singularize(self)
+        end
+
+        # By default, camelize converts strings to UpperCamelCase. If the argument to camelize
+        # is set to ":lower" then camelize produces lowerCamelCase.
+        #
+        # camelize will also convert '/' to '::' which is useful for converting paths to namespaces 
+        #
+        # Examples
+        #   "active_record".camelize #=> "ActiveRecord"
+        #   "active_record".camelize(:lower) #=> "activeRecord"
+        #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+        #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+        def camelize(first_letter = :upper)
+          case first_letter
+            when :upper then Inflector.camelize(self, true)
+            when :lower then Inflector.camelize(self, false)
+          end
+        end
+        alias_method :camelcase, :camelize
+
+        # Capitalizes all the words and replaces some characters in the string to create
+        # a nicer looking title. Titleize is meant for creating pretty output. It is not
+        # used in the Rails internals.
+        #
+        # titleize is also aliased as as titlecase
+        #
+        # Examples
+        #   "man from the boondocks".titleize #=> "Man From The Boondocks"
+        #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+        def titleize
+          Inflector.titleize(self)
+        end
+        alias_method :titlecase, :titleize
+
+        # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+        # 
+        # Changes '::' to '/' to convert namespaces to paths.
+        #
+        # Examples
+        #   "ActiveRecord".underscore #=> "active_record"
+        #   "ActiveRecord::Errors".underscore #=> active_record/errors
+        def underscore
+          Inflector.underscore(self)
+        end
+
+        # Replaces underscores with dashes in the string.
+        #
+        # Example
+        #   "puni_puni" #=> "puni-puni"
+        def dasherize
+          Inflector.dasherize(self)
+        end
+
+        # Removes the module part from the expression in the string
+        #
+        # Examples
+        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+        #   "Inflections".demodulize #=> "Inflections"
+        def demodulize
+          Inflector.demodulize(self)
+        end
+
+        # Create the name of a table like Rails does for models to table names. This method
+        # uses the pluralize method on the last word in the string.
+        #
+        # Examples
+        #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+        #   "egg_and_ham".tableize #=> "egg_and_hams"
+        #   "fancyCategory".tableize #=> "fancy_categories"
+        def tableize
+          Inflector.tableize(self)
+        end
+
+        # Create a class name from a table name like Rails does for table names to models.
+        # Note that this returns a string and not a Class. (To convert to an actual class
+        # follow classify with constantize.)
+        #
+        # Examples
+        #   "egg_and_hams".classify #=> "EggAndHam"
+        #   "post".classify #=> "Post"
+        def classify
+          Inflector.classify(self)
+        end
+        
+        # Capitalizes the first word and turns underscores into spaces and strips _id.
+        # Like titleize, this is meant for creating pretty output.
+        #
+        # Examples
+        #   "employee_salary" #=> "Employee salary" 
+        #   "author_id" #=> "Author"
+        def humanize
+          Inflector.humanize(self)
+        end
+
+        # Creates a foreign key name from a class name.
+        # +separate_class_name_and_id_with_underscore+ sets whether
+        # the method should put '_' between the name and 'id'.
+        #
+        # Examples
+        #   "Message".foreign_key #=> "message_id"
+        #   "Message".foreign_key(false) #=> "messageid"
+        #   "Admin::Post".foreign_key #=> "post_id"
+        def foreign_key(separate_class_name_and_id_with_underscore = true)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        end
+
+        # Constantize tries to find a declared constant with the name specified
+        # in the string. It raises a NameError when the name is not in CamelCase
+        # or is not initialized.
+        #
+        # Examples
+        #   "Module".constantize #=> Module
+        #   "Class".constantize #=> Class
+        def constantize
+          Inflector.constantize(self)
+        end
+      end
+    end
+  end
+end

data/lib/inactive_support/core_ext/symbol.rb

@@ -0,0 +1,14 @@
+unless :test.respond_to?(:to_proc)
+  class Symbol
+    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+    #
+    #   # The same as people.collect { |p| p.name }
+    #   people.collect(&:name)
+    #
+    #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+    #   people.select(&:manager?).collect(&:salary)
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end

data/lib/inactive_support/core_ext/time/conversions.rb

@@ -0,0 +1,94 @@
+module InactiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Time #:nodoc:
+      # Getting times in different convenient string representations and other objects
+      module Conversions
+        DATE_FORMATS = {
+          :db           => "%Y-%m-%d %H:%M:%S",
+          :time         => "%H:%M",
+          :short        => "%d %b %H:%M",
+          :long         => "%B %d, %Y %H:%M",
+          :long_ordinal => lambda { |time| time.strftime("%B #{time.day.ordinalize}, %Y %H:%M") },
+          :rfc822       => "%a, %d %b %Y %H:%M:%S %z"
+        }
+
+        def self.included(base)
+          base.class_eval do
+            alias_method :to_default_s, :to_s
+            alias_method :to_s, :to_formatted_s
+          end
+        end
+
+        # Convert to a formatted string - see DATE_FORMATS for predefined formats.
+        # You can also add your own formats to the DATE_FORMATS constant and use them with this method.
+        #
+        # This method is also aliased as <tt>to_s</tt>.
+        #
+        # ==== Examples:
+        #   time = Time.now                     # => Thu Jan 18 06:10:17 CST 2007
+        #
+        #   time.to_formatted_s(:time)          # => "06:10:17"
+        #   time.to_s(:time)                    # => "06:10:17"
+        #
+        #   time.to_formatted_s(:db)            # => "2007-01-18 06:10:17"
+        #   time.to_formatted_s(:short)         # => "18 Jan 06:10"
+        #   time.to_formatted_s(:long)          # => "January 18, 2007 06:10"
+        #   time.to_formatted_s(:long_ordinal)  # => "January 18th, 2007 06:10"
+        #   time.to_formatted_s(:rfc822)        # => "Thu, 18 Jan 2007 06:10:17 -0600"
+        def to_formatted_s(format = :default)
+          if formatter = DATE_FORMATS[format]
+            if formatter.respond_to?(:call)
+              formatter.call(self).to_s
+            else
+              strftime(formatter)
+            end
+          else
+            to_default_s
+          end
+        end
+
+        # Convert a Time object to a Date, dropping hour, minute, and second precision.
+        #
+        # ==== Examples
+        #   my_time = Time.now
+        #   # => Mon Nov 12 22:59:51 -0500 2007
+        #
+        #   my_time.to_date
+        #   #=> Mon, 12 Nov 2007
+        #
+        #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")
+        #   # => Tue Jan 13 13:13:03 -0500 2009
+        #
+        #   your_time.to_date
+        #   # => Tue, 13 Jan 2009
+        def to_date
+          ::Date.new(year, month, day)
+        end
+
+        # A method to keep Time, Date and DateTime instances interchangeable on conversions.
+        # In this case, it simply returns +self+.
+        def to_time
+          self
+        end
+
+        # Converts a Time instance to a Ruby DateTime instance, preserving UTC offset.
+        #
+        # ==== Examples
+        #   my_time = Time.now
+        #   # => Mon Nov 12 23:04:21 -0500 2007
+        #
+        #   my_time.to_datetime
+        #   # => Mon, 12 Nov 2007 23:04:21 -0500
+        #
+        #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")
+        #   # => Tue Jan 13 13:13:03 -0500 2009
+        #
+        #   your_time.to_datetime
+        #   # => Tue, 13 Jan 2009 13:13:03 -0500
+        def to_datetime
+          ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400))
+        end
+      end
+    end
+  end
+end

data/lib/inactive_support/duration.rb

@@ -0,0 +1,96 @@
+module InactiveSupport
+  # 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:
+      klass == Duration || super
+    end
+
+    # 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 super
+    end
+
+    # Calculates a new Time or Date that is as far in the future
+    # as this Duration represents.
+    def since(time = ::Time.now)
+      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.now)
+      sum(-1, time)
+    end
+    alias :until :ago
+
+    def inspect #:nodoc:
+      consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
+      [: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.to_sentence
+    end
+
+    protected
+
+      def sum(sign, time = ::Time.now) #: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