babosa 0.2.2 → 0.3.0

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+$LOAD_PATH << File.expand_path("../lib", __FILE__)
+$LOAD_PATH.uniq!
+
+if ENV["COV"]
+  require "simplecov"
+  SimpleCov.start
+end
+
+# encoding: utf-8
+$KCODE = 'UTF8' if RUBY_VERSION < '1.9'
+
+require "rubygems"
+require "babosa"
+require "active_support"
+
+shared_examples_for "a latin transliterator" do
+  let(:t) { described_class.instance }
+
+  it "should transliterate latin characters" do
+    string = (0xC0..0x17E).to_a.pack("U*")
+    t.transliterate(string).should match(/[\x0-\x7f]/)
+  end
+end
+
+shared_examples_for "a cyrillic transliterator" do
+  let(:t) { described_class.instance }
+
+  it "should transliterate cyrillic characters" do
+    string = "Славься, Отечество наше свободное"
+    t.transliterate(string).should match(/[\x0-\x7f]/)
+  end
+end

data/spec/transliterators/base_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Base do
+
+  before { @t = Babosa::Transliterator::Base.instance }
+
+  it "should transliterate 'smart' quotes" do
+    @t.transliterate("’").should eql("'")
+  end
+
+  it "should transliterate non-breaking spaces" do
+    @t.transliterate("\xc2\xa0").should eql(" ")
+  end
+
+end

data/spec/transliterators/bulgarian_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Bulgarian do
+
+  let(:t) { described_class.instance }
+  it_behaves_like "a cyrillic transliterator"
+
+  it "should transliterate Cyrillic characters" do
+    examples = {
+      "Ютия"    => "Iutiia",
+      "Чушка"   => "Chushka",
+      "кьорав"  => "kiorav",
+      "Щъркел"  => "Shturkel",
+      "полицай" => "policai"
+    }
+    examples.each {|k, v| t.transliterate(k).should eql(v)}
+  end
+
+end

data/spec/transliterators/danish_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Danish do
+
+  let(:t) { described_class.instance }
+  it_behaves_like "a latin transliterator"
+
+  it "should transliterate various characters" do
+    examples = {
+      "Ærøskøbing" => "Aeroeskoebing",
+      "Årslev"     => "Aarslev"
+    }
+    examples.each {|k, v| t.transliterate(k).should eql(v)}
+  end
+
+end

data/spec/transliterators/german_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::German do
+
+  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

data/spec/transliterators/russian_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Russian do
+
+  let(:t) { described_class.instance }
+  it_behaves_like "a cyrillic transliterator"
+
+end

data/spec/transliterators/serbian_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Serbian do
+
+  let(:t) { described_class.instance }
+  it_behaves_like "a latin transliterator"
+  it_behaves_like "a cyrillic transliterator"
+
+  it "should transliterate Latin characters" do
+    examples = {
+      "Ðorđe"  => "Djordje",
+      "Inđija" => "Indjija",
+      "Četiri" => "Chetiri",
+      "četiri" => "chetiri",
+      "Škola"  => "Shkola",
+      "škola"  => "shkola",
+      "Ђорђе"  => "Djordje",
+      "Инђија" => "Indjija",
+      "Школа"  => "Shkola",
+    }
+    examples.each {|k, v| t.transliterate(k).should eql(v)}
+  end
+
+end

data/spec/transliterators/spanish_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Spanish do
+
+  let(:t) { described_class.instance }
+  it_behaves_like "a latin transliterator"
+
+  it "should transliterate ñ" do
+    t.transliterate("ñ").should eql("ni")
+  end
+
+end

data/spec/transliterators/ukranian_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Ukranian do
+
+  let(:t) { described_class.instance }
+  it_behaves_like "a cyrillic transliterator"
+
+end

