core_ext 0.0.1

data/lib/core_ext/module/introspection.rb

@@ -0,0 +1,62 @@
+require 'core_ext/inflector'
+
+class Module
+  # Returns the name of the module containing this one.
+  #
+  #   M::N.parent_name # => "M"
+  def parent_name
+    if defined? @parent_name
+      @parent_name
+    else
+      @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+    end
+  end
+
+  # Returns the module which contains this one according to its name.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   M::N.parent # => M
+  #   X.parent    # => M
+  #
+  # The parent of top-level and anonymous modules is Object.
+  #
+  #   M.parent          # => Object
+  #   Module.new.parent # => Object
+  def parent
+    parent_name ? CoreExt::Inflector.constantize(parent_name) : Object
+  end
+
+  # Returns all the parents of this module according to its name, ordered from
+  # nested outwards. The receiver is not contained within the result.
+  #
+  #   module M
+  #     module N
+  #     end
+  #   end
+  #   X = M::N
+  #
+  #   M.parents    # => [Object]
+  #   M::N.parents # => [M, Object]
+  #   X.parents    # => [M, Object]
+  def parents
+    parents = []
+    if parent_name
+      parts = parent_name.split('::')
+      until parts.empty?
+        parents << CoreExt::Inflector.constantize(parts * '::')
+        parts.pop
+      end
+    end
+    parents << Object unless parents.include? Object
+    parents
+  end
+
+  def local_constants #:nodoc:
+    constants(false)
+  end
+end

data/lib/core_ext/module/method_transplanting.rb

@@ -0,0 +1,3 @@
+require 'core_ext/deprecation'
+
+CoreExt::Deprecation.warn("This file is deprecated and will be removed in Rails 5.1 with no replacement.")

data/lib/core_ext/module/qualified_const.rb

@@ -0,0 +1,52 @@
+require 'core_ext/string/inflections'
+
+#--
+# Allows code reuse in the methods below without polluting Module.
+#++
+module QualifiedConstUtils
+  def self.raise_if_absolute(path)
+    raise NameError.new("wrong constant name #$&") if path =~ /\A::[^:]+/
+  end
+
+  def self.names(path)
+    path.split('::')
+  end
+end
+
+##
+# Extends the API for constants to be able to deal with qualified names. Arguments
+# are assumed to be relative to the receiver.
+#
+#--
+# Qualified names are required to be relative because we are extending existing
+# methods that expect constant names, ie, relative paths of length 1. For example,
+# Object.const_get('::String') raises NameError and so does qualified_const_get.
+#++
+class Module
+  def qualified_const_defined?(path, search_parents=true)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    QualifiedConstUtils.names(path).inject(self) do |mod, name|
+      return unless mod.const_defined?(name, search_parents)
+      mod.const_get(name)
+    end
+    return true
+  end
+
+  def qualified_const_get(path)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    QualifiedConstUtils.names(path).inject(self) do |mod, name|
+      mod.const_get(name)
+    end
+  end
+
+  def qualified_const_set(path, value)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    const_name = path.demodulize
+    mod_name = path.deconstantize
+    mod = mod_name.empty? ? self : qualified_const_get(mod_name)
+    mod.const_set(const_name, value)
+  end
+end

data/lib/core_ext/module/reachable.rb

@@ -0,0 +1,8 @@
+require 'core_ext/module/anonymous'
+require 'core_ext/string/inflections'
+
+class Module
+  def reachable? #:nodoc:
+    !anonymous? && name.safe_constantize.equal?(self)
+  end
+end

data/lib/core_ext/module/remove_method.rb

@@ -0,0 +1,35 @@
+class Module
+  # Removes the named method, if it exists.
+  def remove_possible_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      undef_method(method)
+    end
+  end
+
+  # Removes the named singleton method, if it exists.
+  def remove_possible_singleton_method(method)
+    singleton_class.instance_eval do
+      remove_possible_method(method)
+    end
+  end
+
+  # Replaces the existing method definition, if there is one, with the passed
+  # block as its body.
+  def redefine_method(method, &block)
+    visibility = method_visibility(method)
+    remove_possible_method(method)
+    define_method(method, &block)
+    send(visibility, method)
+  end
+
+  def method_visibility(method) # :nodoc:
+    case
+    when private_method_defined?(method)
+      :private
+    when protected_method_defined?(method)
+      :protected
+    else
+      :public
+    end
+  end
+end

