byk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 18a9ea704a27dfc6a2ca4f7fd9b83e05c1f5a57b
+  data.tar.gz: b6490d7a249f5ceb6378d92d6ee63af2424074ab
+SHA512:
+  metadata.gz: 809f4204b60ec626f15aff3e32b8ca4368e0bcecbda1700b039b3edf086853841a6e94c7ef3e9a47003623b9cde0635d555d1d19ccca28220aa165f7a28c8327
+  data.tar.gz: 9a103df7e2976d6ab2574a372479e18f6fccd3c2e005d49e5c464f82befb6942ca19a80091387d67ee85aa98980b2bfe21bf9efada48ad1fec5e817a60d827f8

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Nikola Topalović
+
+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 the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+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.

data/README.md

@@ -0,0 +1,83 @@
+Byk
+===
+
+Fast transliteration of Serbian Cyrillic into Latin.
+
+This package was inspired by @dejan's
+[nice little gem](https://github.com/dejan/srbovanje), but this one
+comes with a C-optimized twist.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "byk"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+```
+$ gem install byk
+```
+
+## Usage
+
+First, make sure to require the gem in your initializer:
+
+```
+require "byk"
+```
+
+This will extend `String` with a couple of simple methods:
+
+```ruby
+"Шеширџија".to_latin         # => "Šeširdžija"
+"Шеширџија".to_ascii_latin   # => "Sesirdzija"
+"Šeširdžija".to_ascii_latin  # => "Sesirdzija"
+```
+
+There's also a destructive version of each:
+
+```ruby
+text = "Жвазбука"
+text.to_latin!        # => "Žvazbuka"
+text                  # => "Žvazbuka"
+text.to_ascii_latin!  # => "Zvazbuka"
+text                  # => "Zvazbuka"
+```
+
+Note that these methods will take into account the
+[special two-letter rules](http://sr.wikipedia.org/wiki/Gajica#Abeceda):
+
+```
+"ĐORĐE Đorđević".to_ascii_latin # => "DJORDJE Djordjevic"
+```
+
+## Notes
+
+### How fast is fast?
+
+About [7x](benchmark) faster than the baseline Ruby implementation on
+my hardware. YMMV of course.
+
+### Compatibility
+
+Byk is supported under MRI Ruby 1.9.3, 2.0, 2.1 and 2.2. Earlier
+versions of MRI are untested.
+
+### Raison d'être
+
+For massive transliteration (e.g. sites supporting dual script
+output), this kind of speed-up might be worthwhile, even with caching.
+
+Also, it's a well-defined problem with hard-set rules which makes it a
+natural target for optimization. Plus, it gave me an excuse to play
+with Ruby extensions, so there :smile_cat:
+
+Уздравље!

data/ext/byk/byk.c

@@ -0,0 +1,303 @@
+#include <stdio.h>
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+#define STR_ENC_GET(str) rb_enc_from_index(ENCODING_GET(str))
+
+#define STR_CAT_COND_ASCII(force_ascii, dest, chr, ascii_chr, len, enc) \
+    force_ascii ? rb_enc_str_buf_cat(dest, chr, len, enc)               \
+                : str_cat_char(dest, ascii_chr, enc)
+
+enum {
+    LAT_CAP_TJ=262,
+    LAT_TJ,
+    LAT_CAP_CH=268,
+    LAT_CH,
+    LAT_CAP_DJ=272,
+    LAT_DJ,
+    LAT_CAP_SH=352,
+    LAT_SH,
+    LAT_CAP_ZH=381,
+    LAT_ZH,
+    CYR_CAP_DJ=1026,
+    CYR_CAP_J=1032,
+    CYR_CAP_LJ,
+    CYR_CAP_NJ,
+    CYR_CAP_TJ,
+    CYR_CAP_DZ=1039,
+    CYR_CAP_A,
+    CYR_CAP_B,
+    CYR_CAP_V,
+    CYR_CAP_G,
+    CYR_CAP_D,
+    CYR_CAP_E,
+    CYR_CAP_ZH,
+    CYR_CAP_Z,
+    CYR_CAP_I,
+    CYR_CAP_K=1050,
+    CYR_CAP_L,
+    CYR_CAP_M,
+    CYR_CAP_N,
+    CYR_CAP_O,
+    CYR_CAP_P,
+    CYR_CAP_R,
+    CYR_CAP_S,
+    CYR_CAP_T,
+    CYR_CAP_U,
+    CYR_CAP_F,
+    CYR_CAP_H,
+    CYR_CAP_C,
+    CYR_CAP_CH,
+    CYR_CAP_SH,
+    CYR_A=1072,
+    CYR_B,
+    CYR_V,
+    CYR_G,
+    CYR_D,
+    CYR_E,
+    CYR_ZH,
+    CYR_Z,
+    CYR_I,
+    CYR_K=1082,
+    CYR_L,
+    CYR_M,
+    CYR_N,
+    CYR_O,
+    CYR_P,
+    CYR_R,
+    CYR_S,
+    CYR_T,
+    CYR_U,
+    CYR_F,
+    CYR_H,
+    CYR_C,
+    CYR_CH,
+    CYR_SH,
+    CYR_DJ=1106,
+    CYR_J=1112,
+    CYR_LJ,
+    CYR_NJ,
+    CYR_TJ,
+    CYR_DZ=1119
+};
+
+static inline unsigned int
+is_upper_case(unsigned int c)
+{
+    return ((c >= 65 && c <= 90)
+            || (c >= CYR_CAP_DJ && c <= CYR_CAP_SH)
+            || c == LAT_CAP_TJ
+            || c == LAT_CAP_CH
+            || c == LAT_CAP_DJ
+            || c == LAT_CAP_SH
+            || c == LAT_CAP_ZH);
+}
+
+
+static void
+str_cat_char(VALUE str, unsigned int c, rb_encoding *enc)
+{
+    char s[16];
+    int n = rb_enc_codelen(c, enc);
+    rb_enc_mbcput(c, s, enc);
+    rb_enc_str_buf_cat(str, s, n, enc);
+}
+
+static VALUE
+str_to_latin(int argc, VALUE *argv, VALUE str, int ascii, int bang)
+{
+    VALUE dest;
+    long dest_len;
+    char *pos, *end;
+    rb_encoding *enc;
+    unsigned int codepoint = 0;
+    unsigned int prev_codepoint = 0;
+    unsigned int next_codepoint = 0;
+
+    rb_check_arity(argc, 0, 1);
+
+    pos = RSTRING_PTR(str);
+    if (!pos || RSTRING_LEN(str) == 0) return str;
+
+    end = RSTRING_END(str);
+    enc = STR_ENC_GET(str);
+    dest_len = RSTRING_LEN(str) + 30; /* TODO len + margin */
+    dest = rb_str_buf_new(dest_len);
+    rb_enc_associate(dest, enc);
+
+    while (pos < end) {
+        int len, force_upper = 0;
+
+        prev_codepoint = codepoint;
+        codepoint = rb_enc_codepoint_len(pos, end, &len, enc);
+        next_codepoint = 0;
+
+        force_upper = prev_codepoint && is_upper_case(prev_codepoint);
+
+        if (!force_upper && (pos + len < end)) {
+            /* TODO Trim down to one rb_enc_codepoint call per iter. */
+            next_codepoint = rb_enc_codepoint(pos + len, end, enc);
+            force_upper = is_upper_case(next_codepoint);
+        }
+
+        /* Latin -> "ASCII latin" conversion */
+        if (ascii && codepoint >= LAT_CAP_TJ && codepoint <= LAT_ZH) {
+            switch (codepoint) {
+            case LAT_TJ:
+            case LAT_CH:     rb_enc_str_buf_cat(dest, "c", 1, enc); break;
+            case LAT_DJ:     rb_enc_str_buf_cat(dest, "dj", 2, enc); break;
+            case LAT_SH:     rb_enc_str_buf_cat(dest, "s", 1, enc); break;
+            case LAT_ZH:     rb_enc_str_buf_cat(dest, "z", 1, enc); break;
+            case LAT_CAP_TJ:
+            case LAT_CAP_CH: rb_enc_str_buf_cat(dest, "C", 1, enc); break;
+            case LAT_CAP_SH: rb_enc_str_buf_cat(dest, "S", 1, enc); break;
+            case LAT_CAP_ZH: rb_enc_str_buf_cat(dest, "Z", 1, enc); break;
+
+            case LAT_CAP_DJ:
+                force_upper ? rb_enc_str_buf_cat(dest, "DJ", 2, enc)
+                            : rb_enc_str_buf_cat(dest, "Dj", 2, enc);
+                break;
+            default:
+                rb_enc_str_buf_cat(dest, pos, len, enc);
+            }
+            pos += len;
+            continue;
+        }
+
+        /* Short-circuit for non-cyrillic codepoints */
+        if (codepoint < CYR_CAP_DJ || codepoint > CYR_DZ) {
+            rb_enc_str_buf_cat(dest, pos, len, enc);
+            pos += len;
+            continue;
+        }
+
+        /* Cyrillic -> latin conversion */
+        switch (codepoint) {
+        case CYR_CAP_J:  rb_enc_str_buf_cat(dest, "J",  1, enc); break;
+        case CYR_CAP_A:  rb_enc_str_buf_cat(dest, "A",  1, enc); break;
+        case CYR_CAP_B:  rb_enc_str_buf_cat(dest, "B",  1, enc); break;
+        case CYR_CAP_V:  rb_enc_str_buf_cat(dest, "V",  1, enc); break;
+        case CYR_CAP_G:  rb_enc_str_buf_cat(dest, "G",  1, enc); break;
+        case CYR_CAP_D:  rb_enc_str_buf_cat(dest, "D",  1, enc); break;
+        case CYR_CAP_E:  rb_enc_str_buf_cat(dest, "E",  1, enc); break;
+        case CYR_CAP_Z:  rb_enc_str_buf_cat(dest, "Z",  1, enc); break;
+        case CYR_CAP_I:  rb_enc_str_buf_cat(dest, "I",  1, enc); break;
+        case CYR_CAP_K:  rb_enc_str_buf_cat(dest, "K",  1, enc); break;
+        case CYR_CAP_L:  rb_enc_str_buf_cat(dest, "L",  1, enc); break;
+        case CYR_CAP_M:  rb_enc_str_buf_cat(dest, "M",  1, enc); break;
+        case CYR_CAP_N:  rb_enc_str_buf_cat(dest, "N",  1, enc); break;
+        case CYR_CAP_O:  rb_enc_str_buf_cat(dest, "O",  1, enc); break;
+        case CYR_CAP_P:  rb_enc_str_buf_cat(dest, "P",  1, enc); break;
+        case CYR_CAP_R:  rb_enc_str_buf_cat(dest, "R",  1, enc); break;
+        case CYR_CAP_S:  rb_enc_str_buf_cat(dest, "S",  1, enc); break;
+        case CYR_CAP_T:  rb_enc_str_buf_cat(dest, "T",  1, enc); break;
+        case CYR_CAP_U:  rb_enc_str_buf_cat(dest, "U",  1, enc); break;
+        case CYR_CAP_F:  rb_enc_str_buf_cat(dest, "F",  1, enc); break;
+        case CYR_CAP_H:  rb_enc_str_buf_cat(dest, "H",  1, enc); break;
+        case CYR_CAP_C:  rb_enc_str_buf_cat(dest, "C",  1, enc); break;
+        case CYR_A:      rb_enc_str_buf_cat(dest, "a",  1, enc); break;
+        case CYR_B:      rb_enc_str_buf_cat(dest, "b",  1, enc); break;
+        case CYR_V:      rb_enc_str_buf_cat(dest, "v",  1, enc); break;
+        case CYR_G:      rb_enc_str_buf_cat(dest, "g",  1, enc); break;
+        case CYR_D:      rb_enc_str_buf_cat(dest, "d",  1, enc); break;
+        case CYR_E:      rb_enc_str_buf_cat(dest, "e",  1, enc); break;
+        case CYR_Z:      rb_enc_str_buf_cat(dest, "z",  1, enc); break;
+        case CYR_I:      rb_enc_str_buf_cat(dest, "i",  1, enc); break;
+        case CYR_K:      rb_enc_str_buf_cat(dest, "k",  1, enc); break;
+        case CYR_L:      rb_enc_str_buf_cat(dest, "l",  1, enc); break;
+        case CYR_M:      rb_enc_str_buf_cat(dest, "m",  1, enc); break;
+        case CYR_N:      rb_enc_str_buf_cat(dest, "n",  1, enc); break;
+        case CYR_O:      rb_enc_str_buf_cat(dest, "o",  1, enc); break;
+        case CYR_P:      rb_enc_str_buf_cat(dest, "p",  1, enc); break;
+        case CYR_R:      rb_enc_str_buf_cat(dest, "r",  1, enc); break;
+        case CYR_S:      rb_enc_str_buf_cat(dest, "s",  1, enc); break;
+        case CYR_T:      rb_enc_str_buf_cat(dest, "t",  1, enc); break;
+        case CYR_U:      rb_enc_str_buf_cat(dest, "u",  1, enc); break;
+        case CYR_F:      rb_enc_str_buf_cat(dest, "f",  1, enc); break;
+        case CYR_H:      rb_enc_str_buf_cat(dest, "h",  1, enc); break;
+        case CYR_C:      rb_enc_str_buf_cat(dest, "c",  1, enc); break;
+        case CYR_J:      rb_enc_str_buf_cat(dest, "j",  1, enc); break;
+        case CYR_LJ:     rb_enc_str_buf_cat(dest, "lj", 2, enc); break;
+        case CYR_NJ:     rb_enc_str_buf_cat(dest, "nj", 2, enc); break;
+        case CYR_DJ:     STR_CAT_COND_ASCII(ascii, dest, "dj", LAT_DJ, 2, enc); break;
+        case CYR_TJ:     STR_CAT_COND_ASCII(ascii, dest, "c", LAT_TJ, 1, enc); break;
+        case CYR_CH:     STR_CAT_COND_ASCII(ascii, dest, "c", LAT_CH, 1, enc); break;
+        case CYR_ZH:     STR_CAT_COND_ASCII(ascii, dest, "z", LAT_ZH, 1, enc); break;
+        case CYR_SH:     STR_CAT_COND_ASCII(ascii, dest, "s", LAT_SH, 1, enc); break;
+        case CYR_CAP_TJ: STR_CAT_COND_ASCII(ascii, dest, "C", LAT_CAP_TJ, 1, enc); break;
+        case CYR_CAP_CH: STR_CAT_COND_ASCII(ascii, dest, "C", LAT_CAP_CH, 1, enc); break;
+        case CYR_CAP_ZH: STR_CAT_COND_ASCII(ascii, dest, "Z", LAT_CAP_ZH, 1, enc); break;
+        case CYR_CAP_SH: STR_CAT_COND_ASCII(ascii, dest, "S", LAT_CAP_SH, 1, enc); break;
+
+        /* Several special cases */
+        case CYR_CAP_LJ:
+            rb_enc_str_buf_cat(dest, (force_upper ? "LJ" : "Lj"), 2, enc);
+            break;
+
+        case CYR_CAP_NJ:
+            rb_enc_str_buf_cat(dest, (force_upper ? "NJ" : "Nj"), 2, enc);
+            break;
+
+        case CYR_CAP_DJ:
+            STR_CAT_COND_ASCII(ascii, dest, (force_upper ? "DJ" : "Dj"), LAT_CAP_DJ, 2, enc);
+            break;
+
+        case CYR_CAP_DZ:
+            rb_enc_str_buf_cat(dest, "D", 1, enc);
+            if (force_upper) {
+                STR_CAT_COND_ASCII(ascii, dest, "Z", LAT_CAP_ZH, 1, enc);
+            }
+            else {
+                STR_CAT_COND_ASCII(ascii, dest, "z", LAT_ZH, 1, enc);
+            }
+            break;
+
+        case CYR_DZ:
+            rb_enc_str_buf_cat(dest, "d", 1, enc);
+            STR_CAT_COND_ASCII(ascii, dest, "z", LAT_ZH, 1, enc);
+            break;
+
+        default:
+            rb_enc_str_buf_cat(dest, pos, len, enc);
+        }
+        pos += len;
+    }
+
+    if (bang) {
+        rb_str_shared_replace(str, dest);
+    }
+    else {
+	OBJ_INFECT(dest, str);
+	str = dest;
+    }
+
+    return str;
+}
+
+static VALUE
+rb_str_to_latin(int argc, VALUE *argv, VALUE str) {
+    return str_to_latin(argc, argv, str, 0, 0);
+}
+
+static VALUE
+rb_str_to_latin_bang(int argc, VALUE *argv, VALUE str) {
+    return str_to_latin(argc, argv, str, 0, 1);
+}
+
+static VALUE
+rb_str_to_ascii_latin(int argc, VALUE *argv, VALUE str) {
+    return str_to_latin(argc, argv, str, 1, 0);
+}
+
+static VALUE
+rb_str_to_ascii_latin_bang(int argc, VALUE *argv, VALUE str) {
+    return str_to_latin(argc, argv, str, 1, 1);
+}
+
+void Init_byk_native(void)
+{
+    rb_define_method(rb_cString, "to_latin",  rb_str_to_latin, -1);
+    rb_define_method(rb_cString, "to_latin!", rb_str_to_latin_bang, -1);
+    rb_define_method(rb_cString, "to_ascii_latin", rb_str_to_ascii_latin, -1);
+    rb_define_method(rb_cString, "to_ascii_latin!", rb_str_to_ascii_latin_bang, -1);
+}

data/ext/byk/extconf.rb

@@ -0,0 +1,2 @@
+require "mkmf"
+create_makefile "byk_native"

data/lib/byk.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+require "byk_native"
+require "byk/version"
+
+module Byk
+
+  AZBUKA      = %w[а б в г д ђ е ж з и ј к л љ м н њ о п р с т ћ у ф х ц ч џ ш]
+  AZBUKA_CAPS = %W[А Б В Г Д Ђ Е Ж З И Ј К Л Љ М Н Њ О П Р С Т Ћ У Ф Х Ц Ч Џ Ш]
+
+  ABECEDA      = %w[a b c č ć d dž đ e f g h i j k l lj m n nj o p r s š t u v z ž]
+  ABECEDA_CAPS = %W[A B C Č Ć D Dž Đ E F G H I J K L Lj M N Nj O P R S Š T U V Z Ž]
+
+end

data/lib/byk/version.rb

@@ -0,0 +1,3 @@
+module Byk
+  VERSION = "0.1.0"
+end

data/spec/byk_spec.rb

@@ -0,0 +1,126 @@
+# coding: utf-8
+
+require "spec_helper"
+
+describe Byk do
+
+  # See http://sr.wikipedia.org/wiki/Панграм
+  let(:pangram) { "фијуче ветар у шибљу, леди пасаже и куће иза њих и гунђа у оџацима." }
+  let(:pangram_latin) { "fijuče vetar u šiblju, ledi pasaže i kuće iza njih i gunđa u odžacima." }
+  let(:pangram_ascii_latin) { "fijuce vetar u siblju, ledi pasaze i kuce iza njih i gundja u odzacima." }
+
+  let(:pangram_caps) { "ФИЈУЧЕ ВЕТАР У ШИБЉУ, ЛЕДИ ПАСАЖЕ И КУЋЕ ИЗА ЊИХ И ГУНЂА У ОЏАЦИМА." }
+  let(:pangram_latin_caps) { "FIJUČE VETAR U ŠIBLJU, LEDI PASAŽE I KUĆE IZA NJIH I GUNĐA U ODŽACIMA." }
+  let(:pangram_ascii_latin_caps) { "FIJUCE VETAR U SIBLJU, LEDI PASAZE I KUCE IZA NJIH I GUNDJA U ODZACIMA." }
+
+  let(:ascii) { "The quick brown fox jumps over the lazy dog." }
+  let(:other) { "संस्कृतम् saṃskṛtam" }
+
+  let(:mixed) { "संस्कृतम् saṃskṛtam илити Sanskrit, obrati ПАЖЊУ." }
+  let(:mixed_latin) { "संस्कृतम् saṃskṛtam iliti Sanskrit, obrati PAŽNJU." }
+  let(:mixed_ascii_latin) { "संस्कृतम् saṃskṛtam iliti Sanskrit, obrati PAZNJU." }
+
+  it "has a version number" do
+    expect(Byk::VERSION).not_to be nil
+  end
+
+  describe "#to_latin" do
+
+    it "doesn't modify an empty string" do
+      expect("".to_latin).to eq ""
+    end
+
+    it "doesn't modify ASCII text" do
+      expect(ascii.to_latin).to eq ascii
+    end
+
+    it "doesn't modify latin" do
+      expect(pangram_latin.to_latin).to eq pangram_latin
+    end
+
+    it "doesn't modify other scripts" do
+      expect(other.to_latin).to eq other
+    end
+
+    it "converts cyrillic to latin" do
+      expect(pangram.to_latin).to eq pangram_latin
+    end
+
+    it "converts cyrillic caps to latin caps" do
+      expect(pangram_caps.to_latin).to eq pangram_latin_caps
+    end
+
+    it "converts mixed text properly" do
+      expect(mixed.to_latin).to eq mixed_latin
+    end
+
+    it "converts AZBUKA to ABECEDA" do
+      expect(Byk::AZBUKA.map(&:to_latin)).to match_array(Byk::ABECEDA)
+    end
+
+    it "converts AZBUKA_CAPS to ABECEDA_CAPS" do
+      expect(Byk::AZBUKA_CAPS.map(&:to_latin)).to match_array(Byk::ABECEDA_CAPS)
+    end
+  end
+
+  describe "#to_ascii_latin" do
+
+    # Special care for Њ, Љ, Ђ, Đ
+    let(:edge_cases) {
+      {
+        "Њ" => "Nj",
+        "Љ" => "Lj",
+        "Ђ" => "Dj",
+        "Đ" => "Dj",
+        "ЊЊ" => "NJNJ",
+        "ЉЉ" => "LJLJ",
+        "ЂЂ" => "DJDJ",
+        "ĐĐ" => "DJDJ",
+        "ГУЊ" => "GUNJ",
+        "ПАСУЉ" => "PASULJ",
+        "ЂУРАЂ" => "DJURADJ",
+        "ĐURAĐ" => "DJURADJ",
+        "ĐURAĐ Đorđević" => "DJURADJ Djordjevic",
+        "ĐURAĐ. Đorđević" => "DJURADJ. Djordjevic"
+      }
+    }
+
+    it "doesn't modify an empty string" do
+      expect("".to_ascii_latin).to eq ""
+    end
+
+    it "doesn't modify ASCII text" do
+      expect(ascii.to_ascii_latin).to eq ascii
+    end
+
+    it "doesn't modify other scripts" do
+      expect(other.to_ascii_latin).to eq other
+    end
+
+    it "converts cyrillic to ASCII latin" do
+      expect(pangram.to_ascii_latin).to eq pangram_ascii_latin
+    end
+
+    it "converts cyrillic caps to ASCII latin caps" do
+      expect(pangram_caps.to_ascii_latin).to eq pangram_ascii_latin_caps
+    end
+
+    it "converts latin to ASCII latin" do
+      expect(pangram_latin.to_ascii_latin).to eq pangram_ascii_latin
+    end
+
+    it "converts latin caps to ASCII latin caps" do
+      expect(pangram_latin_caps.to_ascii_latin).to eq pangram_ascii_latin_caps
+    end
+
+    it "converts mixed text properly" do
+      expect(mixed.to_ascii_latin).to eq mixed_ascii_latin
+    end
+
+    it "converts edge cases properly" do
+      edge_cases.each do |input, output|
+        expect(input.to_ascii_latin).to eq output
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: byk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nikola Topalović
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Provides C-optimized methods for transliteration of Serbian Cyrillic
+  into Latin.
+email: nikola.topalovic@gmail.com
+executables: []
+extensions:
+- ext/byk/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- ext/byk/byk.c
+- ext/byk/extconf.rb
+- lib/byk.rb
+- lib/byk/version.rb
+- spec/byk_spec.rb
+homepage: https://github.com/topalovic/byk
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Fast transliteration of Serbian Cyrillic into Latin.
+test_files:
+- spec/byk_spec.rb