core_ext 0.0.1

data/lib/core_ext/date_time/conversions.rb

@@ -0,0 +1,104 @@
+require 'date'
+require 'core_ext/time/conversions'
+require 'core_ext/date_time/calculations'
+require 'core_ext/time_zone'
+
+class DateTime
+  # 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"
+  #   datetime.to_formatted_s(:iso8601)       # => "2007-12-04T00:00:00+00:00"
+  #
+  # == 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
+
+  # Returns a formatted string of the offset from UTC, or an alternative
+  # string if the time zone is already UTC.
+  #
+  #   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 || CoreExt::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, including fractional microseconds, since the Unix epoch.
+  def to_f
+    seconds_since_unix_epoch.to_f + sec_fraction
+  end
+
+  # Converts +self+ to an integer number of seconds since the Unix epoch.
+  def to_i
+    seconds_since_unix_epoch.to_i
+  end
+
+  # Returns the fraction of a second as microseconds
+  def usec
+    (sec_fraction * 1_000_000).to_i
+  end
+
+  # Returns the fraction of a second as nanoseconds
+  def nsec
+    (sec_fraction * 1_000_000_000).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

data/lib/core_ext/date_time/zones.rb

@@ -0,0 +1,6 @@
+require 'date'
+require 'core_ext/date_and_time/zones'
+
+class DateTime
+  include DateAndTime::Zones
+end

data/lib/core_ext/date_time.rb

@@ -0,0 +1,5 @@
+require 'core_ext/date_time/acts_like'
+require 'core_ext/date_time/blank'
+require 'core_ext/date_time/calculations'
+require 'core_ext/date_time/conversions'
+require 'core_ext/date_time/zones'

data/lib/core_ext/deprecation/behaviors.rb

@@ -0,0 +1,86 @@
+module CoreExt
+  class DeprecationException < StandardError
+  end
+
+  class Deprecation
+    # Default warning behaviors per Rails.env.
+    DEFAULT_BEHAVIORS = {
+      raise: ->(message, callstack) {
+        e = DeprecationException.new(message)
+        e.set_backtrace(callstack)
+        raise e
+      },
+
+      stderr: ->(message, callstack) {
+        $stderr.puts(message)
+        $stderr.puts callstack.join("\n  ") if debug
+      },
+
+      log: ->(message, callstack) {
+        logger =
+            if defined?(Rails.logger) && Rails.logger
+              Rails.logger
+            else
+              require 'active_support/logger'
+              CoreExt::Logger.new($stderr)
+            end
+        logger.warn message
+        logger.debug callstack.join("\n  ") if debug
+      },
+
+      notify: ->(message, callstack) {
+        CoreExt::Notifications.instrument("deprecation.rails",
+                                                :message => message, :callstack => callstack)
+      },
+
+      silence: ->(message, callstack) {},
+    }
+
+    # Behavior module allows to determine how to display deprecation messages.
+    # You can create a custom behavior or set any from the +DEFAULT_BEHAVIORS+
+    # constant. Available behaviors are:
+    #
+    # [+raise+]   Raise <tt>CoreExt::DeprecationException</tt>.
+    # [+stderr+]  Log all deprecation warnings to +$stderr+.
+    # [+log+]     Log all deprecation warnings to +Rails.logger+.
+    # [+notify+]  Use +CoreExt::Notifications+ to notify +deprecation.rails+.
+    # [+silence+] Do nothing.
+    #
+    # Setting behaviors only affects deprecations that happen after boot time.
+    # For more information you can read the documentation of the +behavior=+ method.
+    module Behavior
+      # Whether to print a backtrace along with the warning.
+      attr_accessor :debug
+
+      # Returns the current behavior or if one isn't set, defaults to +:stderr+.
+      def behavior
+        @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
+      end
+
+      # Sets the behavior to the specified value. Can be a single value, array,
+      # or an object that responds to +call+.
+      #
+      # Available behaviors:
+      #
+      # [+raise+]   Raise <tt>CoreExt::DeprecationException</tt>.
+      # [+stderr+]  Log all deprecation warnings to +$stderr+.
+      # [+log+]     Log all deprecation warnings to +Rails.logger+.
+      # [+notify+]  Use +CoreExt::Notifications+ to notify +deprecation.rails+.
+      # [+silence+] Do nothing.
+      #
+      # Setting behaviors only affects deprecations that happen after boot time.
+      # Deprecation warnings raised by gems are not affected by this setting
+      # because they happen before Rails boots up.
+      #
+      #   CoreExt::Deprecation.behavior = :stderr
+      #   CoreExt::Deprecation.behavior = [:stderr, :log]
+      #   CoreExt::Deprecation.behavior = MyCustomHandler
+      #   CoreExt::Deprecation.behavior = ->(message, callstack) {
+      #     # custom stuff
+      #   }
+      def behavior=(behavior)
+        @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || b }
+      end
+    end
+  end
+end