data/spec/utf8_proxy_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+require File.expand_path("../spec_helper", __FILE__)
+
+PROXIES = [Babosa::UTF8::DumbProxy]
+
+PROXIES << Babosa::UTF8::JavaProxy if Babosa.jruby15?
+
+begin
+  require "unicode"
+  PROXIES << Babosa::UTF8::UnicodeProxy
+rescue LoadError
+end
+
+begin
+  require "activesupport"
+  PROXIES << Babosa::UTF8::ActiveSupportProxy
+rescue LoadError
+end
+
+PROXIES.each do |proxy|
+
+  describe proxy do
+
+    describe "#normalize_utf8" do
+      it "should normalize to canonical composed" do
+        # ÅÉÎØÜ
+        uncomposed_bytes  = [65, 204, 138, 69, 204, 129, 73, 204, 130, 195, 152, 85, 204, 136]
+        composed_bytes    = [195, 133, 195, 137, 195, 142, 195, 152, 195, 156]
+        uncomposed_string = uncomposed_bytes.pack("C*").unpack("U*").pack("U*")
+        composed_string   = composed_bytes.pack("C*").unpack("U*").pack("U*")
+        proxy.normalize_utf8(uncomposed_string).unpack("C*").should eql(composed_bytes)
+      end
+    end
+
+    describe "#upcase" do
+      it "should upcase the string" do
+        proxy.upcase("åéîøü").should eql("ÅÉÎØÜ")
+      end
+    end
+
+    describe "#downcase" do
+      it "should downcase the string" do
+        proxy.downcase("ÅÉÎØÜ").should eql("åéîøü")
+      end
+    end
+
+  end
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: babosa
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 2
-  version: 0.2.2
+  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors: 
 - Norman Clarke
@@ -14,10 +10,42 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-24 00:00:00 -03:00
+date: 2011-03-23 00:00:00 -03:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: "    A library for creating slugs. Babosa an extraction and improvement of the\n    string code from FriendlyId, intended to help developers create similar\n    libraries or plugins.\n"
 email: norman@njclarke.com
 executables: []
@@ -27,8 +55,17 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/babosa/characters.rb
 - lib/babosa/identifier.rb
+- lib/babosa/transliterator/base.rb
+- lib/babosa/transliterator/bulgarian.rb
+- lib/babosa/transliterator/cyrillic.rb
+- lib/babosa/transliterator/danish.rb
+- lib/babosa/transliterator/german.rb
+- lib/babosa/transliterator/latin.rb
+- lib/babosa/transliterator/russian.rb
+- lib/babosa/transliterator/serbian.rb
+- lib/babosa/transliterator/spanish.rb
+- lib/babosa/transliterator/ukranian.rb
 - lib/babosa/utf8/active_support_proxy.rb
 - lib/babosa/utf8/dumb_proxy.rb
 - lib/babosa/utf8/java_proxy.rb
@@ -41,8 +78,19 @@ files:
 - MIT-LICENSE
 - Rakefile
 - init.rb
-- test/babosa_test.rb
-has_rdoc: false
+- spec/babosa_spec.rb
+- spec/spec_helper.rb
+- spec/transliterators/base_spec.rb
+- spec/transliterators/bulgarian_spec.rb
+- spec/transliterators/danish_spec.rb
+- spec/transliterators/german_spec.rb
+- spec/transliterators/russian_spec.rb
+- spec/transliterators/serbian_spec.rb
+- spec/transliterators/spanish_spec.rb
+- spec/transliterators/ukranian_spec.rb
+- spec/utf8_proxy_spec.rb
+- .gemtest
+has_rdoc: true
 homepage: http://norman.github.com/babosa
 licenses: []
 
@@ -56,23 +104,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: "[none]"
-rubygems_version: 1.3.7
+rubygems_version: 1.6.1
 signing_key: 
 specification_version: 3
 summary: A library for creating slugs.
-test_files: 
-- test/babosa_test.rb
+test_files: []
+

