activesupport-refinements 0.0.1

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

@@ -0,0 +1,14 @@
+module ModuleExt; end; module ModuleExt::RemoveMethod
+refine Module do
+  def remove_possible_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      undef_method(method)
+    end
+  end
+
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end
+end

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

@@ -0,0 +1,20 @@
+module NameErrorExt
+refine NameError do
+  # 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
+end

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

@@ -0,0 +1,3 @@
+require 'active_support/refinements/core_ext/numeric/bytes'
+require 'active_support/refinements/core_ext/numeric/time'
+require 'active_support/refinements/core_ext/numeric/conversions'

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

@@ -0,0 +1,46 @@
+module NumericExt; end; module NumericExt::Bytes
+refine Numeric do
+  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
+end

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

@@ -0,0 +1,137 @@
+module NumericExt; end; module NumericExt::Conversions
+require 'active_support/refinements/core_ext/big_decimal/conversions'
+require 'active_support/number_helper'
+
+refine Numeric do
+
+  # Provides options for converting numbers into formatted strings.
+  # Options are provided for phone numbers, currency, percentage,
+  # precision, positional notation, file size and pretty printing.
+  #
+  # ==== Options
+  #
+  # For details on which formats use which options, see ActiveSupport::NumberHelper
+  #
+  # ==== Examples
+  #
+  #  Phone Numbers:
+  #  5551234.to_s(:phone)                                     # => 555-1234
+  #  1235551234.to_s(:phone)                                  # => 123-555-1234
+  #  1235551234.to_s(:phone, area_code: true)                 # => (123) 555-1234
+  #  1235551234.to_s(:phone, delimiter: ' ')                  # => 123 555 1234
+  #  1235551234.to_s(:phone, area_code: true, extension: 555) # => (123) 555-1234 x 555
+  #  1235551234.to_s(:phone, country_code: 1)                 # => +1-123-555-1234
+  #  1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
+  #  # => +1.123.555.1234 x 1343
+  #
+  #  Currency:
+  #  1234567890.50.to_s(:currency)                 # => $1,234,567,890.50
+  #  1234567890.506.to_s(:currency)                # => $1,234,567,890.51
+  #  1234567890.506.to_s(:currency, precision: 3)  # => $1,234,567,890.506
+  #  1234567890.506.to_s(:currency, locale: :fr)   # => 1 234 567 890,51 €
+  #  -1234567890.50.to_s(:currency, negative_format: '(%u%n)')
+  #  # => ($1,234,567,890.50)
+  #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '')
+  #  # => £1234567890,50
+  #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '', format: '%n %u')
+  #  # => 1234567890,50 £
+  #
+  #  Percentage:
+  #  100.to_s(:percentage)                                  # => 100.000%
+  #  100.to_s(:percentage, precision: 0)                    # => 100%
+  #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => 1.000,000%
+  #  302.24398923423.to_s(:percentage, precision: 5)        # => 302.24399%
+  #  1000.to_s(:percentage, locale: :fr)                    # => 1 000,000%
+  #  100.to_s(:percentage, format: '%n  %')                 # => 100  %
+  #
+  #  Delimited:
+  #  12345678.to_s(:delimited)                     # => 12,345,678
+  #  12345678.05.to_s(:delimited)                  # => 12,345,678.05
+  #  12345678.to_s(:delimited, delimiter: '.')     # => 12.345.678
+  #  12345678.to_s(:delimited, delimiter: ',')     # => 12,345,678
+  #  12345678.05.to_s(:delimited, separator: ' ')  # => 12,345,678 05
+  #  12345678.05.to_s(:delimited, locale: :fr)     # => 12 345 678,05
+  #  98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
+  #  # => 98 765 432,98
+  #
+  #  Rounded:
+  #  111.2345.to_s(:rounded)                                      # => 111.235
+  #  111.2345.to_s(:rounded, precision: 2)                        # => 111.23
+  #  13.to_s(:rounded, precision: 5)                              # => 13.00000
+  #  389.32314.to_s(:rounded, precision: 0)                       # => 389
+  #  111.2345.to_s(:rounded, significant: true)                   # => 111
+  #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => 100
+  #  13.to_s(:rounded, precision: 5, significant: true)           # => 13.000
+  #  111.234.to_s(:rounded, locale: :fr)                          # => 111,234
+  #  13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
+  #  # => 13
+  #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => 389.3
+  #  1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
+  #  # => 1.111,23
+  #
+  #  Human-friendly size in Bytes:
+  #  123.to_s(:human_size)                                   # => 123 Bytes
+  #  1234.to_s(:human_size)                                  # => 1.21 KB
+  #  12345.to_s(:human_size)                                 # => 12.1 KB
+  #  1234567.to_s(:human_size)                               # => 1.18 MB
+  #  1234567890.to_s(:human_size)                            # => 1.15 GB
+  #  1234567890123.to_s(:human_size)                         # => 1.12 TB
+  #  1234567.to_s(:human_size, precision: 2)                 # => 1.2 MB
+  #  483989.to_s(:human_size, precision: 2)                  # => 470 KB
+  #  1234567.to_s(:human_size, precision: 2, separator: ',') # => 1,2 MB
+  #  1234567890123.to_s(:human_size, precision: 5)           # => "1.1229 TB"
+  #  524288000.to_s(:human_size, precision: 5)               # => "500 MB"
+  #
+  #  Human-friendly format:
+  #  123.to_s(:human)                                       # => "123"
+  #  1234.to_s(:human)                                      # => "1.23 Thousand"
+  #  12345.to_s(:human)                                     # => "12.3 Thousand"
+  #  1234567.to_s(:human)                                   # => "1.23 Million"
+  #  1234567890.to_s(:human)                                # => "1.23 Billion"
+  #  1234567890123.to_s(:human)                             # => "1.23 Trillion"
+  #  1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
+  #  1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
+  #  489939.to_s(:human, precision: 2)                      # => "490 Thousand"
+  #  489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
+  #  1234567.to_s(:human, precision: 4,
+  #                   significant: false)                   # => "1.2346 Million"
+  #  1234567.to_s(:human, precision: 1,
+  #                   separator: ',',
+  #                   significant: false)                   # => "1,2 Million"
+  def to_formatted_s(format = :default, options = {})
+    case format
+    when :phone
+      return ActiveSupport::NumberHelper.number_to_phone(self, options)
+    when :currency
+      return ActiveSupport::NumberHelper.number_to_currency(self, options)
+    when :percentage
+      return ActiveSupport::NumberHelper.number_to_percentage(self, options)
+    when :delimited
+      return ActiveSupport::NumberHelper.number_to_delimited(self, options)
+    when :rounded
+      return ActiveSupport::NumberHelper.number_to_rounded(self, options)
+    when :human
+      return ActiveSupport::NumberHelper.number_to_human(self, options)
+    when :human_size
+      return ActiveSupport::NumberHelper.number_to_human_size(self, options)
+    else
+      self.to_default_s
+    end
+  end
+
+  [Float, Fixnum, Bignum, BigDecimal].each do |klass|
+    klass.send(:alias_method, :to_default_s, :to_s)
+
+    klass.send(:define_method, :to_s) do |*args|
+      if args[0].is_a?(Symbol)
+        format = args[0]
+        options = args[1] || {}
+
+        self.to_formatted_s(format, options)
+      else
+        to_default_s(*args)
+      end
+    end
+  end
+end
+end

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