data/lib/core_ext/deprecation/instance_delegator.rb

@@ -0,0 +1,24 @@
+require 'core_ext/kernel/singleton_class'
+require 'core_ext/module/delegation'
+
+module CoreExt
+  class Deprecation
+    module InstanceDelegator # :nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.public_class_method :new
+      end
+
+      module ClassMethods # :nodoc:
+        def include(included_module)
+          included_module.instance_methods.each { |m| method_added(m) }
+          super
+        end
+
+        def method_added(method_name)
+          singleton_class.delegate(method_name, to: :instance)
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/deprecation/method_wrappers.rb

@@ -0,0 +1,70 @@
+require 'core_ext/module/aliasing'
+require 'core_ext/array/extract_options'
+
+module CoreExt
+  class Deprecation
+    module MethodWrapper
+      # Declare that a method has been deprecated.
+      #
+      #   module Fred
+      #     extend self
+      #
+      #     def aaa; end
+      #     def bbb; end
+      #     def ccc; end
+      #     def ddd; end
+      #     def eee; end
+      #   end
+      #
+      # Using the default deprecator:
+      #   CoreExt::Deprecation.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
+      #   # => [:aaa, :bbb, :ccc]
+      #
+      #   Fred.aaa
+      #   # DEPRECATION WARNING: aaa is deprecated and will be removed from Rails 5.0. (called from irb_binding at (irb):10)
+      #   # => nil
+      #
+      #   Fred.bbb
+      #   # DEPRECATION WARNING: bbb is deprecated and will be removed from Rails 5.0 (use zzz instead). (called from irb_binding at (irb):11)
+      #   # => nil
+      #
+      #   Fred.ccc
+      #   # DEPRECATION WARNING: ccc is deprecated and will be removed from Rails 5.0 (use Bar#ccc instead). (called from irb_binding at (irb):12)
+      #   # => nil
+      #
+      # Passing in a custom deprecator:
+      #   custom_deprecator = CoreExt::Deprecation.new('next-release', 'MyGem')
+      #   CoreExt::Deprecation.deprecate_methods(Fred, ddd: :zzz, deprecator: custom_deprecator)
+      #   # => [:ddd]
+      #
+      #   Fred.ddd
+      #   DEPRECATION WARNING: ddd is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):15)
+      #   # => nil
+      #
+      # Using a custom deprecator directly:
+      #   custom_deprecator = CoreExt::Deprecation.new('next-release', 'MyGem')
+      #   custom_deprecator.deprecate_methods(Fred, eee: :zzz)
+      #   # => [:eee]
+      #
+      #   Fred.eee
+      #   DEPRECATION WARNING: eee is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):18)
+      #   # => nil
+      def deprecate_methods(target_module, *method_names)
+        options = method_names.extract_options!
+        deprecator = options.delete(:deprecator) || self
+        method_names += options.keys
+
+        mod = Module.new do
+          method_names.each do |method_name|
+            define_method(method_name) do |*args, &block|
+              deprecator.deprecation_warning(method_name, options[method_name])
+              super(*args, &block)
+            end
+          end
+        end
+
+        target_module.prepend(mod)
+      end
+    end
+  end
+end