data/lib/babosa/characters.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-module Babosa
-
-  # This module provides sets of characters needed for various UTF-8 aware
-  # string operations.
-  module Characters
-    extend self
-
-    # Hash of UTF-8 - ASCII approximations.
-    attr_reader :approximations
-    # Punctuation and control characters to remove from slug strings.
-    attr_reader :strippable
-
-    @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,
-      95, 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]
-
-    # Adds a hash of approximations.
-    # @example
-    #     add_approximations :spanish, "ñ" => "ni"
-    # @param [#to_sym] name The name of the approximations to add.
-    # @param Hash hash The approximations to add.
-    def add_approximations(name, hash)
-      approximations = @approximations ? @approximations.dup : {}
-      approximations[name.to_sym] = hash.inject({}) do |memo, object|
-        key = object[0].unpack("U").shift
-        value = object[1].unpack("C*")
-        memo[key] = value.length == 1 ? value[0] : value
-        memo
-      end.freeze
-      @approximations = approximations.freeze
-    end
-
-    add_approximations :danish,  "æ" => "ae", "ø" => "oe", "å" => "aa", "Ø" => "Oe", "Å" => "Aa"
-    add_approximations :german,  "ä" => "ae", "ö" => "oe", "ü" => "ue", "Ä" => "Ae", "Ö" => "Oe", "Ü" => "Ue"
-    add_approximations :serbian, "Ð" => "Dj", "đ" => "dj" ,"Č" => "Ch", "č" => "ch", "Š" => "Sh", "š" => "sh"
-    add_approximations :spanish, "ñ" => "ni", "Ñ" => "Ni"
-    add_approximations :latin, {
-      "À" => "A", "Á" => "A", "Â" => "A", "Ã" => "A", "Ä" => "A", "Å" => "A",
-      "Æ" => "Ae", "Ç" => "C", "È" => "E", "É" => "E", "Ê" => "E", "Ë" => "E",
-      "Ì" => "I", "Í" => "I", "Î" => "I", "Ï" => "I", "Ð" => "D", "Ñ" => "N",
-      "Ò" => "O", "Ó" => "O", "Ô" => "O", "Õ" => "O", "Ö" => "O", "Ø" => "O",
-      "Ù" => "U", "Ú" => "U", "Û" => "U", "Ü" => "U", "Ý" => "Y", "Þ" => "Th",
-      "ß" => "ss", "à" => "a" , "á" => "a", "â" => "a", "ã" => "a", "ä" => "a",
-      "å" => "a", "æ" => "ae", "ç" => "c" , "è" => "e", "é" => "e", "ê" => "e",
-      "ë" => "e", "ì" => "i", "í" => "i", "î" => "i", "ï" => "i", "ð" => "d",
-      "ñ" => "n", "ò" => "o", "ó" => "o", "ô" => "o", "õ" => "o", "ö" => "o",
-      "ø" => "o", "ù" => "u", "ú" => "u", "û" => "u", "ü" => "u", "ý" => "y",
-      "þ" => "th", "ÿ" => "y", "Ā" => "A", "ā" => "a", "Ă" => "A", "ă" => "a",
-      "Ą" => "A", "ą" => "a", "Ć" => "C", "ć" => "c", "Ĉ" => "C", "ĉ" => "c",
-      "Ċ" => "C", "ċ" => "c", "Č" => "C", "č" => "c", "Ď" => "D", "ď" => "d",
-      "Đ" => "D", "đ" => "d", "Ē" => "E", "ē" => "e", "Ĕ" => "E", "ĕ" => "e",
-      "Ė" => "E", "ė" => "e", "Ę" => "E", "ę" => "e", "Ě" => "E", "ě" => "e",
-      "Ĝ" => "G", "ĝ" => "g", "Ğ" => "G", "ğ" => "g", "Ġ" => "G", "ġ" => "g",
-      "Ģ" => "G", "ģ" => "g", "Ĥ" => "H", "ĥ" => "h", "Ħ" => "H", "ħ" => "h",
-      "Ĩ" => "I", "ĩ" => "i", "Ī" => "I", "ī" => "i", "Ĭ" => "I", "ĭ" => "i",
-      "Į" => "I", "į" => "i", "İ" => "I", "ı" => "i", "IJ" => "Ij", "ij" => "ij",
-      "Ĵ" => "J", "ĵ" => "j", "Ķ" => "K", "ķ" => "k", "ĸ" => "k", "Ĺ" => "L",
-      "ĺ" => "l", "Ļ" => "L", "ļ" => "l", "Ľ" => "L", "ľ" => "l", "Ŀ" => "L",
-      "ŀ" => "l", "Ł" => "L", "ł" => "l", "Ń" => "N", "ń" => "n", "Ņ" => "N",
-      "ņ" => "n", "Ň" => "N", "ň" => "n", "ʼn" => "n", "Ŋ" => "Ng", "ŋ" => "ng",
-      "Ō" => "O", "ō" => "o", "Ŏ" => "O", "ŏ" => "o", "Ő" => "O", "ő" => "o",
-      "Œ" => "OE", "œ" => "oe", "Ŕ" => "R", "ŕ" => "r", "Ŗ" => "R", "ŗ" => "r",
-      "Ř" => "R", "ř" => "r", "Ś" => "S", "ś" => "s", "Ŝ" => "S", "ŝ" => "s",
-      "Ş" => "S", "ş" => "s", "Š" => "S", "š" => "s", "Ţ" => "T", "ţ" => "t",
-      "Ť" => "T", "ť" => "t", "Ŧ" => "T", "ŧ" => "t", "Ũ" => "U", "ũ" => "u",
-      "Ū" => "U", "ū" => "u", "Ŭ" => "U", "ŭ" => "u", "Ů" => "U", "ů" => "u",
-      "Ű" => "U", "ű" => "u", "Ų" => "U", "ų" => "u", "Ŵ" => "W", "ŵ" => "w",
-      "Ŷ" => "Y", "ŷ" => "y", "Ÿ" => "Y", "Ź" => "Z", "ź" => "z", "Ż" => "Z",
-      "ż" => "z", "Ž" => "Z", "ž" => "z", "×" => "x", "÷" => "/", "‘" => "'",
-      '’' => "'", "‛" => "'", "“" => '"', "”" => '"', "„" => '"', "‟" => '"',
-      "‐" => "-", "‑" => "-", "‒" => "-", "–" => "-", "—" => "-", "―" => "-"
-    }
-  end
-end

