babosa 0.3.11 → 1.0.1

data/lib/babosa/utf8/unicode_proxy.rb

@@ -1,9 +1,11 @@
+require 'unicode'
+
 module Babosa
   module UTF8
     # A UTF-8 proxy using the Unicode gem.
     # @see http://github.com/blackwinter/unicode
     module UnicodeProxy
-      extend UTF8Proxy
+      extend Proxy
       extend self
       def downcase(string)
         Unicode.downcase(string)

data/lib/babosa/version.rb

@@ -1,5 +1,5 @@
 module Babosa
   module Version
-    STRING = "0.3.11"
+    STRING = '1.0.1'
   end
 end

data/spec/babosa_spec.rb

@@ -4,7 +4,7 @@ require File.expand_path("../spec_helper", __FILE__)
 describe Babosa::Identifier do
 
   it "should respond_to :empty?" do
-    "".to_slug.should respond_to(:empty?)
+    expect("".to_slug).to respond_to(:empty?)
   end
 
   %w[approximate_ascii clean downcase word_chars normalize to_ascii upcase with_dashes].each do |method|
@@ -18,128 +18,137 @@ describe Babosa::Identifier do
   describe "#word_chars" do
     it "word_chars! should leave only letters and spaces" do
       string = "a*$%^$@!@b$%^&*()*!c"
-      string.to_slug.word_chars.should match(/[a-z ]*/i)
+      expect(string.to_slug.word_chars!).to match(/[a-z ]*/i)
     end
   end
 
   describe "#transliterate" do
     it "should transliterate to ascii" do
-      slug = (0xC0..0x17E).to_a.each do |codepoint|
+      (0xC0..0x17E).to_a.each do |codepoint|
         ss = [codepoint].pack("U*").to_slug
-        ss.approximate_ascii.should match(/[\x0-\x7f]/)
+        expect(ss.approximate_ascii!).to match(/[\x0-\x7f]/)
       end
     end
 
     it "should transliterate uncomposed utf8" do
       string = [117, 776].pack("U*") # "ü" as ASCII "u" plus COMBINING DIAERESIS
-      string.to_slug.approximate_ascii.should eql("u")
+      expect(string.to_slug.approximate_ascii).to eql("u")
     end
 
     it "should transliterate using multiple transliterators" do
       string = "свободное režģis"
-      string.to_slug.approximate_ascii(:latin, :russian).should eql("svobodnoe rezgis")
+      expect(string.to_slug.approximate_ascii(:latin, :russian)).to eql("svobodnoe rezgis")
     end
   end
 
   describe "#downcase" do
     it "should lowercase strings" do
-      "FELIZ AÑO".to_slug.downcase.should eql("feliz año")
+      expect("FELIZ AÑO".to_slug.downcase).to eql("feliz año")
     end
   end
 
   describe "#upcase" do
     it "should uppercase strings" do
-      "feliz año".to_slug.upcase.should eql("FELIZ AÑO")
+      expect("feliz año".to_slug.upcase).to eql("FELIZ AÑO")
     end
   end
 
   describe "#normalize" do
 
     it "should allow passing locale as key for :transliterate" do
-      "ö".to_slug.clean.normalize(:transliterate => :german).should eql("oe")
+      expect("ö".to_slug.clean.normalize(:transliterate => :german)).to eql("oe")
     end
 
     it "should replace whitespace with dashes" do
-      "a b".to_slug.clean.normalize.should eql("a-b")
+      expect("a b".to_slug.clean.normalize).to eql("a-b")
     end
 
     it "should replace multiple spaces with 1 dash" do
-      "a    b".to_slug.clean.normalize.should eql("a-b")
+      expect("a    b".to_slug.clean.normalize).to eql("a-b")
     end
 
     it "should replace multiple dashes with 1 dash" do
-      "male - female".to_slug.normalize.should eql("male-female")
+      expect("male - female".to_slug.normalize).to eql("male-female")
     end
 
     it "should strip trailing space" do
-      "ab ".to_slug.normalize.should eql("ab")
+      expect("ab ".to_slug.normalize).to eql("ab")
     end
 
     it "should strip leading space" do
-      " ab".to_slug.normalize.should eql("ab")
+      expect(" ab".to_slug.normalize).to eql("ab")
     end
 
     it "should strip trailing slashes" do
-      "ab-".to_slug.normalize.should eql("ab")
+      expect("ab-".to_slug.normalize).to eql("ab")
     end
 
     it "should strip leading slashes" do
-      "-ab".to_slug.normalize.should eql("ab")
+      expect("-ab".to_slug.normalize).to eql("ab")
     end
 
     it "should not modify valid name strings" do
