babosa 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 63fa1835d7bbc606c85b2c8315e8619c37bc7703
-  data.tar.gz: 4b0f3a169ed08de3a1614026e58fbc0dc00e58bc
+SHA256:
+  metadata.gz: 84fa74468828d44925314cc1bcf6d297aa3a94ebfd993bca491686c92c936667
+  data.tar.gz: 618a52e9d52878fe8bc5933879115d32dd31b212a9cd2178e78bb7320d186c43
 SHA512:
-  metadata.gz: 8581a919789c35ab9fe3c077190dcb93a20da9b0ed5ebf05cb7342fb2c4c9eeb8181e3d93850fd7564f31e95cd0195274f24e2fde938c7e6c9027aa02a4ccd15
-  data.tar.gz: 6a86041c30dcd1cdbf5a39b1d2f319425656e57135856aa90a32fffd181fe85748676f74fbb25254294f8d8c6c63f1574b087a32f1d2d112ce84ae40f932c8b4
+  metadata.gz: d8d86867859c5af0f8f80631b5d7aefe14cf87d61ec5908fa08d68fa38cc2e287c77c2c59c41377eb41e6524ba723ed511d1d09e5837259aad4a1ced7162c25a
+  data.tar.gz: 005dbd796a469420ddc905e2fcf4261703f3777ab29000102039e52b907d51d51c3ab69f11779bfc3e76ed19c24fad997733d008c7d08f50dc1446fa230b7e3d

data/Changelog.md

@@ -1,5 +1,25 @@
 # Babosa Changelog
 
