ru_translit 0.0.3

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+nbproject/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ru_translit.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    ru_translit (0.0.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ru_translit!

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011 Johannes Stein
+
+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,26 @@
+# ru_translit
+
+A simple Object with two class methods for transliterating russian cyrillic words to latin,
+and for detransliterating transliterated words from latin back to cyrillic. At this point,
+it does not follow any one specific transliteration ruleset, but uses a variation of German,
+English and (simplified) scientific transliteration rules. It is meant to be a very pragmatic, catch-all
+way of getting different real-world variants of how a given word might be transliterated or detransliterated.
+Each of the two methods returns an array of words.
+
+The detransliteration method has an optional second parameter that decides whether the returned
+cyrillic options should include those whose only difference to another option is that it includes one
+or more softeners, which are usually not transliterated. This parameter defaults to false.
+
+What's special about this is that it takes the context of letters in the word into account in order to find out
+whether certain options are to be included. Most other transliteration tools don't do this.
+
+## Install
+
+    gem install ru_translit
+
+## Usage
+
+    require 'ru_translit'
+    RuTranslit.to_cyrillic 'vodka' # => ["водка"]
+    RuTranslit.to_latin 'водка' # => ["vodka", "wodka"]
+    RuTranslit.to_cyrillic 'vodka', true # => ["водка", "водкьа", "водька", "водькьа"]

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/detranslit_rules.rb

@@ -0,0 +1,191 @@
+# coding: utf-8
+class DetranslitRules
+  
+  def self.rules
+    RULES
+  end
+  
+  # arrays: [output, predecessor-rule, successor-rule, softener-if-0]
+  RULES = {
+    'a' => [
+      ['а', /.*/, /.*/, 1]
+    ],
+    'b' => [
+      ['б', /.*/, /.*/, 1],
+      ['бь', /.*/, /[a,e,i,ja,ya,ju,yu]|^$/, 0]
+    ],
+    'c' => [
+      ['ц', /.*/, /.*/, 1]
+    ],
+    'd' => [
+      ['д', /.*/, /.*/, 1],
+      ['дь', /.*/, /[ja,e,m,b,k,ju,yu,s]|^$/, 0]
+    ],
+    'e' => [
+      ['е', /.*/, /.*/, 1]
+    ],
+    'f' => [
+      ['ф', /.*/, /.*/, 1],
+      ['фь', /.*/, /[ja,ya,e,je,o]|^$/, 0]
+    ],
+    'g' => [
+      ['г', /.*/, /.*/, 1]
+    ],
+    'h' => [
+      ['х', /.*/, /.*/, 1]
+    ],
+    'i' => [
+      ['и', /.*/, /.*/, 1],
+      ['ы', /.+/, /.*/, 1],
+      ['ий', /.+/, /^$/, 1]
+    ],
+    'j' => [
+      ['й', /.*/, /.*/, 1]
+    ],
+    'k' => [
+      ['к', /.*/, /.*/, 1],
+      ['кь', /.*/, /[ja,ya]/, 0]  #
+    ],
+
+    'l' => [
+      ['л', /.*/, /.*/, 1]
+    ],
+    'm' => [
+      ['м', /.*/, /.*/, 1]#,
+#      ['мь', /[a,e,i,o,u,ju,yu,ja,ya]/, /[e,ja,ya,d,s,ju,yu]|^$/, 0]
+#      ['мь', /[e]/, /[e]/, 0]
+    ],
+    'n' => [
+      ['н',/.*/,/.*/, 1],
+#      ['нь', /[a,e,o,u,i,y,ja,ya,ju,yu,z,r,s,g]/, /[k,e,ja,sh,sch,o,i,g,-,ju,yu,zh,ch,tsch,b,d,s]|^$/, 0]
+      ['нь', /[a,e,o,u,i,y,ja,ya]/, /[k,e,ja,sh,sch,o,i,g]|^$/, 0]
+    ],
+    'o' => [
+      ['о', /.*/, /.*/, 1]
+    ],
+    'p' => [
+      ['п', /.*/, /.*/, 1],
+      ['пь', /.*/, /[ja,ya,e,ju,yu]|^$/, 0]
+    ],
+    'q' => [
+      ['', /.*/, /.*/, 1]
+    ],
+    'r' => [
+      ['р', /.*/, /.*/, 1],
+#      ['рь', /[a,o,e,u,y,i,b,ja,ju,t,p,kh,ch]/, /[e,k,ja,ya,m,c,-,i,b,tsch,ch,g]|^$/, 0]
+      ['рь', /[a,o,e,u,y,i,b]/, /[e,k,ja,ya,m]|^$/, 0]
+    ],
+    's' => [
+      ['с', /.*/, /.*/, 1],
+#      ['сь', /.*/, /[m,e,k,b,ja,ya,ju,yu,o]|^$/, 0]
+      ['сь', /[i,o,e]/, /[m,e]|^$/, 0]
+    ],
+    't' => [
+      ['т', /.*/, /.*/, 1],
+#      ['ть', /[a,i,s,ja,ya,u,e,y,o,z,r,l,f,n]/, /[s,e,ja,ya,ju,yu,i,-,b,m,f,k,d,u,v,w]|^$/, 0],
+      ['ть', /[a,i,s,ja,ya,u,e,y,o,z,r]/, /[s,e,ja,ya,ju,yu,i,-]|^$/, 0],
+    ],
+    'u' => [
+      ['у', /.*/, /.*/, 1]
+    ],
+    'v' => [
+      ['в', /.*/, /.*/, 1],
+      ['вь', /.*/, /[ju,yu,e,i]|^$/, 0]
+    ],
+    'w' => [
+      ['в', /.*/, /.*/, 1],
+      ['вь', /.+/, /[ju,yu,e,i]|^$/, 0],
+      ['вь', /.*/, /[ju,yu,e,i]/, 0]
+    ],
+    'x' => [
+      ['кс', /.*/, /.*/, 1]
+    ],
+    'y' => [
+      ['ы', /.*/, /.*/, 1]
+    ],
+    'z' => [
+      ['з', /.*/, /.*/, 1],
+      ['зь', /.*/, /[ja,ya,b,e,m,k]|^$/, 0]
+    ],
+    "'" => [
+      ['ь', /.+/, /.*/, 0]
+    ],
+    # english letter combinations
+    'ch' => [
+      ['ч', /.*/, /.*/, 1],
+      ['чь', /.*/, /[s,e,i,ja,ya,ju,yu,-]|^$/, 0]
+    ],
+    'кн' => [
+      ['х', /.*/, /.*/, 1]
+    ],
+    'yu' => [
+      ['ю', /.*/, /.*/, 1]
+    ],
+    'ya' => [
+      ['я', /.*/, /.*/, 1]
+    ],
+    'yo' => [
+      ['е', /.*/, /.*/, 1]
+    ],
+    'sh' => [
+      ['ш', /.*/, /.*/, 1],
+      ['шь', /.*/, /[ja,ya,e,s]|^$/, 0]
+    ],
+    'shch' => [
+      ['щ', /.*/, /.*/, 1],
+      ['щь', /.*/, /^$/, 0]
+    ],
+    'ts' => [
+      ['ц', /.*/, /.*/, 1]
+    ],
+    'zh' => [
+      ['ж', /.*/, /.*/, 1],
+      ['жь', /.*/, /[e,i,ja,ya]|^$/, 0]
+    ],
+    # german letter combinations
+    'sch' => [
+      ['ш', /.*/, /.*/, 1], #de
+      ['щ', /.*/, /.*/, 1], #en
+      ['шь', /.*/, /^$/, 0]
+      #maschadov ?
+    ],
+    'tsch' => [
+      ['ч', /.*/, /.*/, 1],
+      ['чь', /.*/, /[s,e,i,ja,ya,ju,yu,-]|^$/, 0]
+    ],
+    'schtsch' => [
+      ['щ', /.*/, /.*/, 1]
+    ],
+    'ju' => [
+      ['ю', /.*/, /.*/, 1]
+    ],
+    'ja' => [
+      ['я', /.*/, /.*/, 1]
+    ],
+#    'je' => [
+#      ['е', /.*/, /.*/, 1],
+#      ['же', /.*/, /.*/, 1],
+#    ],
+    'jo' => [
+      ['е', /.*/, /.*/, 1]
+    ],
+    'ä' => [
+      ['я', /.*/, /.*/, 1]
+    ],
+    'ö' => [
+      ['ё', /.*/, /.*/, 1]
+    ],
+    'ü' => [
+      ['ю', /.*/, /.*/, 1]
+    ],
+    'ß' => [
+      ['с', /.*/, /.*/, 1]
+    ],
+    'je' => [
+      ['е', /.*/, /.*/, 1],
+      #['йе', /.*/, /.*/, 1],
+      ['же', /^$/, /.*/, 1]
+    ]
+    # TODO scientific letter combinations
+  }
+end

data/lib/detransliterator.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+require_relative 'word'
+
+#TODO check if a word is german or english, then don't detransliterate, right?
+
+# Pass in a word and get some detransliteration suggestions based on our ruleset,
+# which covers german and english transliterations. If softeners are to be included,
+# the returned lists can get quite long.
+class Detransliterator
+  #returns an array of cyrillic options for the passed-in word (just one word at a time!)
+  def self.cyrillic_options(input, include_softeners)
+    data = Word.detransliterations_for(input, include_softeners)
+    options = data[:options]
+    Word.output_words options
+  end
+end

data/lib/ru_translit.rb

@@ -0,0 +1,37 @@
+require 'unicode_utils/downcase'
+require 'transliterator'
+require 'detransliterator'
+
+# Transliteration as well as De-/Retransliteration between russian cyrillic and
+# English, German and Scientific transliterations. Accounts for context-dependent
+# transliteration rules.
+# Current limitations:
+# * Only one word per pass (technically, it should work for multiple words,
+#   but the number of variations returned likely grows beyond manageability).
+# * Everything will be downcased.
+# * No distinction between the different translit variants: Just one list with all possible options gets returned.
+module RuTranslit
+
+  # De-transliterates a single latin word to cyrillic. returns an array of possible cyrillic strings
+  # if include_softeners is true, variations including only the positioning of softeners get added
+  # to the returned array as well. considers mainly German and English transliteration variants.
+  def self.to_cyrillic latin_term, include_softeners=false
+    latin_term = UnicodeUtils.downcase(latin_term) #generally, the regular downcase should be fine here, but doesn't hurt like this.
+    Detransliterator.cyrillic_options(latin_term, include_softeners)
+  end
+
+  # Transliterates a single cyrillic word to latin. Returns an array of possible latin strings.
+  # Considers mainly English, German and scientific (mostly minus the diacritics) transliteration variants.
+  def self.to_latin cyrillic_term
+    cyrillic_term = UnicodeUtils.downcase(cyrillic_term) #generally, the regular downcase should be fine here, but doesn't hurt like this.
+    Transliterator.translit_options(cyrillic_term)
+  end
+
+  # Short forms of the main methods.
+  class << self
+    alias to_cy to_cyrillic
+    alias to_la to_latin
+    alias detransliterate to_cyrillic
+    alias transliterate to_latin
+  end
+end

data/lib/translit_rules.rb

@@ -0,0 +1,151 @@
+# coding: utf-8
+class TranslitRules
+  
+  def self.rules
+    RULES
+  end
+  
+  # arrays: [output, predecessor-rule, successor-rule, softener-if-0]
+  #source: mainly https://secure.wikimedia.org/wikipedia/de/wiki/Kyrillisch#Russisch
+  RULES = {
+    'а' => [
+      ['a', /.*/, /.*/, 1]
+    ],
+    'б' => [
+      ['b', /.*/, /.*/, 1]
+    ],
+    'в' => [
+      ['v', /.*/, /.*/, 1], #sc, en
+      ['w', /.*/, /.*/, 1] #de
+    ],
+    'г' => [
+      ['g', /.*/, /.*/, 1],
+      ['w', /[eo]/, /o/, 1] #de bei genitiv-wendung
+    ],
+    'д' => [
+      ['d', /.*/, /.*/, 1]
+    ],
+    'е' => [
+      ['e', /.*/, /.*/, 1],
+      ['je', /^$|[аоуыэяёюиеь]/, /.*/, 1], #de, am anfang oder nach vokal
+      ['ye', /^$|[аоуыэяёюиеь]/, /.*/, 1], #en, ''
+      ['jo', /[р]/, /.*/, 1]  #de, not official, for book_id 44460
+    ],
+    'ё' => [
+      ['ë', /.*/, /.*/, 1], #sc
+      ['jo', /[^жчшщ]/, /.*/, 1], #de
+      ['e', /[жчшщ]/, /.*/, 1], #de
+      ['yo', /[^жчшщ]/, /.*/, 1], #en
+      ['o', /[жчшщ]/, /.*/, 1] #en
+    ],
+    'ж' => [
+      #['ž', /.*/, /.*/, 1], #sc
+      ['z', /.*/, /.*/, 1], #sc
+      ['sch', /.*/, /.*/, 1], #de
+      ['sh', /.*/, /.*/, 1], #de (ddr?)
+      ['zh', /.*/, /.*/, 1], #en
+    ],
+    'з' => [
+      ['z', /.*/, /.*/, 1], #sc, en
+      ['s', /.*/, /.*/, 1], #de
+    ],
+    'и' => [
+      ['i', /.*/, /.*/, 1], #sc, en, de
+      ['ji', /ь/, /.*/, 1], #de
+      ['yi', /ь/, /.*/, 1], #en
+    ],
+    'й' => [
+      ['j', /.*/, /.*/, 1], #sc
+      ['i', /.*/, /.*/, 1], #de, sometimes also 'j', but that's already covered with sc.
+      ['y', /.*/, /.*/, 1], #en
+    ],
+    'к' => [
+      ['k', /.*/, /.*/, 1], #sc, de, en
+      #['x', /.*/, /c/, 1], #de?
+    ],
+    'л' => [
+      ['l', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'м' => [
+      ['m', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'н' => [
+      ['n', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'о' => [
+      ['o', /.*/, /.*/, 1], #sc, de, en
+      ['jo', /ь/, /.*/, 1], #de
+      ['yo', /ь/, /.*/, 1], #en
+    ],
+    'п' => [
+      ['p', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'р' => [
+      ['r', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'с' => [
+      ['s', /.*/, /.*/, 1], #sc, de, en
+      ['ss', /[аоуыэяёюие]/, /[аоуыэяёюие]/, 1], #de, between vowels
+    ],
+    'т' => [
+      ['t', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'у' => [
+      ['u', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'ф' => [
+      ['f', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'х' => [
+      ['ch', /.*/, /.*/, 1], #sc, de
+      ['kh', /.*/, /.*/, 1], #en
+      ['h', /.*/, /.*/, 1], #not officially, for author of book_id 37718
+    ],
+    'ц' => [
+      ['c', /.*/, /.*/, 1], #sc
+      ['z', /.*/, /.*/, 1], #de
+      ['ts', /.*/, /.*/, 1], #en
+    ],
+    'ч' => [
+      #['č', /.*/, /.*/, 1], #sc
+      ['c', /.*/, /.*/, 1], #sc
+      ['tsch', /.*/, /.*/, 1], #de
+      ['ch', /.*/, /.*/, 1], #en
+    ],
+    'ш' => [
+      #['š', /.*/, /.*/, 1], #sc
+      ['s', /.*/, /.*/, 1], #sc
+      ['sch', /.*/, /.*/, 1], #de
+      ['sh', /.*/, /.*/, 1], #en
+    ],
+    'щ' => [
+      #['šč', /.*/, /.*/, 1], #sc
+      ['sc', /.*/, /.*/, 1], #sc
+      ['schtsch', /.*/, /.*/, 1], #de
+      #['stsch', /.*/, /.*/, 1], #de (ddr)
+      ['shch', /.*/, /.*/, 1], #en
+    ],
+    'ъ' => [
+      ['"', /.*/, /.*/, 1], #sc
+      #hardener, generally not transcribed for de and en
+    ],
+    'ы' => [
+      ['y', /.*/, /.*/, 1], #sc, de, en
+    ],
+    'ь' => [
+      ["'", /.*/, /.*/, 1], #sc
+    ],
+    'э' => [
+      ["ė", /.*/, /.*/, 1], #sc
+      ["e", /.*/, /.*/, 1], #de, en
+    ],
+    'ю' => [
+      ["ju", /.*/, /.*/, 1], #sc, de
+      ["yu", /.*/, /.*/, 1], #en
+    ],
+    'я' => [
+      ["ja", /.*/, /.*/, 1], #sc, de
+      ["ya", /.*/, /.*/, 1], #en
+    ]
+  }
+end

data/lib/transliteration/version.rb

@@ -0,0 +1,3 @@
+module RuTranslit
+  VERSION = "0.0.3"
+end

data/lib/transliterator.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+require_relative 'word'
+
+# Pass in a word and get some transliteration suggestions based on our ruleset,
+# which covers german, english and scientific transliterations.
+class Transliterator
+  # Returns an array of cyrillic options for the passed-in word (just one word at a time!)
+  def self.translit_options(input)
+    data = Word.transliterations_for(input)
+    options = data[:options]
+    Word.output_words options
+  end
+end

data/lib/word.rb

@@ -0,0 +1,98 @@
+# coding: utf-8
+require_relative 'word_part'
+
+@@max_checked_string_length = 7 # To accomodate 'schtsch' or s.th like that.
+
+class Word
+  def self.detransliterations_for(word, include_softeners, is_detranslit=true)
+    last_part = build_word_part_structure word, is_detranslit
+    first_part = add_link_to_succ_to_each_word_part(last_part)
+    input_structure = word_input_structure(first_part)
+    wps_options = [] #this will be filled with lists of possible cyrillic output (2d-array then)
+    part = first_part
+    until part.nil? do
+      wps_options << part.cyrillic_options(include_softeners)
+      part = part.succ
+    end
+    {:input_structure => input_structure, :options => wps_options}
+  end
+
+  def self.transliterations_for(word)
+    self.detransliterations_for(word, true, false)
+  end
+  
+  #transform 2d-options-array two an array of cyrillic words.
+  def self.output_words part_options
+    part_options.map!{|a| a.size==0 ? nil : a} #delete empty option arrays
+    part_options.compact!
+    get_part_combinations '', part_options, []
+  end
+
+  
+private
+  #builds a singly linked list, and returns the last item
+  def self.build_word_part_structure word, is_detranslit
+    rest_size = [word.size-@@max_checked_string_length,0].max #size of the chunk from the beginning of word to be checked for any matching wordparts
+    offset = 0 #offset from the beginning of the word --do we need this at all?
+    cy_result = ""
+    prev_wp = nil #previous wordpart (relative to current. nil for first wordpart)
+    while(word && word.size>0) do
+      #in die liste schaun. wenn ja, dann offset = rest_size
+      chunk = word[0..(-1-rest_size)]
+      if WordPart.has_rules?(chunk, is_detranslit) #if there are rules for this chunk
+        wp = WordPart.new(chunk, prev_wp, is_detranslit)#cy_result << new_cy_char
+        prev_wp = wp
+        offset = word.size-rest_size
+        word = word[(offset)..-1] #cut the word to the rest of the string that has to be put into the wp-structure
+        rest_size = [word.size-@@max_checked_string_length,0].max
+      elsif chunk.size > 0 #no rules found, so make chunk one letter shorter
+        rest_size += 1
+      else #no rules found and chunk is empty. meaning: no rules for the current word's first character. which means: just keep it.
+        offset = word.size-rest_size+1
+        wp = WordPart.new(word[0..offset-1], prev_wp, is_detranslit)
+        prev_wp = wp
+        wp.just_thru = true
+        word = word[(offset)..-1]
+        rest_size = [word.size-@@max_checked_string_length,0].max
+      end
+    end
+    prev_wp
+  end
+  
+  #go thru the linked list and add the next to each (except the last of course). return the first.
+  def self.add_link_to_succ_to_each_word_part last
+    part = last
+    until part.prev.nil? do
+      prev = part.prev
+      prev.succ = part
+      part = prev
+    end
+    part
+  end
+  
+  #just for debugging: return an array of the input parts, how the input has been split into wordparts
+  def self.word_input_structure first_part
+    ret = []
+    part = first_part
+    until part.nil? do
+      ret << part.input
+      part = part.succ
+    end
+    ret
+  end
+  
+  #go through the 2d-array of wordpart-options and build a list of words from all possible combinations  
+  def self.get_part_combinations(str, arr_in, arr_out)
+    if arr_in.size == 0
+      arr_out << str
+      return arr_out
+    end
+    cur_arr = arr_in[0]
+    cur_arr.each do |w|
+      w2 = str == "" ? w : str + w
+      arr_out = arr_out | get_part_combinations(w2, arr_in[1..-1], arr_out) #merge the two arrays. may be faster with just adding, not merging, since there won't be any duplicates anyway
+    end
+    arr_out
+  end
+
+end

data/lib/word_part.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+require_relative 'translit_rules'
+require_relative 'detranslit_rules'
+
+class WordPart
+  attr_accessor :input, :prev, :succ, :static_output, :just_thru #may be more restricted than this
+  @prev, @succ = nil
+  @just_thru = false
+  @input = nil
+  @is_detranslit = nil
+  
+  # arrays: [output, predecessor-rule, successor-rule]
+  DT_RULES = DetranslitRules.rules
+  T_RULES = TranslitRules.rules
+  
+  def initialize input, prev, detranslit=true
+    @input = input
+    @prev = prev
+    @is_detranslit = detranslit
+  end
+  
+  def self.has_rules? input, is_detranslit
+    if is_detranslit
+      DT_RULES.has_key? input
+    else
+      T_RULES.has_key? input
+    end
+  end
+  
+  #return array of (cyrillic) strings which can be empty (or nil instead?) --should we cache the result? i think it's called no more than once.
+  def cyrillic_options(include_softeners)
+    return [input] if just_thru #this can be set to accomodate for untranslatable characters.
+    ret = []
+    arr = @is_detranslit ? DT_RULES[input] : T_RULES[input]
+    if arr #there are rules for this part, now see if any of them match
+      arr.each do |rule|
+        if match?(rule, include_softeners)
+          ret << rule[0]
+        end
+      end
+    end
+    ret
+  end
+  
+private  
+  def match?(rule, include_softeners) #rule is expected to be an array of the form [output, prev-rule, succ-rule, priority(0 is for softeners)]
+    prev_input = prev.nil? ? '' : prev.input
+    succ_input = succ.nil? ? '' : succ.input
+    (prev_input =~ rule[1]) && (succ_input =~ rule[2]) && (rule[3]>0 || include_softeners)
+  end
+
+end

data/ru_translit.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "transliteration/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ru_translit"
+  s.version     = RuTranslit::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Johannes Stein"]
+  s.email       = ["johannes@unsyn.com"]
+  s.homepage    = "http://rubygems.org/gems/ru_translit"
+  s.summary     = %q{Get a list of latin transliterations from a cyrillic word and vice versa.}
+  s.description = %q{Transliterations and detransliterations, using English, German and scientific transliteration variants.}
+
+  s.rubyforge_project = "ru_translit"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/ru_translit_spec.rb

@@ -0,0 +1,76 @@
+#coding: utf-8
+require 'ru_translit'
+
+describe RuTranslit do
+  before(:each) do
+    @la_str = 'something'
+    @cy_str = 'что-то'
+    @cy_str2 = 'биографиями'
+    @nr = '123'
+  end
+
+  it "should respond to the two main methods for transliteration and detransliteration" do
+    RuTranslit.should respond_to('to_latin')
+    RuTranslit.should respond_to('to_cyrillic')
+  end
+
+  it "should respond to some short or alternative forms for the two main methods" do
+    RuTranslit.should respond_to('to_la')
+    RuTranslit.should respond_to('to_cy')
+    RuTranslit.should respond_to('transliterate')
+    RuTranslit.should respond_to('detransliterate')
+  end
+
+  it "should return an array containing only the input when given a lowercase latin string to transliterate" do
+    RuTranslit.to_latin(@la_str).should be_an_instance_of(Array)
+    RuTranslit.to_latin(@la_str).should have(1).items
+    RuTranslit.to_latin(@la_str).first.should == @la_str
+  end
+
+  it "should return an array containing only the input when given a lowercase cyrillic string to detransliterate" do
+    RuTranslit.to_latin(@cy_str).should be_an_instance_of(Array)
+    RuTranslit.to_latin(@cy_str).should have_at_least(1).items
+    RuTranslit.to_cyrillic(@cy_str).first.should == @cy_str
+  end
+
+  it "should leave numbers alone in both directions" do
+    RuTranslit.to_latin(@nr).should have(1).item
+    RuTranslit.to_latin(@nr).first.should == @nr
+    RuTranslit.to_cyrillic(@nr).should have(1).item
+    RuTranslit.to_cyrillic(@nr).first.should == @nr
+  end
+
+  it "should preserve latin word-parts while transliterating cyrillic word-parts" do
+    RuTranslit.to_latin(@cy_str + @la_str + @cy_str).first.should =~ /#{@la_str}/
+  end
+
+  it "should return a list of several transliterations for the russian word 'биографиями'" do
+    RuTranslit.to_latin(@cy_str2).should have_at_least(2).items
+    RuTranslit.to_latin(@cy_str2).should have_at_most(4).items #making sure it doesn't explode for some reason
+  end
+
+  it "should return (among others) the original input if we do a 'round-trip' cy->la->cy, using the first result" do
+    RuTranslit.to_cyrillic(RuTranslit.to_latin(@cy_str2).first).should include(@cy_str2)
+  end
+
+  it "should return (among others) the original input if we do a 'round-trip' la->cy->la, using the first result" do
+    RuTranslit.to_latin(RuTranslit.to_cyrillic(@la_str).first).should include(@la_str)
+  end
+
+  it "should offer cyrillic alternatives for 'schtsch', at least one of which should be only one letter long" do
+    RuTranslit.to_cyrillic('schtsch').should include('щ')
+  end
+
+  it "should return different transliteration results depending on context in some cases" do
+    RuTranslit.to_latin('де').should include('de')
+    RuTranslit.to_latin('де').should_not include('dje')
+    RuTranslit.to_latin('е').should include('je')
+  end
+
+  it "should include softeners in the detransliteration results (only) if called with the appropriate argument" do
+    RuTranslit.to_cyrillic('f', false).should_not include('фь')
+    RuTranslit.to_cyrillic('f', true).should include('фь')
+  end
+
+end
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: ru_translit
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Johannes Stein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-22 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Transliterations and detransliterations, using English, German and scientific transliteration variants.
+email: 
+- johannes@unsyn.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/detranslit_rules.rb
+- lib/detransliterator.rb
+- lib/ru_translit.rb
+- lib/translit_rules.rb
+- lib/transliteration/version.rb
+- lib/transliterator.rb
+- lib/word.rb
+- lib/word_part.rb
+- ru_translit.gemspec
+- spec/ru_translit_spec.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/ru_translit
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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: ru_translit
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Get a list of latin transliterations from a cyrillic word and vice versa.
+test_files: []
+