hanami-utils 2.0.0.alpha1 → 2.0.0.alpha2

data/lib/hanami/utils/file_list.rb

@@ -6,7 +6,7 @@ module Hanami
     #
     # @since 0.9.0
     module FileList
-      # Return an ordered list of files, consistent across operating systems
+      # Returns an ordered list of files, consistent across operating systems
       #
       # It has the same signature of <tt>Dir.glob</tt>, it just guarantees to
       # order the results before to return them.
@@ -14,8 +14,28 @@ module Hanami
       # @since 0.9.0
       #
       # @see https://ruby-doc.org/core/Dir.html#method-c-glob
+      #
+      # @example simple usage
+      #   require "hanami/utils/file_list"
+      #
+      #   Hanami::Utils::FileList["spec/support/fixtures/file_list/*.rb"]
+      #   # => [
+      #     "spec/support/fixtures/file_list/a.rb",
+      #     "spec/support/fixtures/file_list/aa.rb",
+      #     "spec/support/fixtures/file_list/ab.rb"
+      #   ]
+      #
+      # @example token usage
+      #   require "hanami/utils/file_list"
+      #
+      #   Hanami::Utils::FileList["spec", "support", "fixtures", "file_list", "*.rb"]
+      #   # => [
+      #     "spec/support/fixtures/file_list/a.rb",
+      #     "spec/support/fixtures/file_list/aa.rb",
+      #     "spec/support/fixtures/file_list/ab.rb"
+      #   ]
       def self.[](*args)
-        Dir.glob(*args).sort!
+        Dir.glob(::File.join(*args)).sort!
       end
     end
   end

data/lib/hanami/utils/files.rb

@@ -147,6 +147,7 @@ module Hanami
         mkdir_p(path)
 
         content = ::File.readlines(path)
+        content << "\n" if _append_newline?(content)
         content << "#{contents}\n"
 
         write(path, content)
@@ -307,13 +308,13 @@ module Hanami
       #
       #   # class App
       #   # end