-      "a-b-c-d".to_slug.normalize.should eql("a-b-c-d")
+      expect("a-b-c-d".to_slug.normalize).to eql("a-b-c-d")
     end
 
     it "should not convert underscores" do
-      "hello_world".to_slug.normalize.should eql("hello_world")
+      expect("hello_world".to_slug.normalize).to eql("hello_world")
     end
 
     it "should work with non roman chars" do
-      "検 索".to_slug.normalize.should eql("検-索")
+      expect("検 索".to_slug.normalize).to eql("検-索")
     end
 
     context "with to_ascii option" do
       it "should approximate and strip non ascii" do
         ss = "カタカナ: katakana is über cool".to_slug
-        ss.normalize(:to_ascii => true).should eql("katakana-is-uber-cool")
+        expect(ss.normalize(:to_ascii => true)).to eql("katakana-is-uber-cool")
       end
     end
   end
 
   describe "#truncate_bytes" do
     it "should by byte length" do
-      "üa".to_slug.truncate_bytes(2).should eql("ü")
-      "üa".to_slug.truncate_bytes(1).should eql("")
-      "üa".to_slug.truncate_bytes(100).should eql("üa")
-      "üéøá".to_slug.truncate_bytes(3).should eql("ü")
+      expect("üa".to_slug.truncate_bytes(2)).to eql("ü")
+      expect("üa".to_slug.truncate_bytes(1)).to eql("")
+      expect("üa".to_slug.truncate_bytes(100)).to eql("üa")
+      expect("üéøá".to_slug.truncate_bytes(3)).to eql("ü")
     end
   end
 
   describe "#truncate" do
     it "should truncate by char length" do
-      "üa".to_slug.truncate(2).should eql("üa")
-      "üa".to_slug.truncate(1).should eql("ü")
-      "üa".to_slug.truncate(100).should eql("üa")
+      expect("üa".to_slug.truncate(2)).to eql("üa")
+      expect("üa".to_slug.truncate(1)).to eql("ü")
+      expect("üa".to_slug.truncate(100)).to eql("üa")
     end
   end
 
   describe "#with_dashes" do
     it "should not change byte size when replacing spaces" do
-      "".to_slug.with_dashes.bytesize.should eql(0)
-      " ".to_slug.with_dashes.bytesize.should eql(1)
-      "-abc-".to_slug.with_dashes.bytesize.should eql(5)
-      " abc ".to_slug.with_dashes.bytesize.should eql(5)
-      " a  bc ".to_slug.with_dashes.bytesize.should eql(7)
+      expect("".to_slug.with_dashes.bytesize).to eql(0)
+      expect(" ".to_slug.with_dashes.bytesize).to eql(1)
+      expect("-abc-".to_slug.with_dashes.bytesize).to eql(5)
+      expect(" abc ".to_slug.with_dashes.bytesize).to eql(5)
+      expect(" a  bc ".to_slug.with_dashes.bytesize).to eql(7)
     end
   end
 
   describe "#to_ruby_method" do
     it "should get a string suitable for use as a ruby method" do
-      "¿¿¿hello... world???".to_slug.to_ruby_method.should eql("hello_world?")
-      "カタカナ: katakana is über cool".to_slug.to_ruby_method.should eql("katakana_is_uber_cool")
-      "カタカナ: katakana is über cool!".to_slug.to_ruby_method.should eql("katakana_is_uber_cool!")
-      "カタカナ: katakana is über cool".to_slug.to_ruby_method(false).should eql("katakana_is_uber_cool")
+      expect("¿¿¿hello... world???".to_slug.to_ruby_method).to eql("hello_world?")
+      expect("カタカナ: katakana is über cool".to_slug.to_ruby_method).to eql("katakana_is_uber_cool")
+      expect("カタカナ: katakana is über cool!".to_slug.to_ruby_method).to eql("katakana_is_uber_cool!")
+      expect("カタカナ: katakana is über cool".to_slug.to_ruby_method(false)).to eql("katakana_is_uber_cool")
+    end
+
+    it "should optionally remove trailing punctuation" do
+      expect("¿¿¿hello... world???".to_slug.to_ruby_method(false)).to eql("hello_world")
+    end
+
+    it "should raise an error when it would generate an impossible method name" do
+      # "1".to_identifier.to_ruby_method
+      expect {"1".to_identifier.to_ruby_method}.to raise_error(Babosa::Identifier::Error)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,25 +1,19 @@
-# encoding: utf-8
-$LOAD_PATH << File.expand_path("../lib", __FILE__)
-$LOAD_PATH.uniq!
+# coding: utf-8
 
-if ENV["COV"]
-  require "simplecov"
+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"
+require 'bundler/setup'
+require 'babosa'
 
 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]/)
