core_ext 0.0.1

data/lib/core_ext/numeric/time.rb

@@ -0,0 +1,74 @@
+require 'core_ext/duration'
+require 'core_ext/time/calculations'
+require 'core_ext/time/acts_like'
+require 'core_ext/date/calculations'
+require 'core_ext/date/acts_like'
+
+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.current.advance(months: 1)
+  #   1.month.from_now
+  #
+  #   # equivalent to Time.current.advance(years: 2)
+  #   2.years.from_now
+  #
+  #   # equivalent to Time.current.advance(months: 4, years: 5)
+  #   (4.months + 5.years).from_now
+  def seconds
+    CoreExt::Duration.new(self, [[:seconds, self]])
+  end
+  alias :second :seconds
+
+  # Returns a Duration instance matching the number of minutes provided.
+  #
+  #   2.minutes # => 120 seconds
+  def minutes
+    CoreExt::Duration.new(self * 60, [[:seconds, self * 60]])
+  end
+  alias :minute :minutes
+
+  # Returns a Duration instance matching the number of hours provided.
+  #
+  #   2.hours # => 7_200 seconds
+  def hours
+    CoreExt::Duration.new(self * 3600, [[:seconds, self * 3600]])
+  end
+  alias :hour :hours
+
+  # Returns a Duration instance matching the number of days provided.
+  #
+  #   2.days # => 2 days
+  def days
+    CoreExt::Duration.new(self * 24.hours, [[:days, self]])
+  end
+  alias :day :days
+
+  # Returns a Duration instance matching the number of weeks provided.
+  #
+  #   2.weeks # => 14 days
+  def weeks
+    CoreExt::Duration.new(self * 7.days, [[:days, self * 7]])
+  end
+  alias :week :weeks
+
+  # Returns a Duration instance matching the number of fortnights provided.
+  #
+  #   2.fortnights # => 28 days
+  def fortnights
+    CoreExt::Duration.new(self * 2.weeks, [[:days, self * 14]])
+  end
+  alias :fortnight :fortnights
+
+  # Returns the number of milliseconds equivalent to the seconds provided.
+  # Used with the standard time durations, like 1.hour.in_milliseconds --
+  # so we can feed them to JavaScript functions like getTime().
+  #
+  #   2.in_milliseconds # => 2_000
+  def in_milliseconds
+    self * 1000
+  end
+end

data/lib/core_ext/numeric.rb

@@ -0,0 +1,4 @@
+require 'core_ext/numeric/bytes'
+require 'core_ext/numeric/time'
+require 'core_ext/numeric/inquiry'
+require 'core_ext/numeric/conversions'

data/lib/core_ext/object/acts_like.rb

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

data/lib/core_ext/object/blank.rb

@@ -0,0 +1,140 @@
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies
+  #
+  #   !address || address.empty?
+  #
+  # to
+  #
+  #   address.blank?
+  #
+  # @return [true, false]
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  #
+  # @return [true, false]
+  def present?
+    !blank?
+  end
+
+  # Returns the receiver if it's present otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to
+  #
+  #    object.present? ? object : nil
+  #
+  # For example, something like
+  #
+  #   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'
+  #
+  # @return [Object]
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class String
+  BLANK_RE = /\A[[:space:]]*\z/
+
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?       # => true
+  #   '   '.blank?    # => true
+  #   "\t\n\r".blank? # => true
+  #   ' blah '.blank? # => false
+  #
+  # Unicode whitespace is supported:
+  #
+  #   "\u00a0".blank? # => true
+  #
+  # @return [true, false]
+  def blank?
+    BLANK_RE === self
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Time #:nodoc:
+  # No Time is blank:
+  #
+  #   Time.now.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end

data/lib/core_ext/object/conversions.rb

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

data/lib/core_ext/object/deep_dup.rb

@@ -0,0 +1,53 @@
+require 'core_ext/object/duplicable'
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  def deep_dup
+    map(&:deep_dup)
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  def deep_dup
+    hash = dup
+    each_pair do |key, value|
+      if key.frozen? && ::String === key
+        hash[key] = value.deep_dup
+      else
+        hash.delete(key)
+        hash[key.deep_dup] = value.deep_dup
+      end
+    end
+    hash
+  end
+end