data/lib/core_ext/module.rb

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

data/lib/core_ext/multibyte/chars.rb

@@ -0,0 +1,231 @@
+require 'core_ext/json'
+require 'core_ext/string/access'
+require 'core_ext/string/behavior'
+require 'core_ext/module/delegation'
+
+module CoreExt #:nodoc:
+  module Multibyte #:nodoc:
+    # Chars enables you to work transparently with UTF-8 encoding in the Ruby
+    # String class without having extensive knowledge about the encoding. A
+    # Chars object accepts a string upon initialization and proxies String
+    # methods in an encoding safe manner. All the normal String methods are also
+    # implemented on the proxy.
+    #
+    # String methods are proxied through the Chars object, and can be accessed
+    # through the +mb_chars+ method. Methods which would normally return a
+    # String object now return a Chars object so methods can be chained.
+    #
+    #   'The Perfect String  '.mb_chars.downcase.strip.normalize # => "the perfect string"
+    #
+    # Chars objects are perfectly interchangeable with String objects as long as
+    # no explicit class checks are made. If certain methods do explicitly check
+    # the class, call +to_s+ before you pass chars objects to them.
+    #
+    #   bad.explicit_checking_method 'T'.mb_chars.downcase.to_s
+    #
+    # The default Chars implementation assumes that the encoding of the string
+    # is UTF-8, if you want to handle different encodings you can write your own
+    # multibyte string handler and configure it through
+    # CoreExt::Multibyte.proxy_class.
+    #
+    #   class CharsForUTF32
+    #     def size
+    #       @wrapped_string.size / 4
+    #     end
+    #
+    #     def self.accepts?(string)
+    #       string.length % 4 == 0
+    #     end
+    #   end
+    #
+    #   CoreExt::Multibyte.proxy_class = CharsForUTF32
+    class Chars
+      include Comparable
+      attr_reader :wrapped_string
+      alias to_s wrapped_string
+      alias to_str wrapped_string
+
+      delegate :<=>, :=~, :acts_like_string?, :to => :wrapped_string
+
+      # Creates a new Chars instance by wrapping _string_.
+      def initialize(string)
+        @wrapped_string = string
+        @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
+      end
+
+      # Forward all undefined methods to the wrapped string.
+      def method_missing(method, *args, &block)
+        result = @wrapped_string.__send__(method, *args, &block)
+        if method.to_s =~ /!$/
+          self if result
+        else
+          result.kind_of?(String) ? chars(result) : result
+        end
+      end
+
+      # Returns +true+ if _obj_ responds to the given method. Private methods
+      # are included in the search only if the optional second parameter
+      # evaluates to +true+.
+      def respond_to_missing?(method, include_private)
+        @wrapped_string.respond_to?(method, include_private)
+      end
+
+      # Returns +true+ when the proxy class can handle the string. Returns
+      # +false+ otherwise.
+      def self.consumes?(string)
+        string.encoding == Encoding::UTF_8
+      end
+
+      # Works just like <tt>String#split</tt>, with the exception that the items
+      # in the resulting list are Chars instances instead of String. This makes
+      # chaining methods easier.
+      #
+      #   'Café périferôl'.mb_chars.split(/é/).map { |part| part.upcase.to_s } # => ["CAF", " P", "RIFERÔL"]
+      def split(*args)
+        @wrapped_string.split(*args).map { |i| self.class.new(i) }
+      end
+
+      # Works like <tt>String#slice!</tt>, but returns an instance of
+      # Chars, or nil if the string was not modified. The string will not be
+      # modified if the range given is out of bounds
+      #
+      #   string = 'Welcome'
+      #   string.mb_chars.slice!(3)    # => #<CoreExt::Multibyte::Chars:0x000000038109b8 @wrapped_string="c">
+      #   string # => 'Welome'
+      #   string.mb_chars.slice!(0..3) # => #<CoreExt::Multibyte::Chars:0x00000002eb80a0 @wrapped_string="Welo">
+      #   string # => 'me'
+      def slice!(*args)
+        string_sliced = @wrapped_string.slice!(*args)
+        if string_sliced
+          chars(string_sliced)
+        end
+      end
+
+      # Reverses all characters in the string.
+      #
+      #   'Café'.mb_chars.reverse.to_s # => 'éfaC'
+      def reverse
+        chars(Unicode.unpack_graphemes(@wrapped_string).reverse.flatten.pack('U*'))
+      end
+
+      # Limits the byte size of the string to a number of bytes without breaking
+      # characters. Usable when the storage for a string is limited for some
+      # reason.
+      #
+      #   'こんにちは'.mb_chars.limit(7).to_s # => "こん"
+      def limit(limit)
+        slice(0...translate_offset(limit))
+      end
+
+      # Converts characters in the string to uppercase.
+      #
+      #   'Laurent, où sont les tests ?'.mb_chars.upcase.to_s # => "LAURENT, OÙ SONT LES TESTS ?"
+      def upcase
+        chars Unicode.upcase(@wrapped_string)
+      end
+
+      # Converts characters in the string to lowercase.
+      #
+      #   'VĚDA A VÝZKUM'.mb_chars.downcase.to_s # => "věda a výzkum"
+      def downcase
+        chars Unicode.downcase(@wrapped_string)
+      end
+
+      # Converts characters in the string to the opposite case.
+      #
+      #    'El Cañón".mb_chars.swapcase.to_s # => "eL cAÑÓN"
+      def swapcase
+        chars Unicode.swapcase(@wrapped_string)
+      end
+
+      # Converts the first character to uppercase and the remainder to lowercase.
+      #
+      #  'über'.mb_chars.capitalize.to_s # => "Über"
+      def capitalize
+        (slice(0) || chars('')).upcase + (slice(1..-1) || chars('')).downcase
+      end
+
+      # Capitalizes the first letter of every word, when possible.
+      #
+      #   "ÉL QUE SE ENTERÓ".mb_chars.titleize    # => "Él Que Se Enteró"
+      #   "日本語".mb_chars.titleize                 # => "日本語"
+      def titleize
+        chars(downcase.to_s.gsub(/\b('?\S)/u) { Unicode.upcase($1)})
+      end
+      alias_method :titlecase, :titleize
+
+      # Returns the KC normalization of the string by default. NFKC is
+      # considered the best normalization form for passing strings to databases
+      # and validations.
+      #
+      # * <tt>form</tt> - The form you want to normalize in. Should be one of the following:
+      #   <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>. Default is
+      #   CoreExt::Multibyte::Unicode.default_normalization_form
+      def normalize(form = nil)
+        chars(Unicode.normalize(@wrapped_string, form))
+      end
+
+      # Performs canonical decomposition on all the characters.
+      #
+      #   'é'.length                         # => 2
+      #   'é'.mb_chars.decompose.to_s.length # => 3
+      def decompose
+        chars(Unicode.decompose(:canonical, @wrapped_string.codepoints.to_a).pack('U*'))
+      end
+
+      # Performs composition on all the characters.
+      #
+      #   'é'.length                       # => 3
+      #   'é'.mb_chars.compose.to_s.length # => 2
+      def compose
+        chars(Unicode.compose(@wrapped_string.codepoints.to_a).pack('U*'))
+      end
+
+      # Returns the number of grapheme clusters in the string.
+      #
+      #   'क्षि'.mb_chars.length   # => 4
+      #   'क्षि'.mb_chars.grapheme_length # => 3
+      def grapheme_length
+        Unicode.unpack_graphemes(@wrapped_string).length
+      end
+
+      # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
+      # resulting in a valid UTF-8 string.
+      #
+      # Passing +true+ will forcibly tidy all bytes, assuming that the string's
+      # encoding is entirely CP1252 or ISO-8859-1.
+      def tidy_bytes(force = false)
+        chars(Unicode.tidy_bytes(@wrapped_string, force))
+      end
+
+      def as_json(options = nil) #:nodoc:
+        to_s.as_json(options)
+      end
+
+      %w(capitalize downcase reverse tidy_bytes upcase).each do |method|
+        define_method("#{method}!") do |*args|
+          @wrapped_string = send(method, *args).to_s
+          self
+        end
+      end
+
+      protected
+
+        def translate_offset(byte_offset) #:nodoc:
+          return nil if byte_offset.nil?
+          return 0   if @wrapped_string == ''
+
+          begin
+            @wrapped_string.byteslice(0...byte_offset).unpack('U*').length
+          rescue ArgumentError
+            byte_offset -= 1
+            retry
+          end
+        end
+
+        def chars(string) #:nodoc:
+          self.class.new(string)
+        end
+    end
+  end
+end