-      def self.remove_block(path, target) # rubocop:disable Metrics/AbcSize
+      def self.remove_block(path, target)
         content  = ::File.readlines(path)
         starting = index(content, path, target)
         line     = content[starting]
         size     = line[/\A[[:space:]]*/].bytesize
         closing  = (" " * size) + (/{/.match?(target) ? "}" : "end")
-        ending   = starting + index(content[starting..-1], path, closing)
+        ending   = starting + index(content[starting..], path, closing)
 
         content.slice!(starting..ending)
         write(path, content)
@@ -435,6 +436,16 @@ module Hanami
       end
 
       private_class_method :line_number
+
+      # @since 1.3.6
+      # @api private
+      def self._append_newline?(content)
+        return false if content.empty?
+
+        !content.last.end_with?("\n")
+      end
+
+      private_class_method :_append_newline?
     end
   end
 end

data/lib/hanami/utils/hash.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "transproc"
+require "dry-transformer"
 
 module Hanami
   module Utils
     # Hash transformations
     # @since 0.1.0
     module Hash
-      extend Transproc::Registry
-      import Transproc::HashTransformations
+      extend Dry::Transformer::Registry
+      import Dry::Transformer::HashTransformations
 
       # Symbolize the given hash
       #
@@ -32,7 +32,7 @@ module Hanami
         self[:symbolize_keys].call(input)
       end
 
-      # Deep symbolize the given hash
+      # Performs deep symbolize on the given hash
       #
       # @param input [::Hash] the input
       #
@@ -54,7 +54,7 @@ module Hanami
         self[:deep_symbolize_keys].call(input)
       end
 
-      # Stringify the given hash
+      # Stringifies the given hash
       #
       # @param input [::Hash] the input
       #
@@ -74,7 +74,7 @@ module Hanami
         self[:stringify_keys].call(input)
       end
 
-      # Deeply stringify the given hash
+      # Deeply stringifies the given hash
       #
       # @param input [::Hash] the input
       #
@@ -90,31 +90,19 @@ module Hanami
       #
       #   hash.class
       #     # => Hash
-      def self.deep_stringify(input) # rubocop:disable Metrics/MethodLength
-        input.each_with_object({}) do |(key, value), output|
-          output[key.to_s] =
-            case value
-            when ::Hash
-              deep_stringify(value)
-            when Array
-              value.map do |item|
-                item.is_a?(::Hash) ? deep_stringify(item) : item
-              end
-            else
-              value
-            end
-        end
+      def self.deep_stringify(input)
+        self[:deep_stringify_keys].call(input)
       end
 
-      # Deep duplicate hash values
+      # Deep duplicates hash values
       #
-      # The output of this function is a shallow duplicate of the input.
+      # The output of this function is a deep duplicate of the input.
       # Any further modification on the input, won't be reflected on the output
       # and viceversa.
       #
       # @param input [::Hash] the input
       #
-      # @return [::Hash] the shallow duplicate of input
+      # @return [::Hash] the deep duplicate of input
       #
       # @since 1.0.1
       #
@@ -144,17 +132,17 @@ module Hanami
       #   input
       #     # => {"a"=>{"b"=>{"c"=>[1,2,3,4]}}}
       def self.deep_dup(input)
-        input.each_with_object({}) do |(k, v), result|
-          result[k] = case v
-                      when ::Hash
-                        deep_dup(v)
-                      else
-                        v.dup
-                      end
+        input.transform_values do |v|
+          case v
+          when ::Hash
+            deep_dup(v)
+          else
+            v.dup
+          end
         end
       end
 
-      # Deep serialize given object into a `Hash`
+      # Deep serializes given object into a `Hash`
       #
       # Please note that the returning `Hash` will use symbols as keys.
       #
@@ -178,7 +166,7 @@ module Hanami
       #
       #   Hanami::Utils::Hash.deep_serialize(input)
       #     # => {:foo=>"bar", :baz=>[{:hello=>"world"}]}
-      def self.deep_serialize(input) # rubocop:disable Metrics/MethodLength
+      def self.deep_serialize(input)
         input.to_hash.each_with_object({}) do |(key, value), output|
           output[key.to_sym] =
             case value

data/lib/hanami/utils/json.rb

@@ -43,7 +43,7 @@ module Hanami
       end
       # rubocop:enable Style/ClassVars
 
-      # Parse the given JSON paylod
+      # Parses the given JSON paylod
       #
       # @param payload [String] a JSON payload
       #

data/lib/hanami/utils/kernel.rb

@@ -9,7 +9,7 @@ require "hanami/utils"
 require "hanami/utils/string"
 
 unless defined?(Boolean)
-  # Define top level constant Boolean, so it can be easily used by other libraries
+  # Defines top level constant Boolean, so it can be easily used by other libraries
   # in coercions DSLs
   #
   # @since 0.3.0
@@ -28,7 +28,7 @@ module Hanami
       # @api private
       #
       # @see Hanami::Utils::Kernel.Integer
-      NUMERIC_MATCHER = %r{\A([\d\/\.\+iE]+|NaN|Infinity)\z}.freeze
+      NUMERIC_MATCHER = %r{\A([\d/.+iE]+|NaN|Infinity)\z}.freeze
 
       # @since 0.8.0
       # @api private
@@ -327,7 +327,7 @@ module Hanami
       #   # big complex represented as a string
       #   input = Complex(2, 3)
       #   Hanami::Utils::Kernel.Integer(input) # => TypeError
-      def self.Integer(arg) # rubocop:disable Metrics/MethodLength
+      def self.Integer(arg)
         super(arg)
       rescue ArgumentError, TypeError, NoMethodError
         begin
@@ -418,7 +418,6 @@ module Hanami
       #   input = BasicObject.new
       #   Hanami::Utils::Kernel.BigDecimal(input) # => TypeError
       #
-      # rubocop:disable Metrics/MethodLength
       def self.BigDecimal(arg, precision = ::Float::DIG)
         case arg
         when NilClass # This is only needed by Ruby 2.6
@@ -435,7 +434,6 @@ module Hanami
       rescue NoMethodError
         raise TypeError.new "can't convert #{inspect_type_error(arg)}into BigDecimal"
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Coerces the argument to be a Float.
       #
@@ -549,7 +547,7 @@ module Hanami
       #   # big complex represented as a string
       #   input = Complex(2, 3)
       #   Hanami::Utils::Kernel.Float(input) # => TypeError
-      def self.Float(arg) # rubocop:disable Metrics/MethodLength
+      def self.Float(arg)
         super(arg)
       rescue ArgumentError, TypeError
         begin
@@ -738,7 +736,8 @@ module Hanami
       #   require 'hanami/utils/kernel'
       #
       #   Hanami::Utils::Kernel.DateTime(3483943)
-      #     # => Time.at(3483943).to_datetime #<DateTime: 1970-02-10T08:45:43+01:00 ((2440628j,27943s,0n),+3600s,2299161j)>
+      #     # => Time.at(3483943).to_datetime
+      #     # #<DateTime: 1970-02-10T08:45:43+01:00 ((2440628j,27943s,0n),+3600s,2299161j)>
       #
       #   Hanami::Utils::Kernel.DateTime(DateTime.now)
       #     # => #<DateTime: 2014-04-18T09:33:49+02:00 ((2456766j,27229s,690849000n),+7200s,2299161j)>
@@ -898,7 +897,7 @@ module Hanami
       #   # Missing #respond_to?
       #   input = BasicObject.new
       #   Hanami::Utils::Kernel.Boolean(input) # => TypeError
-      def self.Boolean(arg) # rubocop:disable Metrics/MethodLength
+      def self.Boolean(arg)
         case arg
         when Numeric
           arg.to_i == BOOLEAN_TRUE_INTEGER
@@ -1023,7 +1022,7 @@ module Hanami
         raise TypeError.new "can't convert #{inspect_type_error(arg)}into Symbol"
       end
 
-      # Check if the given argument is a string representation of a number
+      # Checks if the given argument is a string representation of a number
       #
       # @param arg [Object] the input
       #
@@ -1044,11 +1043,11 @@ module Hanami
       # @since 0.4.3
       # @api private
       def self.inspect_type_error(arg)
-        (arg.respond_to?(:inspect) ? arg.inspect : arg.to_s) << " "
-      rescue NoMethodError => _
+        "#{(arg.respond_to?(:inspect) ? arg.inspect : arg.to_s)} "
+      rescue NoMethodError
         # missing the #respond_to? method, fall back to returning the class' name
         begin
-          arg.class.name << " instance "
+          "#{arg.class.name} instance "
         rescue NoMethodError
           # missing the #class method, can't fall back to anything better than nothing
           # Callers will have to guess from their code
@@ -1057,7 +1056,7 @@ module Hanami
       end
 
       class << self
-        private :inspect_type_error # rubocop:disable Style/AccessModifierDeclarations
+        private :inspect_type_error
       end
     end
   end

data/lib/hanami/utils/load_paths.rb

@@ -50,7 +50,7 @@ module Hanami
         @paths = original.instance_variable_get(:@paths).dup
       end
 
-      # Iterates thru the collection and yields the given block.
+      # Iterates through the collection and yields the given block.
       # It skips duplications and raises an error in case one of the paths
       # doesn't exist.
       #
@@ -117,7 +117,7 @@ module Hanami
         self
       end
 
-      alias << push
+      alias_method :<<, :push
 
       # It freezes the object by preventing further modifications.
       #
@@ -158,7 +158,7 @@ module Hanami
 
       private
 
-      # Allow subclasses to define their own policy to discover the realpath
+      # Allows subclasses to define their own policy to discover the realpath
       # of the given path.
       #
       # @since 0.2.0

data/lib/hanami/utils/path_prefix.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/utils/string"
 require "hanami/utils/kernel"
 
 module Hanami
@@ -8,7 +7,7 @@ module Hanami
     # Prefixed string
     #
     # @since 0.1.0
-    class PathPrefix < Hanami::Utils::String
+    class PathPrefix
       # Path separator
       #
       # @since 0.3.1
@@ -26,7 +25,7 @@ module Hanami
       #
       # @see Hanami::Utils::PathPrefix::DEFAULT_SEPARATOR
       def initialize(string = nil, separator = DEFAULT_SEPARATOR)
-        super(string)
+        @string = string.to_s
         @separator = separator
       end
 
@@ -93,6 +92,37 @@ module Hanami
         ).relative!
       end
 