data/lib/core_ext/deprecation/proxy_wrappers.rb

@@ -0,0 +1,149 @@
+require 'core_ext/inflector/methods'
+
+module CoreExt
+  class Deprecation
+    class DeprecationProxy #:nodoc:
+      def self.new(*args, &block)
+        object = args.first
+
+        return object unless object
+        super
+      end
+
+      instance_methods.each { |m| undef_method m unless m =~ /^__|^object_id$/ }
+
+      # Don't give a deprecation warning on inspect since test/unit and error
+      # logs rely on it for diagnostics.
+      def inspect
+        target.inspect
+      end
+
+      private
+        def method_missing(called, *args, &block)
+          warn caller_locations, called, args
+          target.__send__(called, *args, &block)
+        end
+    end
+
+    # DeprecatedObjectProxy transforms an object into a deprecated one. It
+    # takes an object, a deprecation message and optionally a deprecator. The
+    # deprecator defaults to +CoreExt::Deprecator+ if none is specified.
+    #
+    #   deprecated_object = CoreExt::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")
+    #   # => #<Object:0x007fb9b34c34b0>
+    #
+    #   deprecated_object.to_s
+    #   DEPRECATION WARNING: This object is now deprecated.
+    #   (Backtrace)
+    #   # => "#<Object:0x007fb9b34c34b0>"
+    class DeprecatedObjectProxy < DeprecationProxy
+      def initialize(object, message, deprecator = CoreExt::Deprecation.instance)
+        @object = object
+        @message = message
+        @deprecator = deprecator
+      end
+
+      private
+        def target
+          @object
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn(@message, callstack)
+        end
+    end
+
+    # DeprecatedInstanceVariableProxy transforms an instance variable into a
+    # deprecated one. It takes an instance of a class, a method on that class
+    # and an instance variable. It optionally takes a deprecator as the last
+    # argument. The deprecator defaults to +CoreExt::Deprecator+ if none
+    # is specified.
+    #
+    #   class Example
+    #     def initialize
+    #       @request = CoreExt::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request)
+    #       @_request = :special_request
+    #     end
+    #
+    #     def request
+    #       @_request
+    #     end
+    #
+    #     def old_request
+    #       @request
+    #     end
+    #   end
+    #
+    #   example = Example.new
+    #   # => #<Example:0x007fb9b31090b8 @_request=:special_request, @request=:special_request>
+    #
+    #   example.old_request.to_s
+    #   # => DEPRECATION WARNING: @request is deprecated! Call request.to_s instead of
+    #      @request.to_s
+    #      (Bactrace information…)
+    #      "special_request"
+    #
+    #   example.request.to_s
+    #   # => "special_request"
+    class DeprecatedInstanceVariableProxy < DeprecationProxy
+      def initialize(instance, method, var = "@#{method}", deprecator = CoreExt::Deprecation.instance)
+        @instance = instance
+        @method = method
+        @var = var
+        @deprecator = deprecator
+      end
+
+      private
+        def target
+          @instance.__send__(@method)
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn("#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}", callstack)
+        end
+    end
+
+    # DeprecatedConstantProxy transforms a constant into a deprecated one. It
+    # takes the names of an old (deprecated) constant and of a new constant
+    # (both in string form) and optionally a deprecator. The deprecator defaults
+    # to +CoreExt::Deprecator+ if none is specified. The deprecated constant
+    # now returns the value of the new one.
+    #
+    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
+    #
+    #   (In a later update, the original implementation of `PLANETS` has been removed.)
+    #
+    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+    #   PLANETS = CoreExt::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+    #
+    #   PLANETS.map { |planet| planet.capitalize }
+    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
+    #        (Bactrace information…)
+    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+    class DeprecatedConstantProxy < DeprecationProxy
+      def initialize(old_const, new_const, deprecator = CoreExt::Deprecation.instance)
+        @old_const = old_const
+        @new_const = new_const
+        @deprecator = deprecator
+      end
+
+      # Returns the class of the new constant.
+      #
+      #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+      #   PLANETS = CoreExt::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+      #   PLANETS.class # => Array
+      def class
+        target.class
+      end
+
+      private
+        def target
+          CoreExt::Inflector.constantize(@new_const.to_s)
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn("#{@old_const} is deprecated! Use #{@new_const} instead.", callstack)
+        end
+    end
+  end
+end