+    expect(t.transliterate(string)).to match(/[\x0-\x7f]/)
   end
 end
 
@@ -28,7 +22,7 @@ shared_examples_for "a cyrillic transliterator" do
 
   it "should transliterate cyrillic characters" do
     string = "Славься, Отечество наше свободное"
-    t.transliterate(string).should match(/[\x0-\x7f]/)
+    expect(t.transliterate(string)).to match(/[\x0-\x7f]/)
   end
 end
 
@@ -37,6 +31,6 @@ shared_examples_for "a greek transliterator" do
 
   it "should transliterate greek characters" do
     string = "Γερμανία"
-    t.transliterate(string).should match(/[\x0-\x7f]/)
+    expect(t.transliterate(string)).to match(/[\x0-\x7f]/)
   end
 end

data/spec/transliterators/base_spec.rb

@@ -3,14 +3,14 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 describe Babosa::Transliterator::Base do
 
-  before { @t = Babosa::Transliterator::Base.instance }
+  let(:t) {Babosa::Transliterator::Base.instance}
 
   it "should transliterate 'smart' quotes" do
-    @t.transliterate("’").should eql("'")
+    expect(t.transliterate("’")).to eql("'")
   end
 
   it "should transliterate non-breaking spaces" do
-    @t.transliterate("\xc2\xa0").should eql(" ")
+    expect(t.transliterate("\xc2\xa0")).to eql(" ")
   end
 
 end

data/spec/transliterators/bulgarian_spec.rb

@@ -14,7 +14,7 @@ describe Babosa::Transliterator::Bulgarian do
       "Щъркел"  => "Shturkel",
       "полицай" => "policai"
     }
-    examples.each {|k, v| t.transliterate(k).should eql(v)}
+    examples.each {|k, v| expect(t.transliterate(k)).to eql(v)}
   end
 
 end

data/spec/transliterators/danish_spec.rb

@@ -11,7 +11,7 @@ describe Babosa::Transliterator::Danish do
       "Ærøskøbing" => "Aeroeskoebing",
       "Årslev"     => "Aarslev"
     }
-    examples.each {|k, v| t.transliterate(k).should eql(v)}
+    examples.each {|k, v| expect(t.transliterate(k)).to eql(v)}
   end
 
 end

data/spec/transliterators/german_spec.rb

@@ -7,11 +7,11 @@ describe Babosa::Transliterator::German do
   it_behaves_like "a latin transliterator"
 
   it "should transliterate Eszett" do
-    t.transliterate("ß").should eql("ss")
+    expect(t.transliterate("ß")).to eql("ss")
   end
 
   it "should transliterate vowels with umlauts" do
-    t.transliterate("üöä").should eql("ueoeae")
+    expect(t.transliterate("üöä")).to eql("ueoeae")
   end
 
 end

data/spec/transliterators/greek_spec.rb

@@ -12,6 +12,6 @@ describe Babosa::Transliterator::Greek do
       "Αυστρία"   => "Aystria",
       "Ιταλία"    => "Italia"
     }
-    examples.each {|k, v| t.transliterate(k).should eql(v)}
+    examples.each {|k, v| expect(t.transliterate(k)).to eql(v)}
   end
 end

data/spec/transliterators/latin_spec.rb

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

data/spec/transliterators/norwegian_spec.rb

@@ -13,6 +13,6 @@ describe Babosa::Transliterator::Norwegian do
       "Åre"    => "Aare",
       "Håkon"  => "Haakon"
     }
-    examples.each {|k, v| t.transliterate(k).should eql(v)}
+    examples.each {|k, v| expect(t.transliterate(k)).to eql(v)}
   end
 end

data/spec/transliterators/polish_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Babosa::Transliterator::Romanian do
+
+  let(:t) { described_class.instance }
+  it_behaves_like "a latin transliterator"
+
+  it "should transliterate various characters" do
+    expect(t.transliterate("ĄąĆćĘꣳŃńÓ󌜏źŻż")).to eql("AaCcEeLlNnOoSsZzZz")
+  end
+
+end
+

data/spec/transliterators/romanian_spec.rb

@@ -13,7 +13,7 @@ describe Babosa::Transliterator::Romanian do
       "Țară"      => "Tara",
       "Șanț"      => "Sant"
     }
-    examples.each {|k, v| t.transliterate(k).should eql(v)}
+    examples.each {|k, v| expect(t.transliterate(k)).to eql(v)}
   end
 
 end

data/spec/transliterators/serbian_spec.rb

@@ -19,7 +19,7 @@ describe Babosa::Transliterator::Serbian do
       "Инђија" => "Indjija",
       "Школа"  => "Shkola",
     }