+      # Returns the hash of the internal string
+      #
+      # @return [Integer]
+      #
+      # @since 0.3.0
+      def hash
+        @string.hash
+      end
+
+      # Returns a string representation
+      #
+      # @return [::String]
+      #
+      # @since 0.3.0
+      def to_s
+        @string
+      end
+
+      alias_method :to_str, :to_s
+
+      # Equality
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @since 0.3.0
+      def ==(other)
+        to_s == other
+      end
+
+      alias_method :eql?, :==
+
       protected
 
       # Modifies the path prefix to have a prepended separator.

data/lib/hanami/utils/query_string.rb

@@ -12,7 +12,7 @@ module Hanami
       # @api private
       HASH_SEPARATOR = ","
 
-      # Serialize input into a query string
+      # Serializes input into a query string
       #
       # @param input [Object] the input
       #

data/lib/hanami/utils/shell_color.rb

@@ -18,22 +18,22 @@ module Hanami
         end
       end
 
-      # Escape codes for terminals to output strings in colors
+      # Escapes codes for terminals to output strings in colors
       #
       # @since 1.2.0
       # @api private
       COLORS = ::Hash[
-        black:   30,
-        red:     31,
-        green:   32,
-        yellow:  33,
-        blue:    34,
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
         magenta: 35,
-        cyan:    36,
-        gray:    37,
+        cyan: 36,
+        gray: 37,
       ].freeze
 