data/lib/core_ext/object/duplicable.rb

@@ -0,0 +1,98 @@
+#--
+# 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+, symbol, number, method objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass
+  # +nil+ is not duplicable:
+  #
+  #   nil.duplicable? # => false
+  #   nil.dup         # => TypeError: can't dup NilClass
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass
+  # +false+ is not duplicable:
+  #
+  #   false.duplicable? # => false
+  #   false.dup         # => TypeError: can't dup FalseClass
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass
+  # +true+ is not duplicable:
+  #
+  #   true.duplicable? # => false
+  #   true.dup         # => TypeError: can't dup TrueClass
+  def duplicable?
+    false
+  end
+end
+
+class Symbol
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.duplicable? # => false
+  #   :my_symbol.dup         # => TypeError: can't dup Symbol
+  def duplicable?
+    false
+  end
+end
+
+class Numeric
+  # Numbers are not duplicable:
+  #
+  #  3.duplicable? # => false
+  #  3.dup         # => TypeError: can't dup Fixnum
+  def duplicable?
+    false
+  end
+end
+
+require 'bigdecimal'
+class BigDecimal
+  # BigDecimals are duplicable:
+  #
+  # BigDecimal.new("1.2").duplicable? # => true
+  # BigDecimal.new("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
+  def duplicable?
+    true
+  end
+end
+
+class Method
+  # Methods are not duplicable:
+  #
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  def duplicable?
+    false
+  end
+end

data/lib/core_ext/object/inclusion.rb

@@ -0,0 +1,27 @@
+class Object
+  # Returns true if this object is included in the argument. Argument must be
+  # any object which responds to +#include?+. Usage:
+  #
+  #   characters = ["Konata", "Kagami", "Tsukasa"]
+  #   "Konata".in?(characters) # => true
+  #
+  # This will throw an +ArgumentError+ if the argument doesn't respond
+  # to +#include?+.
+  def in?(another_object)
+    another_object.include?(self)
+  rescue NoMethodError
+    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
+  end
+
+  # Returns the receiver if it's included in the argument otherwise returns +nil+.
+  # Argument must be any object which responds to +#include?+. Usage:
+  #
+  #   params[:bucket_type].presence_in %w( project calendar )
+  #
+  # This will throw an +ArgumentError+ if the argument doesn't respond to +#include?+.
+  #
+  # @return [Object]
+  def presence_in(another_object)
+    self.in?(another_object) ? self : nil
+  end
+end

data/lib/core_ext/object/instance_variables.rb

@@ -0,0 +1,28 @@
+class Object
+  # Returns a hash with string keys that maps instance variable names without "@" to their
+  # corresponding values.
+  #
+  #   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
+    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+  end
+
+  # Returns an array of instance variable names as strings including "@".
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #
+  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
+  def instance_variable_names
+    instance_variables.map(&:to_s)
+  end
+end

data/lib/core_ext/object/json.rb