-    examples.each {|k, v| t.transliterate(k).should eql(v)}
+    examples.each {|k, v| expect(t.transliterate(k)).to eql(v)}
   end
 
 end

data/spec/transliterators/spanish_spec.rb

@@ -7,7 +7,7 @@ describe Babosa::Transliterator::Spanish do
   it_behaves_like "a latin transliterator"
 
   it "should transliterate ñ" do
-    t.transliterate("ñ").should eql("ni")
+    expect(t.transliterate("ñ")).to eql("ni")
   end
 
 end

data/spec/transliterators/swedish_spec.rb

@@ -13,6 +13,6 @@ describe Babosa::Transliterator::Swedish do
       "Åre"    => "Aare",
       "Älskar"  => "Aelskar"
     }
-    examples.each {|k, v| t.transliterate(k).should eql(v)}
+    examples.each {|k, v| expect(t.transliterate(k)).to eql(v)}
   end
 end

data/spec/transliterators/ukrainian_spec.rb

@@ -6,4 +6,83 @@ describe Babosa::Transliterator::Ukrainian do
   let(:t) { described_class.instance }
   it_behaves_like "a cyrillic transliterator"
 
-end
+  it "should transliterate Cyrillic characters" do
+    examples = {
+      "Алушта" => "Alushta",
+      "Андрій" => "Andrii",
+      "Борщагівка" => "Borshchahivka",
+      "Борисенко" => "Borysenko",
+      "Вінниця" => "Vinnytsia",
+      "Володимир" => "Volodymyr",
+      "Гадяч" => "Hadiach",
+      "Богдан" => "Bohdan",
+      "Ґалаґан" => "Galagan",
+      "Ґорґани" => "Gorgany",
+      "Донецьк" => "Donetsk",
+      "Дмитро" => "Dmytro",
+      "Рівне" => "Rivne",
+      "Олег" => "Oleh",
+      "Есмань" => "Esman",
+      "Єнакієве" => "Yenakiieve",
+      "Гаєвич" => "Haievych",
+      "Короп'є" => "Koropie",
+      "Житомир" => "Zhytomyr",
+      "Жанна" => "Zhanna",
+      "Жежелів" => "Zhezheliv",
+      "Закарпаття" => "Zakarpattia",
+      "Казимирчук" => "Kazymyrchuk",
+      "Медвин" => "Medvyn",
+      "Михайленко" => "Mykhailenko",
+      "Іванків" => "Ivankiv",
+      "Іващенко" => "Ivashchenko",
+      "Їжакевич" => "Yizhakevych",
+      "Кадиївка" => "Kadyivka",
+      "Мар'їне" => "Marine",
+      "Йосипівка" => "Yosypivka",
+      "Стрий" => "Stryi",
+      "Олексій" => "Oleksii",
+      "Київ" => "Kyiv",
+      "Коваленко" => "Kovalenko",
+      "Лебедин" => "Lebedyn",
+      "Леонід" => "Leonid",
+      "Миколаїв" => "Mykolaiv",
+      "Маринич" => "Marynych",
+      "Ніжин" => "Nizhyn",
+      "Наталія" => "Nataliia",
+      "Одеса" => "Odesa",
+      "Онищенко" => "Onyshchenko",
+      "Полтава" => "Poltava",
+      "Петро" => "Petro",
+      "Решетилівка" => "Reshetylivka",
+      "Рибчинський" => "Rybchynskyi",
+      "Суми" => "Sumy",
+      "Соломія" => "Solomiia",
+      "Тернопіль" => "Ternopil",
+      "Троць" => "Trots",
+      "Ужгород" => "Uzhhorod",
+      "Уляна" => "Uliana",
+      "Фастів" => "Fastiv",
+      "Філіпчук" => "Filipchuk",
+      "Харків" => "Kharkiv",
+      "Христина" => "Khrystyna",
+      "Біла Церква" => "Bila Tserkva",
+      "Стеценко" => "Stetsenko",
+      "Чернівці" => "Chernivtsi",
+      "Шевченко" => "Shevchenko",
+      "Шостка" => "Shostka",
+      "Кишеньки" => "Kyshenky",
+      "Щербухи" => "Shcherbukhy",
+      "Гоща" => "Hoshcha",
+      "Гаращенко" => "Harashchenko",
+      "Юрій" => "Yurii",
+      "Корюківка" => "Koriukivka",
+      "Яготин" => "Yahotyn",
+      "Ярошенко" => "Yaroshenko",
+      "Костянтин" => "Kostiantyn",
+      "Знам'янка" => "Znamianka",
+      "Феодосія" => "Feodosiia"
+    }
+    examples.each { |k, v| expect(t.transliterate(k)).to eql(v) }
+  end
+
+end