data/test/babosa_test.rb

@@ -1,198 +0,0 @@
-# encoding: utf-8
-$KCODE = 'UTF8' if RUBY_VERSION < '1.9'
-
-require "rubygems"
-require "bundler/setup"
-require "test/unit"
-require "babosa"
-
-Module.send :include, Module.new {
-  def test(name, &block)
-    define_method("test_#{name.gsub(/[^a-z0-9_]/i, "_")}".to_sym, &block)
-  end
-}
-
-module UTF8ProxyTest
-  test "should downcase strings" do
-    assert_equal "åéîøü", proxy.downcase("ÅÉÎØÜ")
-  end
-
-  test "should upcase strings" do
-    assert_equal "ÅÉÎØÜ", proxy.upcase("åéîøü")
-  end
-
-  test "should compose UTF-8" do
-    # ÅÉÎØÜ
-    uncomposed_bytes = [65, 204, 138, 69, 204, 129, 73, 204, 130, 195, 152, 85, 204, 136]
-    composed_bytes   = [195, 133, 195, 137, 195, 142, 195, 152, 195, 156]
-    uncomposed_string = uncomposed_bytes.pack("C*").unpack("U*").pack("U*")
-    composed_string   = composed_bytes.pack("C*").unpack("U*").pack("U*")
-    assert_equal composed_bytes, proxy.normalize_utf8(uncomposed_string).unpack("C*")
-  end
-end
-
-if Babosa.jruby15?
-  class JavaProxyTest < Test::Unit::TestCase
-    include UTF8ProxyTest
-    def proxy
-      Babosa::UTF8::JavaProxy
-    end
-  end
-end
-
-class DumbProxyTest < Test::Unit::TestCase
-  include UTF8ProxyTest
-  def proxy
-    Babosa::UTF8::DumbProxy
-  end
-end
-
-class  BabosaTest < Test::Unit::TestCase
-
-  test "should respond_to? :empty?" do
-    assert "".to_slug.respond_to? :empty?
-  end
-
-  test "word_chars! should leave only letters and spaces" do
-    string = "a*$%^$@!@b$%^&*()*!c"
-    assert_match /[a-z ]*/i, string.to_slug.word_chars!
-  end
-
-  test "approximate_ascii should transliterate to ascii" do
-    slug = (0xC0..0x17E).to_a.each do |codepoint|
-      ss = [codepoint].pack("U*").to_slug
-      approx = ss.approximate_ascii
-      assert_match /[\x0-\x7f]/, approx.to_s
-    end
-  end
-
-  test "should lowercase strings" do
-    assert_equal "feliz año", "FELIZ AÑO".to_slug.downcase!
-  end
-
-  test "should uppercase strings" do
-    assert_equal "FELIZ AÑO", "feliz año".to_slug.upcase!
-  end
-
-  test "should replace whitespace with dashes" do
-    assert_equal "a-b", "a b".to_slug.clean.normalize!
-  end
-
-  test "should replace multiple spaces with 1 dash" do
-    assert_equal "a-b", "a    b".to_slug.clean.normalize!
-  end
-
-  test "should replace multiple dashes with 1 dash" do
-    assert_equal "male-female", "male - female".to_slug.normalize!
-  end
-
-  test "should strip trailing space" do
-    assert_equal "ab", "ab ".to_slug.normalize!
-  end
-
-  test "should strip leading space" do
-    assert_equal "ab", " ab".to_slug.normalize!
-  end
-
-  test "should strip trailing slashes" do
-    assert_equal "ab", "ab-".to_slug.normalize!
-  end
-
-  test "should strip leading slashes" do
-    assert_equal "ab", "-ab".to_slug.normalize!
-  end
-
-  test "should not modify valid name strings" do
-    assert_equal "a-b-c-d", "a-b-c-d".to_slug.normalize!
-  end
-
-  test "should do special approximations for German" do
-    {
-      "Jürgen" => "Juergen",
-      "böse"   => "boese",
-      "Männer" => "Maenner"
-    }.each {|given, expected| assert_equal expected, given.to_slug.approximate_ascii!(:german)}
-  end
-
-  test "should do special approximations for Spanish" do
-    assert_equal "anio", "año".to_slug.approximate_ascii!(:spanish)
-  end
-
-  test "should do special approximations for Serbian" do
-    {
-      "Ðorđe"  => "Djordje",
-      "Inđija" => "Indjija",
-      "Četiri" => "Chetiri",
-      "četiri" => "chetiri",
-      "Škola"  => "Shkola",
-      "škola"  => "shkola"
-    }.each {|given, expected| assert_equal expected, given.to_slug.approximate_ascii!(:serbian)}
-  end
-
-  test "should do special approximations for Danish" do
-    {
-      "Ærøskøbing" => "Aeroeskoebing",
-      "Årslev"       => "Aarslev"
-    }.each {|given, expected| assert_equal expected, given.to_slug.approximate_ascii!(:danish)}
-  end
-
-  test "should work with non roman chars" do
-    assert_equal "検-索", "検 索".to_slug.normalize!
-  end
-
-  test "should work with invalid UTF-8 strings" do
-    %w[approximate_ascii clean downcase word_chars normalize to_ascii upcase with_dashes].each do |method|
-      string = "\x93abc".to_slug
-      assert_nothing_raised do
-        method == "truncate" ? string.send(method, 32) : string.send(method)
-      end
-    end
-  end
-
-  test "should truncate string by byte length" do
-    assert_equal "ü",  "üa".to_slug.truncate_bytes!(2)
-    assert_equal "",   "üa".to_slug.truncate_bytes!(1)
-    assert_equal "üa", "üa".to_slug.truncate_bytes!(100)
-    assert_equal "ü",  "üéøá".to_slug.truncate_bytes!(3)
-  end
-
-  test "should truncate string by char length" do
-    assert_equal "üa", "üa".to_slug.truncate!(2)
-    assert_equal "ü",  "üa".to_slug.truncate!(1)
-    assert_equal "üa", "üa".to_slug.truncate!(100)
-  end
-
-  test "should transliterate uncomposed utf8" do
-    string = [117, 776].pack("U*") # "ü" as ASCII "u" plus COMBINING DIAERESIS
-    assert_equal "u", string.to_slug.approximate_ascii!
-  end
-
-  test "with_dashes should not change byte size when replacing spaces" do
-    assert_equal "".bytesize, "".to_slug.with_dashes.bytesize
-    assert_equal " ".bytesize, " ".to_slug.with_dashes.bytesize
-    assert_equal "-abc-".bytesize, "-abc-".to_slug.with_dashes.bytesize
-    assert_equal " abc ".bytesize, " abc ".to_slug.with_dashes.bytesize
-    assert_equal " a  bc ".bytesize, " a  bc ".to_slug.with_dashes.bytesize
-  end
-
-  test "normalize! with ascii option should approximate and strip non ascii" do
-    ss = "カタカナ: katakana is über cool".to_slug
-    assert_equal "katakana-is-uber-cool", ss.normalize!(:to_ascii => true)
-  end
-
-  test "normalize should use transliterations" do
-    assert_equal "juergen", "Jürgen".to_slug.normalize(:transliterations => :german).to_s
-  end
-
-  test "should get a string suitable for use as a ruby method" do
-    assert_equal "hello_world?", "¿¿¿hello... world???".to_slug.to_ruby_method!
-    assert_equal "katakana_is_uber_cool", "カタカナ: katakana is über cool".to_slug.to_ruby_method!
-    assert_equal "katakana_is_uber_cool!", "カタカナ: katakana is über cool!".to_slug.to_ruby_method!
-    assert_equal "katakana_is_uber_cool", "カタカナ: katakana is über cool".to_slug.to_ruby_method!(false)
-  end
-
-  test "should approximate 'smart' quotes" do
-    assert_equal "john's", "john’s".to_slug.approximate_ascii.to_s
-    assert_equal "johns", "john’s".to_slug.normalize.to_s
-  end
-end