+## 2.0.0
+
+This release contains no important changes. I had a week off from work and
+decided to refactor the code.  However there are some small breaking changes so
+I have released it as 2.0.0.
+
+* Refactor internals for simplicity
+* Use built-in Ruby UTF-8 support in places of other gems.
+* Drop support for Ruby < 2.5.0.
+* `Babosa::Identifier#word_chars` no longer removes dashes
+* `Babosa::Identifier#to_ruby_method` default argument `allow_bangs` is now a keyword argument
+
+## 1.0.4
+
+* Fix nil being cast to frozen string (https://github.com/norman/babosa/pull/52)
+
+## 1.0.3
+
+* Fix Active Support 6 deprecations (https://github.com/norman/babosa/pull/50)
+
 ## 1.0.2
 
 * Fix regression in ActiveSupport UTF8 proxy.

data/README.md

@@ -1,7 +1,6 @@
 # Babosa
 
-[![Build Status](https://travis-ci.org/norman/babosa.png?branch=master)](https://travis-ci.org/norman/babosa)
-
+[![Build Status](https://github.com/norman/babosa/actions/workflows/main.yml/badge.svg)](https://github.com/norman/babosa/actions)
 
 Babosa is a library for creating human-friendly identifiers, aka "slugs". It can
 also be useful for normalizing and sanitizing data.
@@ -15,12 +14,16 @@ FriendlyId.
 
 ### Transliterate UTF-8 characters to ASCII
 
-    "Gölcük, Turkey".to_slug.transliterate.to_s #=> "Golcuk, Turkey"
+```ruby
+"Gölcük, Turkey".to_slug.transliterate.to_s #=> "Golcuk, Turkey"
+```
 
 ### Locale sensitive transliteration, with support for many languages
 
-    "Jürgen Müller".to_slug.transliterate.to_s           #=> "Jurgen Muller"
-    "Jürgen Müller".to_slug.transliterate(:german).to_s  #=> "Juergen Mueller"
+```ruby
+"Jürgen Müller".to_slug.transliterate.to_s           #=> "Jurgen Muller"
+"Jürgen Müller".to_slug.transliterate(:german).to_s  #=> "Juergen Mueller"
+```
 
 Currently supported languages include:
 
@@ -28,6 +31,7 @@ Currently supported languages include:
 * Danish
 * German
 * Greek
+* Hindi
 * Macedonian
 * Norwegian
 * Romanian
@@ -35,124 +39,125 @@ Currently supported languages include:
 * Serbian
 * Spanish
 * Swedish
+* Turkish
 * Ukrainian
+* Vietnamese
+
+Additionally there are generic transliterators for transliterating from the
+Cyrillic alphabet and Latin alphabet with diacritics. The Latin transliterator
+can be used, for example, with Czech. There is also a transliterator named
+"Hindi" which may be sufficient for other Indic languages using Devanagari, but
+I do not know enough to say whether the transliterations would make sense.
 
 I'll gladly accept contributions from fluent speakers to support more languages.
 
 ### Strip non-ASCII characters
 
-    "Gölcük, Turkey".to_slug.to_ascii.to_s #=> "Glck, Turkey"
+```ruby
+"Gölcük, Turkey".to_slug.to_ascii.to_s #=> "Glck, Turkey"
+```
 
 ### Truncate by characters
 
-    "üüü".to_slug.truncate(2).to_s #=> "üü"
+```ruby
+"üüü".to_slug.truncate(2).to_s #=> "üü"
+```
 
 ### Truncate by bytes
 
 This can be useful to ensure the generated slug will fit in a database column
 whose length is limited by bytes rather than UTF-8 characters.
 
-    "üüü".to_slug.truncate_bytes(2).to_s #=> "ü"
+```ruby
+"üüü".to_slug.truncate_bytes(2).to_s #=> "ü"
+```
 
 ### Remove punctuation chars
 
-    "this is, um, **really** cool, huh?".to_slug.word_chars.to_s #=> "this is um really cool huh"
+```ruby
+"this is, um, **really** cool, huh?".to_slug.word_chars.to_s #=> "this is um really cool huh"
+```
 
 ### All-in-one
 
-    "Gölcük, Turkey".to_slug.normalize.to_s #=> "golcuk-turkey"
+```ruby
+"Gölcük, Turkey".to_slug.normalize.to_s #=> "golcuk-turkey"
+```
 
 ### Other stuff
 
-#### Using Babosa With FriendlyId 4
-
-    require "babosa"
-
-    class Person < ActiveRecord::Base
-      friendly_id :name, use: :slugged
-
-      def normalize_friendly_id(input)
-        input.to_s.to_slug.normalize(transliterations: :russian).to_s
-      end
-    end
-
-#### Pedantic UTF-8 support
+#### Using Babosa With FriendlyId 4+
 
-Babosa goes out of its way to handle [nasty Unicode issues you might never think
-you would have](https://github.com/norman/enc/blob/master/equivalence.rb) by
-checking, sanitizing and normalizing your string input.
+```ruby
+require "babosa"
 
-It will automatically use whatever Unicode library you have loaded before
-Babosa, or fall back to a simple built-in library. Supported
-Unicode libraries include:
+class Person < ActiveRecord::Base
+  friendly_id :name, use: :slugged
 
-* Java (only on JRuby of course)
-* Active Support
-* [Unicode](https://github.com/blackwinter/unicode)
-* Built-in
+  def normalize_friendly_id(input)
+    input.to_s.to_slug.normalize(transliterations: :russian).to_s
+  end
+end
+```
 
-This built-in module is much faster than Active Support but much slower than
-Java or Unicode. It can only do **very** naive Unicode composition to ensure
-that, for example, "é" will always be composed to a single codepoint rather than
-an "e" and a "´" - making it safe to use as a hash key.
+#### UTF-8 support
 
-But seriously - save yourself the headache and install a real Unicode library.
-If you are using Babosa with a language that uses the Cyrillic alphabet, Babosa
-requires either Unicode, Active Support or Java.
+Babosa normalizes all input strings [to NFC](https://en.wikipedia.org/wiki/Unicode_equivalence#Normal_forms).
 
 #### Ruby Method Names
 
-Babosa can also generate strings for Ruby method names. (Yes, Ruby 1.9 can use
+Babosa can generate strings for Ruby method names. (Yes, Ruby 1.9+ can use
 UTF-8 chars in method names, but you may not want to):
 
 
-    "this is a method".to_slug.to_ruby_method! #=> this_is_a_method
-    "über cool stuff!".to_slug.to_ruby_method! #=> uber_cool_stuff!
+```ruby
+"this is a method".to_slug.to_ruby_method! #=> this_is_a_method
+"über cool stuff!".to_slug.to_ruby_method! #=> uber_cool_stuff!
 
-    # You can also disallow trailing punctuation chars
-    "über cool stuff!".to_slug.to_ruby_method(false) #=> uber_cool_stuff
+# You can also disallow trailing punctuation chars
+"über cool stuff!".to_slug.to_ruby_method(allow_bangs: false) #=> uber_cool_stuff
+```
 
 #### Easy to Extend
 
 You can add custom transliterators for your language with very little code. For
 example here's the transliterator for German:
 
-    # encoding: utf-8
-    module Babosa
-      module Transliterator
-        class German < Latin
-          APPROXIMATIONS = {
-            "ä" => "ae",
-            "ö" => "oe",
-            "ü" => "ue",
-            "Ä" => "Ae",
-            "Ö" => "Oe",
-            "Ü" => "Ue"
-          }
-        end
-      end
+```ruby
+module Babosa
+  module Transliterator
+    class German < Latin
+      APPROXIMATIONS = {
+        "ä" => "ae",
+        "ö" => "oe",
+        "ü" => "ue",
+        "Ä" => "Ae",
+        "Ö" => "Oe",
+        "Ü" => "Ue"
+      }
     end
+  end
+end
+```
 
 And a spec (you can use this as a template):
 
-    # encoding: utf-8
-    require File.expand_path("../../spec_helper", __FILE__)
+```ruby
+require "spec_helper"
 
-    describe Babosa::Transliterator::German do
+describe Babosa::Transliterator::German do
+  let(:t) { described_class.instance }
+  it_behaves_like "a latin transliterator"
 
-      let(:t) { described_class.instance }
-      it_behaves_like "a latin transliterator"
-
-      it "should transliterate Eszett" do
-        t.transliterate("ß").should eql("ss")
-      end
-
-      it "should transliterate vowels with umlauts" do
-        t.transliterate("üöä").should eql("ueoeae")
-      end
-
-    end
+  it "should transliterate Eszett" do
+    t.transliterate("ß").should eql("ss")
+  end
 
+  it "should transliterate vowels with umlauts" do
+    t.transliterate("üöä").should eql("ueoeae")
+  end
+end
+```
 
 ### Rails 3.x and higher
 
@@ -167,46 +172,6 @@ and
 [parameterize](http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize)
 to see if they suit your needs.
 
-### Babosa vs. Stringex
-
-Babosa provides much of the functionality provided by the
-[Stringex](https://github.com/rsl/stringex) gem, but in the subjective opinion
-of the author, is for most use cases a better choice.
-
-#### Fewer Features
-
-Stringex offers functionality for storing slugs in an Active Record model, like
-a simple version of [FriendlyId](http://github.com/norman/friendly_id), in
-addition to string processing. Babosa only does string processing.
-
-#### Less Aggressive Unicode Transliteration
-
-Stringex uses an agressive Unicode to ASCII mapping which outputs gibberish for
-almost anything but Western European langages and Mandarin Chinese. Babosa
-supports only languages for which fluent speakers have provided
-transliterations, to ensure that the output makes sense to users.
-
-#### Unicode Support
-
-Stringex does no Unicode normalization or validation before transliterating
-strings, so if you pass in strings with encoding errors or with different
-Unicode normalizations, you'll get unpredictable results.
-
-#### No Locale Assumptions
-
-Babosa avoids making assumptions about locales like Stringex does, so it doesn't
-offer transliterations like this out of the box:
-
-    "$12 worth of Ruby power".to_url => "12-dollars-worth-of-ruby-power"
-
-This is because the symbol "$" is used in many Latin American countries for the
-peso. Stringex does this in many places, for example, transliterating all Han
-characters into Pinyin, effectively treating Japanese text as if it were
-Mandarin Chinese.
-
-
-### More info
-
 Please see the [API docs](http://rubydoc.info/github/norman/babosa/master/frames) and source code for
 more info.
 
@@ -218,9 +183,6 @@ Babosa can be installed via Rubygems:
 
 You can get the source code from its [Github repository](http://github.com/norman/babosa).
 
-Babosa is tested to be compatible with Ruby 1.8.7-2.0.0, JRuby 1.4+, and
-Rubinius 1.0+ It's probably compatible with other Rubies as well.
-
 ## Reporting bugs
 
 Please use Babosa's [Github issue
@@ -229,7 +191,7 @@ tracker](http://github.com/norman/babosa/issues).
 
 ## Misc
 
-"Babosa" means slug in Spanish.
+"Babosa" means "slug" in Spanish.
 
 ## Author
 
@@ -239,6 +201,7 @@ tracker](http://github.com/norman/babosa/issues).
 
 Many thanks to the following people for their help:
 
+* [Dmitry A. Ilyashevich](https://github.com/dmitry-ilyashevich) - Deprecation fixes
 * [anhkind](https://github.com/anhkind) - Vietnamese support
 * [Martins Zakis](https://github.com/martins) - Bug fixes
 * [Vassilis Rodokanakis](https://github.com/vrodokanakis) - Greek support
@@ -255,10 +218,9 @@ Many thanks to the following people for their help:
 * [Molte Emil Strange Andersen](https://github.com/molte) - Danish support
 * [Milan Dobrota](https://github.com/milandobrota) - Serbian support
 
-
 ## Copyright
 
-Copyright (c) 2010-2013 Norman Clarke
+Copyright (c) 2010-2020 Norman Clarke
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -276,4 +238,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

data/Rakefile

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 require "rubygems"
 require "rake/testtask"
 require "rake/clean"
 require "rubygems/package_task"
+require "rubocop/rake_task"
 
-task :default => :spec
-task :test    => :spec
+task default: [:rubocop, :spec]
+task test: :spec
 
 CLEAN << "pkg" << "doc" << "coverage" << ".yardoc"
 
@@ -14,6 +17,7 @@ begin
     t.options = ["--output-dir=doc"]
   end
 rescue LoadError
+  puts "Yard not present"
 end
 
 begin
@@ -23,12 +27,9 @@ begin
     Rake::Task["spec"].execute
   end
 rescue LoadError
+  puts "SimpleCov not present"
 end
 
-gemspec = File.expand_path("../babosa.gemspec", __FILE__)
-if File.exist? gemspec
-  Gem::PackageTask.new(eval(File.read(gemspec))) { |pkg| }
-end
-
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new

data/lib/babosa.rb

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
+
 module Babosa
-  def self.jruby15?
-    JRUBY_VERSION >= "1.5" rescue false
-  end
 end
 
 class String
@@ -12,5 +11,4 @@ class String
 end
 
 require "babosa/transliterator/base"
-require "babosa/utf8/proxy"
 require "babosa/identifier"

data/lib/babosa/identifier.rb

@@ -1,16 +1,6 @@
-# encoding: utf-8
-module Babosa
-
-  # Codepoints for characters that will be deleted by +#word_chars!+.
-  STRIPPABLE = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 14, 15, 16, 17, 18, 19,
-    20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 33, 34, 35, 36, 37, 38, 39,
-    40, 41, 42, 43, 44, 45, 46, 47, 58, 59, 60, 61, 62, 63, 64, 91, 92, 93, 94,
-    96, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
-    137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
-    152, 153, 154, 155, 156, 157, 158, 159, 161, 162, 163, 164, 165, 166, 167,
-    168, 169, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 182, 183, 184,
-    185, 187, 188, 189, 190, 191, 215, 247, 8203, 8204, 8205, 8239, 65279]
+# frozen_string_literal: true
 
+module Babosa
   # This class provides some string-manipulation methods specific to slugs.
   #
   # Note that this class includes many "bang methods" such as {#clean!} and
@@ -20,7 +10,7 @@ module Babosa
   # it is generated dynamically.
   #
   # All of the bang methods return an instance of String, while the bangless
-  # versions return an instance of Babosa::Identifier, so that calls to methods
+  # versions return an instance of {Babosa::Identifier}, so that calls to methods
   # specific to this class can be chained:
   #
   #   string = Identifier.new("hello world")
@@ -29,71 +19,47 @@ module Babosa
   #
   # @see http://www.utf8-chartable.de/unicode-utf8-table.pl?utf8=dec Unicode character table
   class Identifier
-
     Error = Class.new(StandardError)
 
     attr_reader :wrapped_string
     alias to_s wrapped_string
 
-    @@utf8_proxy = if Babosa.jruby15?
-      UTF8::JavaProxy
-    elsif defined? Unicode
-      UTF8::UnicodeProxy
-    elsif defined? ActiveSupport
-      UTF8::ActiveSupportProxy
-    else
-      UTF8::DumbProxy
-    end
-
-    # Return the proxy used for UTF-8 support.
-    # @see Babosa::UTF8::Proxy
-    def self.utf8_proxy
-      @@utf8_proxy
-    end
-
-    # Set a proxy object used for UTF-8 support.
-    # @see Babosa::UTF8::Proxy
-    def self.utf8_proxy=(obj)
-      @@utf8_proxy = obj
-    end
-
     def method_missing(symbol, *args, &block)
       @wrapped_string.__send__(symbol, *args, &block)
     end
 
+    def respond_to_missing?(name, include_all)
+      @wrapped_string.respond_to?(name, include_all)
+    end
+
     # @param string [#to_s] The string to use as the basis of the Identifier.
     def initialize(string)
-      @wrapped_string = string.to_s
+      @wrapped_string = string.to_s.dup
       tidy_bytes!
       normalize_utf8!
     end
 
-    def ==(value)
-      @wrapped_string.to_s == value.to_s
+    def ==(other)
+      to_s == other.to_s
     end
 
-    def eql?(value)
-      @wrapped_string == value
+    def eql?(other)
+      self == other
     end
 
-    def empty?
-      # included to make this class :respond_to? :empty for compatibility with Active Support's
-      # #blank?
-      @wrapped_string.empty?
-    end
-
-    # Approximate an ASCII string. This works only for Western strings using
-    # characters that are Roman-alphabet characters + diacritics. Non-letter
-    # characters are left unmodified.
+    # Approximate an ASCII string. This works only for strings using characters
+    # that are Roman-alphabet characters + diacritics. Non-letter characters
+    # are left unmodified.
     #
-    #   string = Identifier.new "Łódź
+    #   string = Identifier.new "Łódź, Poland"
     #   string.transliterate                 # => "Lodz, Poland"
     #   string = Identifier.new "日本"
     #   string.transliterate                 # => "日本"
     #
-    # You can pass any key(s) from +Characters.approximations+ as arguments. This allows
-    # for contextual approximations. Various languages are supported, you can see which ones
-    # by looking at the source of {Babosa::Transliterator::Base}.
+    # You can pass the names of any transliterator class as arguments. This
+    # allows for contextual approximations. Various languages are supported,
+    # you can see which ones by looking at the source of
+    # {Babosa::Transliterator::Base}.
     #
     #   string = Identifier.new "Jürgen Müller"
     #   string.transliterate                 # => "Jurgen Muller"
@@ -111,7 +77,7 @@ module Babosa
     # to remove non-ASCII characters such as "¡" and "¿", use {#to_ascii!}:
     #
     #   string.transliterate!(:spanish)       # => "¡Feliz anio!"
-    #   string.transliterate!                 # => "¡Feliz anio!"
+    #   string.to_ascii!                      # => "Feliz anio!"
     #
     # @param *args <Symbol>
     # @return String
@@ -122,40 +88,50 @@ module Babosa
         transliterator = Transliterator.get(kind).instance
         @wrapped_string = transliterator.transliterate(@wrapped_string)
       end
-      @wrapped_string
+      to_s
     end
 
     # Converts dashes to spaces, removes leading and trailing spaces, and
     # replaces multiple whitespace characters with a single space.
+    #
     # @return String
     def clean!
-      @wrapped_string = @wrapped_string.gsub("-", " ").squeeze(" ").strip
+      gsub!(/[- ]+/, " ")
+      strip!
+      to_s
     end
 
     # Remove any non-word characters. For this library's purposes, this means
-    # anything other than letters, numbers, spaces, newlines and linefeeds.
+    # anything other than letters, numbers, spaces, underscores, dashes,
+    # newlines, and linefeeds.
+    #
     # @return String
     def word_chars!
-      @wrapped_string = (unpack("U*") - Babosa::STRIPPABLE).pack("U*")
+      # `^\p{letter}` = Any non-Unicode letter
+      # `&&` = add the following character class
+      # `[^ _\n\r]` = Anything other than space, underscore, newline or linefeed
+      gsub!(/[[^\p{letter}]&&[^ \d_\-\n\r]]/, "")
+      to_s
     end
 
     # Normalize the string for use as a URL slug. Note that in this context,
     # +normalize+ means, strip, remove non-letters/numbers, downcasing,
     # truncating to 255 bytes and converting whitespace to dashes.
-    # @param Options
+    #
+    # @param options [Hash]
     # @return String
-    def normalize!(options = nil)
-      options = default_normalize_options.merge(options || {})
+    def normalize!(options = {})
+      options = default_normalize_options.merge(options)
 
-      if translit_option = options[:transliterate]
-        if translit_option != true
-          transliterate!(*translit_option)
-        else
+      if options[:transliterate]
+        option = options[:transliterate]
+        if option == true
           transliterate!(*options[:transliterations])
+        else
+          transliterate!(*option)
         end
       end
       to_ascii! if options[:to_ascii]
-      clean!
       word_chars!
       clean!
       downcase!
@@ -164,105 +140,103 @@ module Babosa
     end
 
     # Normalize a string so that it can safely be used as a Ruby method name.
-    def to_ruby_method!(allow_bangs = true)
-      leader, trailer = @wrapped_string.strip.scan(/\A(.+)(.)\z/).flatten
-      leader          = leader.to_s
-      trailer         = trailer.to_s
-      if allow_bangs
-        trailer.downcase!
-        trailer.gsub!(/[^a-z0-9!=\\?]/, '')
-      else
-        trailer.downcase!
-        trailer.gsub!(/[^a-z0-9]/, '')
-      end
-      id = leader.to_identifier
-      id.transliterate!
-      id.to_ascii!
-      id.clean!
-      id.word_chars!
-      id.clean!
-      @wrapped_string = id.to_s + trailer
-      if @wrapped_string == ""
-        raise Error, "Input generates impossible Ruby method name"
-      end
+    #
+    # @param allow_bangs [Boolean]
+    # @return String
+    def to_ruby_method!(allow_bangs: true)
+      last_char = self[-1]
+      transliterate!
+      to_ascii!
+      word_chars!
+      strip_leading_digits!
+      clean!
+      @wrapped_string += last_char if allow_bangs && ["!", "?"].include?(last_char)
+      raise Error, "Input generates impossible Ruby method name" if self == ""
+
       with_separators!("_")
     end
 
     # Delete any non-ascii characters.
+    #
     # @return String
     def to_ascii!
-      @wrapped_string = @wrapped_string.gsub(/[^\x00-\x7f]/u, '')
+      gsub!(/[^\x00-\x7f]/u, "")
+      to_s
     end
 
     # Truncate the string to +max+ characters.
+    #
     # @example
     #   "üéøá".to_identifier.truncate(3) #=> "üéø"
+    #
+    # @param max [Integer] The maximum number of characters.
     # @return String
     def truncate!(max)
-      @wrapped_string = unpack("U*")[0...max].pack("U*")
+      @wrapped_string = slice(0, max)
     end
 
     # Truncate the string to +max+ bytes. This can be useful for ensuring that
     # a UTF-8 string will always fit into a database column with a certain max
     # byte length. The resulting string may be less than +max+ if the string must
     # be truncated at a multibyte character boundary.
+    #
     # @example
     #   "üéøá".to_identifier.truncate_bytes(3) #=> "ü"
+    #
+    # @param max [Integer] The maximum number of bytes.
     # @return String
     def truncate_bytes!(max)
-      return @wrapped_string if @wrapped_string.bytesize <= max
-      curr = 0
-      new = []
-      unpack("U*").each do |char|
-        break if curr > max
-        char = [char].pack("U")
-        curr += char.bytesize
-        if curr <= max
-          new << char
-        end
-      end
-      @wrapped_string = new.join
+      truncate!(max)
+      chop! until bytesize <= max
     end
 
     # Replaces whitespace with dashes ("-").
+    #
+    # @param char [String] the separator character to use.
     # @return String
     def with_separators!(char = "-")
-      @wrapped_string = @wrapped_string.gsub(/\s/u, char)
-    end
-
-    # Perform UTF-8 sensitive upcasing.
-    # @return String
-    def upcase!
-      @wrapped_string = @@utf8_proxy.upcase(@wrapped_string)
+      gsub!(/\s/u, char)
+      to_s
     end
 
-    # Perform UTF-8 sensitive downcasing.
+    # Perform Unicode composition on the wrapped string.
+    #
     # @return String
-    def downcase!
-      @wrapped_string = @@utf8_proxy.downcase(@wrapped_string)
+    def normalize_utf8!
+      unicode_normalize!(:nfc)
+      to_s
     end
 
-    # Perform Unicode composition on the wrapped string.
+    # Strip any leading digits.
+    #
     # @return String
-    def normalize_utf8!
-      @wrapped_string = @@utf8_proxy.normalize_utf8(@wrapped_string)
+    def strip_leading_digits!
+      gsub!(/^\d+/, "")
+      to_s
     end
 
     # Attempt to convert characters encoded using CP1252 and IS0-8859-1 to
     # UTF-8.
     # @return String
     def tidy_bytes!
-      @wrapped_string = @@utf8_proxy.tidy_bytes(@wrapped_string)
+      scrub! do |bad|
+        bad.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)
+      end
+      to_s
     end
 
-    %w[transliterate clean downcase word_chars normalize normalize_utf8
-      tidy_bytes to_ascii to_ruby_method truncate truncate_bytes upcase
-      with_separators].each do |method|
-      class_eval(<<-EOM, __FILE__, __LINE__ + 1)
+    %w[clean downcase normalize normalize_utf8 strip_leading_digits
+       tidy_bytes to_ascii transliterate truncate truncate_bytes upcase
+       with_separators word_chars].each do |method|
+      class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
         def #{method}(*args)
-          send_to_new_instance(:#{method}!, *args)
+          with_new_instance { |id| id.send(:#{method}!, *args) }
         end
-      EOM
+      METHOD
+    end
+
+    def to_ruby_method(allow_bangs: true)
+      with_new_instance { |id| id.to_ruby_method!(allow_bangs: allow_bangs) }
     end
 
     def to_identifier
@@ -271,7 +245,7 @@ module Babosa
 
     # The default options for {#normalize!}. Override to set your own defaults.
     def default_normalize_options
-      {:transliterate => true, :max_length => 255, :separator => "-"}
+      {transliterate: :latin, max_length: 255, separator: "-"}
     end
 
     alias approximate_ascii transliterate
@@ -282,12 +256,13 @@ module Babosa
 
     private
 
-    # Used as the basis of the bangless methods.
-    def send_to_new_instance(*args)
-      id = Identifier.allocate
-      id.instance_variable_set :@wrapped_string, to_s
-      id.send(*args)
-      id
+    # Used as the basis of the non-mutating (bangless) methods.
+    def with_new_instance
+      Identifier.allocate.tap do |id|
+        id.instance_variable_set :@wrapped_string, to_s
+
+        yield id
+      end
     end
   end
 end