@@ -0,0 +1,199 @@
+# Hack to load json gem first so we can overwrite its to_json.
+require 'json'
+require 'time'
+require 'bigdecimal'
+require 'core_ext/big_decimal/conversions' # for #to_s
+require 'core_ext/hash/except'
+require 'core_ext/hash/slice'
+require 'core_ext/object/instance_variables'
+require 'core_ext/time/conversions'
+require 'core_ext/date_time/conversions'
+require 'core_ext/date/conversions'
+
+# The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
+# their default behavior. That said, we need to define the basic to_json method in all of them,
+# otherwise they will always use to_json gem implementation, which is backwards incompatible in
+# several cases (for instance, the JSON implementation for Hash does not work) with inheritance
+# and consequently classes as CoreExt::OrderedHash cannot be serialized to json.
+#
+# On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
+# JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
+# passes a ::JSON::State object as the only argument to to_json, we can detect that and forward the
+# calls to the original to_json method.
+#
+# It should be noted that when using ::JSON.{generate,dump} directly, CoreExt's encoder is
+# bypassed completely. This means that as_json won't be invoked and the JSON gem will simply
+# ignore any options it does not natively understand. This also means that ::JSON.{generate,dump}
+# should give exactly the same results with or without active support.
+
+module CoreExt
+  module ToJsonWithCoreExtEncoder # :nodoc:
+    def to_json(options = nil)
+      if options.is_a?(::JSON::State)
+        # Called from JSON.{generate,dump}, forward it to JSON gem's to_json
+        super(options)
+      else
+        # to_json is being invoked directly, use CoreExt's encoder
+        CoreExt::JSON.encode(self, options)
+      end
+    end
+  end
+end
+
+[Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass, Enumerable].reverse_each do |klass|
+  klass.prepend(CoreExt::ToJsonWithCoreExtEncoder)
+end
+
+class Object
+  def as_json(options = nil) #:nodoc:
+    if respond_to?(:to_hash)
+      to_hash.as_json(options)
+    else
+      instance_values.as_json(options)
+    end
+  end
+end
+
+class Struct #:nodoc:
+  def as_json(options = nil)
+    Hash[members.zip(values)].as_json(options)
+  end
+end
+
+class TrueClass
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+end
+
+class FalseClass
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+end
+
+class NilClass
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+end
+
+class String
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+end
+
+class Symbol
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
+end
+
+class Numeric
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+end
+
+class Float
+  # Encoding Infinity or NaN to JSON should return "null". The default returns
+  # "Infinity" or "NaN" which are not valid JSON.
+  def as_json(options = nil) #:nodoc:
+    finite? ? self : nil
+  end
+end
+
+class BigDecimal
+  # A BigDecimal would be naturally represented as a JSON number. Most libraries,
+  # however, parse non-integer JSON numbers directly as floats. Clients using
+  # those libraries would get in general a wrong number and no way to recover
+  # other than manually inspecting the string with the JSON code itself.
+  #
+  # That's why a JSON string is returned. The JSON literal is not numeric, but
+  # if the other end knows by contract that the data is supposed to be a
+  # BigDecimal, it still has the chance to post-process the string and get the
+  # real value.
+  def as_json(options = nil) #:nodoc:
+    finite? ? to_s : nil
+  end
+end
+
+class Regexp
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
+end
+
+module Enumerable
+  def as_json(options = nil) #:nodoc:
+    to_a.as_json(options)
+  end
+end
+
+class Range
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
+end
+
+class Array
+  def as_json(options = nil) #:nodoc:
+    map { |v| options ? v.as_json(options.dup) : v.as_json }
+  end
+end
+
+class Hash
+  def as_json(options = nil) #:nodoc:
+    # create a subset of the hash by applying :only or :except
+    subset = if options
+      if attrs = options[:only]
+        slice(*Array(attrs))
+      elsif attrs = options[:except]
+        except(*Array(attrs))
+      else
+        self
+      end
+    else
+      self
+    end
+
+    Hash[subset.map { |k, v| [k.to_s, options ? v.as_json(options.dup) : v.as_json] }]
+  end
+end
+
+class Time
+  def as_json(options = nil) #:nodoc:
+    if CoreExt::JSON::Encoding.use_standard_json_time_format
+      xmlschema(CoreExt::JSON::Encoding.time_precision)
+    else
+      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
+    end
+  end
+end
+
+class Date
+  def as_json(options = nil) #:nodoc:
+    if CoreExt::JSON::Encoding.use_standard_json_time_format
+      strftime("%Y-%m-%d")
+    else
+      strftime("%Y/%m/%d")
+    end
+  end
+end
+
+class DateTime
+  def as_json(options = nil) #:nodoc:
+    if CoreExt::JSON::Encoding.use_standard_json_time_format
+      xmlschema(CoreExt::JSON::Encoding.time_precision)
+    else
+      strftime('%Y/%m/%d %H:%M:%S %z')
+    end
+  end
+end
+
+class Process::Status #:nodoc:
+  def as_json(options = nil)
+    { :exitstatus => exitstatus, :pid => pid }
+  end
+end

data/lib/core_ext/object/to_param.rb

@@ -0,0 +1 @@
+require 'core_ext/object/to_query'