data/lib/core_ext/deprecation/reporting.rb

@@ -0,0 +1,105 @@
+module CoreExt
+  class Deprecation
+    module Reporting
+      # Whether to print a message (silent mode)
+      attr_accessor :silenced
+      # Name of gem where method is deprecated
+      attr_accessor :gem_name
+
+      # Outputs a deprecation warning to the output configured by
+      # <tt>CoreExt::Deprecation.behavior</tt>.
+      #
+      #   CoreExt::Deprecation.warn('something broke!')
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
+      def warn(message = nil, callstack = nil)
+        return if silenced
+
+        callstack ||= caller_locations(2)
+        deprecation_message(callstack, message).tap do |m|
+          behavior.each { |b| b.call(m, callstack) }
+        end
+      end
+
+      # Silence deprecation warnings within the block.
+      #
+      #   CoreExt::Deprecation.warn('something broke!')
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
+      #
+      #   CoreExt::Deprecation.silence do
+      #     CoreExt::Deprecation.warn('something broke!')
+      #   end
+      #   # => nil
+      def silence
+        old_silenced, @silenced = @silenced, true
+        yield
+      ensure
+        @silenced = old_silenced
+      end
+
+      def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
+        caller_backtrace ||= caller_locations(2)
+        deprecated_method_warning(deprecated_method_name, message).tap do |msg|
+          warn(msg, caller_backtrace)
+        end
+      end
+
+      private
+        # Outputs a deprecation warning message
+        #
+        #   CoreExt::Deprecation.deprecated_method_warning(:method_name)
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon}"
+        #   CoreExt::Deprecation.deprecated_method_warning(:method_name, :another_method)
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (use another_method instead)"
+        #   CoreExt::Deprecation.deprecated_method_warning(:method_name, "Optional message")
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (Optional message)"
+        def deprecated_method_warning(method_name, message = nil)
+          warning = "#{method_name} is deprecated and will be removed from #{gem_name} #{deprecation_horizon}"
+          case message
+            when Symbol then "#{warning} (use #{message} instead)"
+            when String then "#{warning} (#{message})"
+            else warning
+          end
+        end
+
+        def deprecation_message(callstack, message = nil)
+          message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
+          message += '.' unless message =~ /\.$/
+          "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
+        end
+
+        def deprecation_caller_message(callstack)
+          file, line, method = extract_callstack(callstack)
+          if file
+            if line && method
+              "(called from #{method} at #{file}:#{line})"
+            else
+              "(called from #{file}:#{line})"
+            end
+          end
+        end
+
+        def extract_callstack(callstack)
+          return _extract_callstack(callstack) if callstack.first.is_a? String
+
+          rails_gem_root = File.expand_path("../../../../..", __FILE__) + "/"
+          offending_line = callstack.find { |frame|
+            frame.absolute_path && !frame.absolute_path.start_with?(rails_gem_root)
+          } || callstack.first
+          [offending_line.path, offending_line.lineno, offending_line.label]
+        end
+
+        def _extract_callstack(callstack)
+          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
+          rails_gem_root = File.expand_path("../../../../..", __FILE__) + "/"
+          offending_line = callstack.find { |line| !line.start_with?(rails_gem_root) } || callstack.first
+          if offending_line
+            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
+              md.captures
+            else
+              offending_line
+            end
+          end
+        end
+    end
+  end
+end

