activesupport-refinements 0.0.1

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

@@ -0,0 +1,3 @@
+require 'active_support/refinements/core_ext/integer/multiple'
+require 'active_support/refinements/core_ext/integer/inflections'
+require 'active_support/refinements/core_ext/integer/time'

data/lib/active_support/refinements/core_ext/integer/inflections.rb

@@ -0,0 +1,31 @@
+module IntegerExt; end; module IntegerExt::Inflections
+require 'active_support/inflector'
+
+refine Integer do
+  # Ordinalize turns a number into an ordinal string used to denote the
+  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  #  1.ordinalize     # => "1st"
+  #  2.ordinalize     # => "2nd"
+  #  1002.ordinalize  # => "1002nd"
+  #  1003.ordinalize  # => "1003rd"
+  #  -11.ordinalize   # => "-11th"
+  #  -1001.ordinalize # => "-1001st"
+  def ordinalize
+    ActiveSupport::Inflector.ordinalize(self)
+  end
+
+  # Ordinal returns the suffix used to denote the position
+  # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  #  1.ordinal     # => "st"
+  #  2.ordinal     # => "nd"
+  #  1002.ordinal  # => "nd"
+  #  1003.ordinal  # => "rd"
+  #  -11.ordinal   # => "th"
+  #  -1001.ordinal # => "st"
+  def ordinal
+    ActiveSupport::Inflector.ordinal(self)
+  end
+end
+end

data/lib/active_support/refinements/core_ext/integer/multiple.rb

@@ -0,0 +1,12 @@
+module IntegerExt; end; module IntegerExt::Multiple
+refine Integer do
+  # Check whether the integer is evenly divisible by the argument.
+  #
+  #   0.multiple_of?(0)  #=> true
+  #   6.multiple_of?(5)  #=> false
+  #   10.multiple_of?(2) #=> true
+  def multiple_of?(number)
+    number != 0 ? self % number == 0 : zero?
+  end
+end
+end

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

@@ -0,0 +1,43 @@
+module IntegerExt; end; module IntegerExt::Time
+refine Integer do
+  # Enables the use of time calculations and declarations, like <tt>45.minutes +
+  # 2.hours + 4.years</tt>.
+  #
+  # These methods use Time#advance for precise date calculations when using
+  # <tt>from_now</tt>, +ago+, etc. as well as adding or subtracting their
+  # results from a Time object.
+  #
+  #   # 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://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 months
+    ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
+  end
+#  alias :month :months
+
+  def years
+    ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+  end
+#  alias :year :years
+end
+end

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

@@ -0,0 +1,4 @@
+require 'active_support/refinements/core_ext/kernel/reporting'
+require 'active_support/refinements/core_ext/kernel/agnostics'
+require 'active_support/refinements/core_ext/kernel/debugger'
+require 'active_support/refinements/core_ext/kernel/singleton_class'

data/lib/active_support/refinements/core_ext/kernel/agnostics.rb