-      # Colorize output
+      # Colorizes output
       # 8 colors available: black, red, green, yellow, blue, magenta, cyan, and gray
       #
       # @param input [#to_s] the string to colorize

data/lib/hanami/utils/string.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "transproc"
+require "dry/transformer"
 require "concurrent/map"
 
 module Hanami
   module Utils
-    # String on steroids
+    # String utilities
     #
     # @since 0.1.0
-    class String # rubocop:disable Metrics/ClassLength
+    module String
       # Empty string for #classify
       #
       # @since 0.6.0
@@ -27,18 +27,6 @@ module Hanami
       # @api private
       CLASSIFY_SEPARATOR  = "_"
 
-      # Regexp for #tokenize
-      #
-      # @since 0.3.0
-      # @api private
-      TOKENIZE_REGEXP     = /\((.*)\)/.freeze
-
-      # Separator for #tokenize
-      #
-      # @since 0.3.0
-      # @api private
-      TOKENIZE_SEPARATOR  = "|"
-
       # Separator for #underscore
       #
       # @since 0.3.0
@@ -73,16 +61,16 @@ module Hanami
       #
       # @since 0.3.4
       # @api private
-      CLASSIFY_WORD_SEPARATOR = /#{CLASSIFY_SEPARATOR}|#{NAMESPACE_SEPARATOR}|#{UNDERSCORE_SEPARATOR}|#{DASHERIZE_SEPARATOR}/.freeze
+      CLASSIFY_WORD_SEPARATOR = /#{CLASSIFY_SEPARATOR}|#{NAMESPACE_SEPARATOR}|#{UNDERSCORE_SEPARATOR}|#{DASHERIZE_SEPARATOR}/.freeze # rubocop:disable Layout/LineLength
 
       @__transformations__ = Concurrent::Map.new
 
-      extend Transproc::Registry
-      extend Transproc::Composer
+      extend Dry::Transformer::Registry
 
-      # Apply the given transformation(s) to `input`
+      # Applies the given transformation(s) to `input`
       #
-      # It performs a pipeline of transformations, by applying the given functions from `Hanami::Utils::String` and `::String`.
+      # It performs a pipeline of transformations, by applying the given
+      # functions from `Hanami::Utils::String` and `::String`.
       # The transformations are applied in the given order.
       #
       # It doesn't mutate the input, unless you use destructive methods from `::String`
@@ -130,42 +118,31 @@ module Hanami
       #   Hanami::Utils::String.transform("Cherry", -> { "blossom" }))
       #     # => ArgumentError: wrong number of arguments (given 1, expected 0)
       #
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/MethodLength
       def self.transform(input, *transformations)
         fn = @__transformations__.fetch_or_store(transformations.hash) do