data/lib/core_ext/deprecation.rb

@@ -0,0 +1,43 @@
+require 'singleton'
+
+module CoreExt
+  # \Deprecation specifies the API used by Rails to deprecate methods, instance
+  # variables, objects and constants.
+  class Deprecation
+    # active_support.rb sets an autoload for CoreExt::Deprecation.
+    #
+    # If these requires were at the top of the file the constant would not be
+    # defined by the time their files were loaded. Since some of them reopen
+    # CoreExt::Deprecation its autoload would be triggered, resulting in
+    # a circular require warning for active_support/deprecation.rb.
+    #
+    # So, we define the constant first, and load dependencies later.
+    require 'core_ext/deprecation/instance_delegator'
+    require 'core_ext/deprecation/behaviors'
+    require 'core_ext/deprecation/reporting'
+    require 'core_ext/deprecation/method_wrappers'
+    require 'core_ext/deprecation/proxy_wrappers'
+    require 'core_ext/module/deprecation'
+
+    include Singleton
+    include InstanceDelegator
+    include Behavior
+    include Reporting
+    include MethodWrapper
+
+    # The version number in which the deprecated behavior will be removed, by default.
+    attr_accessor :deprecation_horizon
+
+    # It accepts two parameters on initialization. The first is a version of library
+    # and the second is a library name
+    #
+    #   CoreExt::Deprecation.new('2.0', 'MyLibrary')
+    def initialize(deprecation_horizon = '5.0', gem_name = 'Rails')
+      self.gem_name = gem_name
+      self.deprecation_horizon = deprecation_horizon
+      # By default, warnings are not silenced and debugging is off.
+      self.silenced = false
+      self.debug = false
+    end
+  end
+end

data/lib/core_ext/digest/uuid.rb

@@ -0,0 +1,51 @@
+require 'securerandom'
+
+module Digest
+  module UUID
+    DNS_NAMESPACE  = "k\xA7\xB8\x10\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    URL_NAMESPACE  = "k\xA7\xB8\x11\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+
+    # Generates a v5 non-random UUID (Universally Unique IDentifier).
+    #
+    # Using Digest::MD5 generates version 3 UUIDs; Digest::SHA1 generates version 5 UUIDs.
+    # uuid_from_hash always generates the same UUID for a given name and namespace combination.
+    #
+    # See RFC 4122 for details of UUID at: http://www.ietf.org/rfc/rfc4122.txt
+    def self.uuid_from_hash(hash_class, uuid_namespace, name)
+      if hash_class == Digest::MD5
+        version = 3
+      elsif hash_class == Digest::SHA1
+        version = 5
+      else
+        raise ArgumentError, "Expected Digest::SHA1 or Digest::MD5, got #{hash_class.name}."
+      end
+
+      hash = hash_class.new
+      hash.update(uuid_namespace)
+      hash.update(name)
+
+      ary = hash.digest.unpack('NnnnnN')
+      ary[2] = (ary[2] & 0x0FFF) | (version << 12)
+      ary[3] = (ary[3] & 0x3FFF) | 0x8000
+
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end
+
+    # Convenience method for uuid_from_hash using Digest::MD5.
+    def self.uuid_v3(uuid_namespace, name)
+      self.uuid_from_hash(Digest::MD5, uuid_namespace, name)
+    end
+
+    # Convenience method for uuid_from_hash using Digest::SHA1.
+    def self.uuid_v5(uuid_namespace, name)
+      self.uuid_from_hash(Digest::SHA1, uuid_namespace, name)
+    end
+
+    # Convenience method for SecureRandom.uuid.
+    def self.uuid_v4
+      SecureRandom.uuid
+    end
+  end
+end