@@ -0,0 +1,13 @@
+module KernelExt; end; module KernelExt::Agnostics
+refine Object do
+  # Makes backticks behave (somewhat more) similarly on all platforms.
+  # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the
+  # spawned shell prints a message to stderr and sets $?. We emulate
+  # Unix on the former but not the latter.
+  def `(command) #:nodoc:
+    super
+  rescue Errno::ENOENT => e
+    STDERR.puts "#$0: #{e}"
+  end
+end
+end

data/lib/active_support/refinements/core_ext/kernel/debugger.rb

@@ -0,0 +1,12 @@
+module KernelExt; end; module KernelExt::Debugger
+refine Kernel do
+  unless respond_to?(:debugger)
+    # Starts a debugging session if the +debugger+ gem has been loaded (call rails server --debugger to do load it).
+    def debugger
+      message = "\n***** Debugger requested, but was not available (ensure the debugger gem is listed in Gemfile/installed as gem): Start server with --debugger to enable *****\n"
+      defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
+    end
+#    alias breakpoint debugger unless respond_to?(:breakpoint)
+  end
+end
+end

data/lib/active_support/refinements/core_ext/kernel/reporting.rb

@@ -0,0 +1,97 @@
+module KernelExt; end; module KernelExt::Reporting
+require 'rbconfig'
+
+refine Kernel do
+  # Sets $VERBOSE to nil for the duration of the block and back to its original
+  # value afterwards.
+  #
+  #   silence_warnings do
+  #     value = noisy_call # no warning voiced
+  #   end
+  #
+  #   noisy_call # warning voiced
+  def silence_warnings
+    with_warnings(nil) { yield }
+  end
+
+  # Sets $VERBOSE to +true+ for the duration of the block and back to its
+  # original value afterwards.
+  def enable_warnings
+    with_warnings(true) { yield }
+  end
+
+  # Sets $VERBOSE for the duration of the block and back to its original
+  # value afterwards.
+  def with_warnings(flag)
+    old_verbose, $VERBOSE = $VERBOSE, flag
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  # For compatibility
+  def silence_stderr #:nodoc:
+    silence_stream(STDERR) { yield }
+  end
+
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+
+  # Blocks and ignores any exception passed as argument if raised within the block.
+  #
+  #   suppress(ZeroDivisionError) do
+  #     1/0
+  #     puts 'This code is NOT reached'
+  #   end
+  #
+  #   puts 'This code gets executed and nothing related to ZeroDivisionError was seen'
+  def suppress(*exception_classes)
+    begin yield
+    rescue Exception => e
+      raise unless exception_classes.any? { |cls| e.kind_of?(cls) }
+    end
+  end
+
+  # Captures the given stream and returns it:
+  #
+  #   stream = capture(:stdout) { puts 'Cool' }
+  #   stream # => "Cool\n"
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+#  alias :silence :capture
+
+  # Silences both STDOUT and STDERR, even for subprocesses.
+  #
+  #   quietly { system 'bundle install' }
+  def quietly
+    silence_stream(STDOUT) do
+      silence_stream(STDERR) do
+        yield
+      end
+    end
+  end
+end
+end

data/lib/active_support/refinements/core_ext/kernel/singleton_class.rb

@@ -0,0 +1,8 @@
+module KernelExt; end; module KernelExt::SingletonClass
+refine Kernel do
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end
+end

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

@@ -0,0 +1,27 @@
+module LoadErrorExt
+refine LoadError do
+  REGEXPS = [
+    /^no such file to load -- (.+)$/i,
+    /^Missing \w+ (?:file\s*)?([^\s]+.rb)$/i,
+    /^Missing API definition file in (.+)$/i,
+    /^cannot load such file -- (.+)$/i,
+  ]
+
+  unless method_defined?(:path)
+    def path
+      @path ||= begin
+        REGEXPS.find do |regex|
+          message =~ regex
+        end
+        $1
+      end
+    end
+  end
+
+  def is_missing?(location)
+    location.sub(/\.rb$/, '') == path.sub(/\.rb$/, '')
+  end
+end
+
+MissingSourceFile = LoadError
+end

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

@@ -0,0 +1,86 @@
+module LoggerExt
+require 'active_support/refinements/core_ext/class/attribute_accessors'
+require 'active_support/deprecation'
+
+ActiveSupport::Deprecation.warn 'this file is deprecated and will be removed'
+
+# Adds the 'around_level' method to Logger.
+refine Logger do
+  def self.define_around_helper(level)
+    module_eval <<-end_eval, __FILE__, __LINE__ + 1
+      def around_#{level}(before_message, after_message)  # def around_debug(before_message, after_message, &block)
+        self.#{level}(before_message)                     #   self.debug(before_message)
+        return_value = yield(self)                        #   return_value = yield(self)
+        self.#{level}(after_message)                      #   self.debug(after_message)
+        return_value                                      #   return_value
+      end                                                 # end
+    end_eval
+  end
+  [:debug, :info, :error, :fatal].each {|level| define_around_helper(level) }
+end
+
+require 'logger'
+
+# Extensions to the built-in Ruby logger.
+#
+# If you want to use the default log formatter as defined in the Ruby core, then you
+# will need to set the formatter for the logger as in:
+#
+#   logger.formatter = Formatter.new
+#
+# You can then specify the datetime format, for example:
+#
+#   logger.datetime_format = "%Y-%m-%d"
+#
+# Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
+refine Logger do
+  ##
+  # :singleton-method:
+  # Set to false to disable the silencer
+  cattr_accessor :silencer
+  self.silencer = true
+
+  # Silences the logger for the duration of the block.
+  def silence(temporary_level = Logger::ERROR)
+    if silencer
+      begin
+        old_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
+    else
+      yield self
+    end
+  end
+
+#  alias :old_datetime_format= :datetime_format=
+  # Logging date-time format (string passed to +strftime+). Ignored if the formatter
+  # does not respond to datetime_format=.
+  def datetime_format=(format)
+    formatter.datetime_format = format if formatter.respond_to?(:datetime_format=)
+  end
+
+#  alias :old_datetime_format :datetime_format
+  # Get the logging datetime format. Returns nil if the formatter does not support
+  # datetime formatting.
+  def datetime_format
+    formatter.datetime_format if formatter.respond_to?(:datetime_format)
+  end
+
+#  alias :old_initialize :initialize
+  # Overwrite initialize to set a default formatter.
+  def initialize(*args)
+    old_initialize(*args)
+    self.formatter = SimpleFormatter.new
+  end
+
+  # Simple formatter which only displays the message.
+ refine SimpleFormatter do
+    # This method is invoked when a log event occurs
+    def call(severity, timestamp, progname, msg)
+      "#{String === msg ? msg : msg.inspect}\n"
+    end
+  end
+end
+end

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

@@ -0,0 +1,10 @@
+require 'active_support/refinements/core_ext/module/aliasing'
+require 'active_support/refinements/core_ext/module/introspection'
+require 'active_support/refinements/core_ext/module/anonymous'
+require 'active_support/refinements/core_ext/module/reachable'
+require 'active_support/refinements/core_ext/module/attribute_accessors'
+require 'active_support/refinements/core_ext/module/attr_internal'
+require 'active_support/refinements/core_ext/module/delegation'
+require 'active_support/refinements/core_ext/module/deprecation'
+require 'active_support/refinements/core_ext/module/remove_method'
+require 'active_support/refinements/core_ext/module/qualified_const'

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

@@ -0,0 +1,69 @@
+class Module
+  # Encapsulates the common pattern of:
+  #
+  #   alias_method :foo_without_feature, :foo
+  #   alias_method :foo, :foo_with_feature
+  #
+  # With this, you simply do:
+  #
+  #   alias_method_chain :foo, :feature
+  #
+  # And both aliases are set up for you.
+  #
+  # Query and bang methods (foo?, foo!) keep the same punctuation:
+  #
+  #   alias_method_chain :foo?, :feature
+  #
+  # is equivalent to
+  #
+  #   alias_method :foo_without_feature?, :foo?
+  #   alias_method :foo?, :foo_with_feature?
+  #
+  # so you can safely chain foo, foo?, and foo! with the same feature.
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
+    without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+    when public_method_defined?(without_method)
+      public target
+    when protected_method_defined?(without_method)
+      protected target
+    when private_method_defined?(without_method)
+      private target
+    end
+  end
+
+  # Allows you to make aliases for attributes, which includes
+  # getter, setter, and query methods.
+  #
+  #   class Content < ActiveRecord::Base
+  #     # has a title attribute
+  #   end
+  #
+  #   class Email < Content
+  #     alias_attribute :subject, :title
+  #   end
+  #
+  #   e = Email.find(1)
+  #   e.title    # => "Superstars"
+  #   e.subject  # => "Superstars"
+  #   e.subject? # => true
+  #   e.subject = "Megastars"
+  #   e.title    # => "Megastars"
+  def alias_attribute(new_name, old_name)
+    module_eval <<-STR, __FILE__, __LINE__ + 1
+      def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
+      def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
+      def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
+    STR
+  end
+end

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

@@ -0,0 +1,21 @@
+module ModuleExt; end; module ModuleExt::Anonymous
+refine Module do
+  # A module may or may not have a name.
+  #
+  #   module M; end
+  #   M.name # => "M"
+  #
+  #   m = Module.new
+  #   m.name # => nil
+  #
+  # A module gets a name when it is first assigned to a constant. Either
+  # via the +module+ or +class+ keyword or by an explicit assignment:
+  #
+  #   m = Module.new # creates an anonymous module
+  #   M = m          # => m gets a name here as a side-effect
+  #   m.name         # => "M"
+  def anonymous?
+    name.nil?
+  end
+end
+end