-          compose do |fns|
-            transformations.each do |transformation, *args|
-              fns << if transformation.is_a?(Proc)
-                       transformation
-                     elsif contain?(transformation)
-                       self[transformation, *args]
-                     elsif input.respond_to?(transformation)
-                       t(:bind, input, ->(i) { i.public_send(transformation, *args) })
-                     else
-                       raise NoMethodError.new(%(undefined method `#{transformation.inspect}' for #{input.inspect}:#{input.class}))
-                     end
-            end
+          fns = Dry::Transformer::Function.new(->(object) { object })
+
+          transformations.each do |transformation, *args|
+            fns = fns.compose(
+              if transformation.is_a?(Proc)
+                transformation
+              elsif contain?(transformation)
+                self[transformation, *args]
+              elsif input.respond_to?(transformation)
+                ->(i) { i.public_send(transformation, *args) }
+              else
+                raise NoMethodError.new(%(undefined method `#{transformation.inspect}' for #{input.inspect}:#{input.class})) # rubocop:disable Layout/LineLength
+              end
+            )
           end
+
+          fns
         end
 
         fn.call(input)
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/AbcSize
 
-      # Extracted from `transproc` source code
-      #
-      # `transproc` is Copyright 2014 by Piotr Solnica (piotr.solnica@gmail.com),
-      # released under the MIT License
-      #
-      # @since 1.1.0
-      # @api private
-      def self.bind(value, binding, fun)
-        binding.instance_exec(value, &fun)
-      end
-
-      # Return a titleized version of the string
+      # Returns a titleized version of the string
       #
       # @param input [::String] the input
       #
@@ -182,7 +159,7 @@ module Hanami
         underscore(string).split(CLASSIFY_SEPARATOR).map(&:capitalize).join(TITLEIZE_SEPARATOR)
       end
 
-      # Return a capitalized version of the string
+      # Returns a capitalized version of the string
       #
       # @param input [::String] the input
       #
@@ -209,7 +186,7 @@ module Hanami
         tail.unshift(head.capitalize).join(CAPITALIZE_SEPARATOR)
       end
 
-      # Return a CamelCase version of the string
+      # Returns a CamelCase version of the string
       #
       # @param input [::String] the input
       #
@@ -233,7 +210,7 @@ module Hanami
         words.zip(delimiters).join
       end
 
-      # Return a downcased and underscore separated version of the string
+      # Returns a downcased and underscore separated version of the string
       #
       # Revised version of `ActiveSupport::Inflector.underscore` implementation
       # @see https://github.com/rails/rails/blob/feaa6e2048fe86bcf07e967d6e47b865e42e055b/activesupport/lib/active_support/inflector/methods.rb#L90
@@ -254,11 +231,11 @@ module Hanami
         string.gsub!(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
         string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
         string.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
-        string.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
+        string.gsub!(/[[:space:]]|-/, UNDERSCORE_DIVISION_TARGET)
         string.downcase
       end
 
-      # Return a downcased and dash separated version of the string
+      # Returns a downcased and dash separated version of the string
       #
       # @param input [::String] the input
       #
@@ -279,7 +256,7 @@ module Hanami
         underscore(string).split(CLASSIFY_SEPARATOR).join(DASHERIZE_SEPARATOR)
       end
 
-      # Return the string without the Ruby namespace of the class
+      # Returns the string without the Ruby namespace of the class
       #
       # @param input [::String] the input
       #
@@ -297,7 +274,7 @@ module Hanami
         ::String.new(input.to_s).split(NAMESPACE_SEPARATOR).last
       end
 
-      # Return the top level namespace name
+      # Returns the top level namespace name
       #
       # @param input [::String] the input
       #
@@ -336,7 +313,7 @@ module Hanami
       #     # => 'authors/books#index'
       def self.rsub(input, pattern, replacement)
         string = ::String.new(input.to_s)
-        if i = string.rindex(pattern) # rubocop:disable Lint/AssignmentInCondition
+        if i = string.rindex(pattern)
           s = string.dup
           s[i] = replacement
           s
@@ -344,344 +321,6 @@ module Hanami
           string
         end
       end
-
-      # Initialize the string
-      #
-      # @param string [::String, Symbol] the value we want to initialize
-      #
-      # @return [Hanami::Utils::String] self
-      #
-      # @since 0.1.0
-      # @deprecated
-      def initialize(string)
-        @string = string.to_s
-      end
-
-      # Return a titleized version of the string
-      #
-      # @return [Hanami::Utils::String] the transformed string
-      #
-      # @since 0.4.0
-      # @deprecated Use {Hanami::Utils::String.titleize}
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'hanami utils'
-      #   string.titleize # => "Hanami Utils"
-      def titleize
-        self.class.new underscore.split(CLASSIFY_SEPARATOR).map(&:capitalize).join(TITLEIZE_SEPARATOR)
-      end
-
-      # Return a capitalized version of the string
-      #
-      # @return [Hanami::Utils::String] the transformed string
-      #
-      # @since 0.5.2
-      # @deprecated Use {Hanami::Utils::String.capitalize}
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'hanami'
-      #   string.capitalize # => "Hanami"
-      #
-      #   string = Hanami::Utils::String.new 'hanami utils'
-      #   string.capitalize # => "Hanami utils"
-      #
-      #   string = Hanami::Utils::String.new 'Hanami Utils'
-      #   string.capitalize # => "Hanami utils"
-      #
-      #   string = Hanami::Utils::String.new 'hanami_utils'
-      #   string.capitalize # => "Hanami utils"
-      #
-      #   string = Hanami::Utils::String.new 'hanami-utils'
-      #   string.capitalize # => "Hanami utils"
-      def capitalize
-        head, *tail = underscore.split(CLASSIFY_SEPARATOR)
-
-        self.class.new(
-          tail.unshift(head.capitalize).join(CAPITALIZE_SEPARATOR)
-        )
-      end
-
-      # Return a CamelCase version of the string
-      #
-      # @return [Hanami::Utils::String] the transformed string
-      #
-      # @since 0.1.0
-      # @deprecated Use {Hanami::Utils::String.classify}
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'hanami_utils'
-      #   string.classify # => 'HanamiUtils'
-      def classify
-        words = underscore.split(CLASSIFY_WORD_SEPARATOR).map!(&:capitalize)
-        delimiters = underscore.scan(CLASSIFY_WORD_SEPARATOR)
-
-        delimiters.map! do |delimiter|
-          delimiter == CLASSIFY_SEPARATOR ? EMPTY_STRING : NAMESPACE_SEPARATOR
-        end
-
-        self.class.new words.zip(delimiters).join
-      end
-
-      # Return a downcased and underscore separated version of the string
-      #
-      # Revised version of `ActiveSupport::Inflector.underscore` implementation
-      # @see https://github.com/rails/rails/blob/feaa6e2048fe86bcf07e967d6e47b865e42e055b/activesupport/lib/active_support/inflector/methods.rb#L90
-      #
-      # @return [Hanami::Utils::String] the transformed string
-      # @deprecated Use {Hanami::Utils::String.underscore}
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'HanamiUtils'
-      #   string.underscore # => 'hanami_utils'
-      def underscore
-        new_string = gsub(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)
-        new_string.gsub!(/([A-Z\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)
-        new_string.gsub!(/([a-z\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)
-        new_string.gsub!(/[[:space:]]|\-/, UNDERSCORE_DIVISION_TARGET)
-        new_string.downcase!
-        self.class.new new_string
-      end
-
-      # Return a downcased and dash separated version of the string
-      #
-      # @return [Hanami::Utils::String] the transformed string
-      #
-      # @since 0.4.0
-      # @deprecated Use {Hanami::Utils::String.dasherize}
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'Hanami Utils'
-      #   string.dasherize # => 'hanami-utils'
-      #
-      #   string = Hanami::Utils::String.new 'hanami_utils'
-      #   string.dasherize # => 'hanami-utils'
-      #
-      #   string = Hanami::Utils::String.new 'HanamiUtils'
-      #   string.dasherize # => "hanami-utils"
-      def dasherize
-        self.class.new underscore.split(CLASSIFY_SEPARATOR).join(DASHERIZE_SEPARATOR)
-      end
-
-      # Return the string without the Ruby namespace of the class
-      #
-      # @return [Hanami::Utils::String] the transformed string
-      #
-      # @since 0.1.0
-      # @deprecated Use {Hanami::Utils::String.demodulize}
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'Hanami::Utils::String'
-      #   string.demodulize # => 'String'
-      #
-      #   string = Hanami::Utils::String.new 'String'
-      #   string.demodulize # => 'String'
-      def demodulize
-        self.class.new split(NAMESPACE_SEPARATOR).last
-      end
-
-      # Return the top level namespace name
-      #
-      # @return [Hanami::Utils::String] the transformed string
-      #
-      # @since 0.1.2
-      # @deprecated Use {Hanami::Utils::String.namespace}
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'Hanami::Utils::String'
-      #   string.namespace # => 'Hanami'
-      #
-      #   string = Hanami::Utils::String.new 'String'
-      #   string.namespace # => 'String'
-      def namespace
-        self.class.new split(NAMESPACE_SEPARATOR).first
-      end
-
-      # It iterates through the tokens and calls the given block.
-      # A token is a substring wrapped by `()` and separated by `|`.
-      #
-      # @yield the block that is called for each token.
-      #
-      # @return [void]
-      #
-      # @since 0.1.0
-      # @deprecated
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new 'Hanami::(Utils|App)'
-      #   string.tokenize do |token|
-      #     puts token
-      #   end
-      #
-      #   # =>
-      #     'Hanami::Utils'
-      #     'Hanami::App'
-      #
-      # rubocop:disable Metrics/MethodLength
-      def tokenize
-        if match = TOKENIZE_REGEXP.match(@string) # rubocop:disable Lint/AssignmentInCondition
-          pre  = match.pre_match
-          post = match.post_match
-          tokens = match[1].split(TOKENIZE_SEPARATOR)
-          tokens.each do |token|
-            yield(self.class.new("#{pre}#{token}#{post}"))
-          end
-        else
-          yield(self.class.new(@string))
-        end
-
-        nil
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      # Returns the hash of the internal string
-      #
-      # @return [Integer]
-      #
-      # @since 0.3.0
-      # @deprecated
-      def hash
-        @string.hash
-      end
-
-      # Returns a string representation
-      #
-      # @return [::String]
-      #
-      # @since 0.3.0
-      # @deprecated
-      def to_s
-        @string
-      end
-
-      alias to_str to_s
-
-      # Equality
-      #
-      # @return [TrueClass,FalseClass]
-      #
-      # @since 0.3.0
-      # @deprecated
-      def ==(other)
-        to_s == other
-      end
-
-      alias eql? ==
-
-      # Split the string with the given pattern
-      #
-      # @return [Array<::String>]
-      #
-      # @see http://www.ruby-doc.org/core/String.html#method-i-split
-      #
-      # @since 0.3.0
-      # @deprecated
-      def split(pattern, limit = 0)
-        @string.split(pattern, limit)
-      end
-
-      # Replace the given pattern with the given replacement
-      #
-      # @return [::String]
-      #
-      # @see http://www.ruby-doc.org/core/String.html#method-i-gsub
-      #
-      # @since 0.3.0
-      # @deprecated
-      def gsub(pattern, replacement = nil, &blk)
-        if block_given?
-          @string.gsub(pattern, &blk)
-        else
-          @string.gsub(pattern, replacement)
-        end
-      end
-
-      # Iterate through the string, matching the pattern.
-      # Either return all those patterns, or pass them to the block.
-      #
-      # @return [Array<::String>]
-      #
-      # @see http://www.ruby-doc.org/core/String.html#method-i-scan
-      #
-      # @since 0.6.0
-      # @deprecated
-      def scan(pattern, &blk)
-        @string.scan(pattern, &blk)
-      end
-
-      # Replace the rightmost match of `pattern` with `replacement`
-      #
-      # If the pattern cannot be matched, it returns the original string.
-      #
-      # This method does NOT mutate the original string.
-      #
-      # @param pattern [Regexp, String] the pattern to find
-      # @param replacement [String, Hanami::Utils::String] the string to replace
-      #
-      # @return [Hanami::Utils::String] the replaced string
-      #
-      # @since 0.6.0
-      # @deprecated Use {Hanami::Utils::String.rsub}
-      #
-      # @example
-      #   require 'hanami/utils/string'
-      #
-      #   string = Hanami::Utils::String.new('authors/books/index')
-      #   result = string.rsub(/\//, '#')
-      #
-      #   puts string
-      #     # => #<Hanami::Utils::String:0x007fdb41233ad8 @string="authors/books/index">
-      #
-      #   puts result
-      #     # => #<Hanami::Utils::String:0x007fdb41232ed0 @string="authors/books#index">
-      def rsub(pattern, replacement)
-        if i = rindex(pattern) # rubocop:disable Lint/AssignmentInCondition
-          s    = @string.dup
-          s[i] = replacement
-          self.class.new s
-        else
-          self
-        end
-      end
-
-      # Override Ruby's method_missing in order to provide ::String interface
-      #
-      # @api private
-      # @since 0.3.0
-      #
-      # @raise [NoMethodError] If doesn't respond to the given method
-      def method_missing(method_name, *args, &blk)
-        raise NoMethodError.new(%(undefined method `#{method_name}' for "#{@string}":#{self.class})) unless respond_to?(method_name)
-
-        s = @string.__send__(method_name, *args, &blk)
-        s = self.class.new(s) if s.is_a?(::String)
-        s
-      end
-
-      # Override Ruby's respond_to_missing? in order to support ::String interface
-      #
-      # @api private
-      # @since 0.3.0
-      def respond_to_missing?(method_name, include_private = false)
-        @string.respond_to?(method_name, include_private)
-      end
     end
   end
 end