@@ -0,0 +1,81 @@
+module NumericExt; end; module NumericExt::Time
+require 'active_support/duration'
+require 'active_support/refinements/core_ext/time/calculations'
+require 'active_support/refinements/core_ext/time/acts_like'
+
+refine Numeric do
+  # 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
+  #
+  # 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://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+  # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.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.current)
+    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.current)
+    time + self
+  end
+
+  # Reads best without arguments:  10.minutes.from_now
+#  alias :from_now :since
+end
+end

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

@@ -0,0 +1,14 @@
+require 'active_support/refinements/core_ext/object/acts_like'
+require 'active_support/refinements/core_ext/object/blank'
+require 'active_support/refinements/core_ext/object/duplicable'
+require 'active_support/refinements/core_ext/object/deep_dup'
+require 'active_support/refinements/core_ext/object/try'
+require 'active_support/refinements/core_ext/object/inclusion'
+
+require 'active_support/refinements/core_ext/object/conversions'
+require 'active_support/refinements/core_ext/object/instance_variables'
+
+require 'active_support/refinements/core_ext/object/to_json'
+require 'active_support/refinements/core_ext/object/to_param'
+require 'active_support/refinements/core_ext/object/to_query'
+require 'active_support/refinements/core_ext/object/with_options'

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

@@ -0,0 +1,12 @@
+module ObjectExt; end; module ObjectExt::ActsLike
+refine Object do
+  # 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
+end

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

@@ -0,0 +1,107 @@
+module ObjectExt; end; module ObjectExt::Blank
+# encoding: utf-8
+
+refine Object do
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, '', '   ', +nil+, [], and {} are all 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 <tt>blank?</tt>.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+  #
+  # 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
+
+refine NilClass do
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  def blank?
+    true
+  end
+end
+
+refine FalseClass do
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  def blank?
+    true
+  end
+end
+
+refine TrueClass do
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  def blank?
+    false
+  end
+end
+
+refine Array do
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+#  alias_method :blank?, :empty?
+end
+
+refine Hash do
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+#  alias_method :blank?, :empty?
+end
+
+refine String do
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?                 # => true
+  #   '   '.blank?              # => true
+  #   '　'.blank?               # => true
+  #   ' something here '.blank? # => false
+  def blank?
+    self !~ /[^[:space:]]/
+  end
+end
+
+refine Numeric do
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  def blank?
+    false
+  end
+end
+end

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

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