rs_russian 0.7.0

data/lib/russian/locale/pluralization.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*- 
+
+# Правило плюрализации для русского языка, взято из CLDR, http://unicode.org/cldr/
+#
+# Russian language pluralization rules, taken from CLDR project, http://unicode.org/cldr/
+#
+#   one -> n mod 10 is 1 and n mod 100 is not 11;
+#   few -> n mod 10 in 2..4 and n mod 100 not in 12..14;
+#   many -> n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14;
+#   other -> everything else
+#
+# Пример
+#
+#   :one  = 1, 21, 31, 41, 51, 61...
+#   :few  = 2-4, 22-24, 32-34...
+#   :many = 0, 5-20, 25-30, 35-40...
+#   :other = 1.31, 2.31, 5.31...
+{
+  :ru => {
+    :'i18n' => {
+      :plural => {
+        :rule => lambda { |n| 
+          n % 10 == 1 && n % 100 != 11 ? :one : [2, 3, 4].include?(n % 10) && ![12, 13, 14].include?(n % 100) ? :few : n % 10 == 0 || [5, 6, 7, 8, 9].include?(n % 10) || [11, 12, 13, 14].include?(n % 100) ? :many : :other 
+        }
+      }
+    }
+  }
+}

data/lib/russian/locale/transliterator.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*- 
+
+# I18n transliteration delegates to Russian::Transliteration (we're unable
+# to use common I18n transliteration tables with Russian)
+#
+# Правило транслитерации для I18n использует Russian::Transliteration
+# (использовать обычный механизм и таблицу транслитерации I18n с
+# русским языком не получится)
+{
+  :ru => {
+    :i18n => {
+      :transliterate => {
+        :rule => lambda { |str| Russian.transliterate(str) }
+      }
+    }
+  }
+}

data/lib/russian/russian_rails.rb

@@ -0,0 +1,8 @@
+# Rails hacks
+if defined?(ActiveModel)
+  require 'active_model_ext/custom_error_message'
+end
+
+if defined?(ActionView::Helpers)
+  require 'action_view_ext/helpers/date_helper' 
+end

data/lib/russian/transliteration.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*- 
+
+module Russian
+  # Russian transliteration 
+  #
+  # Транслитерация для букв русского алфавита
+  module Transliteration
+    extend self
+
+    # Transliteration heavily based on rutils gem by Julian "julik" Tarkhanov and Co.
+    # <http://rutils.rubyforge.org/>
+    # Cleaned up and optimized.
+
+    LOWER_SINGLE = {
+      "і"=>"i","ґ"=>"g","ё"=>"yo","№"=>"#","є"=>"e",
+      "ї"=>"yi","а"=>"a","б"=>"b",
+      "в"=>"v","г"=>"g","д"=>"d","е"=>"e","ж"=>"zh",
+      "з"=>"z","и"=>"i","й"=>"y","к"=>"k","л"=>"l",
+      "м"=>"m","н"=>"n","о"=>"o","п"=>"p","р"=>"r",
+      "с"=>"s","т"=>"t","у"=>"u","ф"=>"f","х"=>"h",
+      "ц"=>"ts","ч"=>"ch","ш"=>"sh","щ"=>"sch","ъ"=>"'",
+      "ы"=>"y","ь"=>"","э"=>"e","ю"=>"yu","я"=>"ya",
+    }
+    LOWER_MULTI = {
+      "ье"=>"ie",
+      "ьё"=>"ie",
+    }
+
+    UPPER_SINGLE = {
+      "Ґ"=>"G","Ё"=>"YO","Є"=>"E","Ї"=>"YI","І"=>"I",
+      "А"=>"A","Б"=>"B","В"=>"V","Г"=>"G",
+      "Д"=>"D","Е"=>"E","Ж"=>"ZH","З"=>"Z","И"=>"I",
+      "Й"=>"Y","К"=>"K","Л"=>"L","М"=>"M","Н"=>"N",
+      "О"=>"O","П"=>"P","Р"=>"R","С"=>"S","Т"=>"T",
+      "У"=>"U","Ф"=>"F","Х"=>"H","Ц"=>"TS","Ч"=>"CH",
+      "Ш"=>"SH","Щ"=>"SCH","Ъ"=>"'","Ы"=>"Y","Ь"=>"",
+      "Э"=>"E","Ю"=>"YU","Я"=>"YA",
+    }
+    UPPER_MULTI = {
+      "ЬЕ"=>"IE",
+      "ЬЁ"=>"IE",
+    }
+
+    LOWER = (LOWER_SINGLE.merge(LOWER_MULTI)).freeze
+    UPPER = (UPPER_SINGLE.merge(UPPER_MULTI)).freeze
+    MULTI_KEYS = (LOWER_MULTI.merge(UPPER_MULTI)).keys.sort_by {|s| s.length}.reverse.freeze
+    SCAN_REGEX = %r{#{MULTI_KEYS.join '|'}|\w|.}.freeze
+
+    # Transliterate a string with russian characters
+    #
+    # Возвращает строку, в которой все буквы русского алфавита заменены на похожую по звучанию латиницу
+    def transliterate(str)
+      chars = str.scan(SCAN_REGEX)
+
+      result = ''
+
+      chars.each_with_index do |char, index|
+        result << ( LOWER[char] || ( ( upper = UPPER[char] ) ? LOWER[chars[index+1]] ? upper.capitalize : upper : char ) )
+      end
+
+      result
+    end
+  end
+end

data/lib/russian/version.rb

@@ -0,0 +1,9 @@
+module Russian
+  module VERSION
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/russian.rb

@@ -0,0 +1,121 @@
+# coding: utf-8 
+
+$KCODE = 'u' if RUBY_VERSION < "1.9"
+
+require 'i18n'
+
+$:.push File.join(File.dirname(__FILE__), 'russian')
+require 'russian_rails'
+
+if RUBY_ENGINE == "jruby"
+  require 'unicode_utils/upcase'
+else
+  require 'unicode'
+end
+
+module Russian
+  extend self
+
+  autoload :Transliteration, 'transliteration'
+
+  # Russian locale
+  LOCALE = :'ru'
+
+  # Russian locale
+  def locale
+    LOCALE
+  end
+
+  # Regexp machers for context-based russian month names and day names translation
+  LOCALIZE_ABBR_MONTH_NAMES_MATCH = /(%[-_0^#:]*(\d+)*[EO]?d|%[-_0^#:]*(\d+)*[EO]?e)(.*)(%b)/
+  LOCALIZE_MONTH_NAMES_MATCH = /(%[-_0^#:]*(\d+)*[EO]?d|%[-_0^#:]*(\d+)*[EO]?e)(.*)(%B)/
+  LOCALIZE_STANDALONE_ABBR_DAY_NAMES_MATCH = /^%a/
+  LOCALIZE_STANDALONE_DAY_NAMES_MATCH = /^%A/
+
+  # Init Russian i18n: load all translations shipped with library.
+  def init_i18n
+    I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
+    I18n::Backend::Simple.send(:include, I18n::Backend::Transliterator)
+
+    I18n.load_path.unshift(*locale_files)
+
+    I18n.reload!
+  end
+
+  # See I18n::translate
+  def translate(key, options = {})
+    I18n.translate(key, options.merge({ :locale => LOCALE }))
+  end
+  alias :t :translate
+
+  # See I18n::localize
+  def localize(object, options = {})
+    I18n.localize(object, options.merge({ :locale => LOCALE }))
+  end
+  alias :l :localize
+
+  # strftime() proxy with Russian localization
+  def strftime(object, format = :default)
+    localize(object, { :format => check_strftime_format(object, format) })
+  end
+
+  # Simple pluralization proxy
+  #
+  # Usage:
+  #   Russian.pluralize(1, "вещь", "вещи", "вещей")
+  #   Russian.pluralize(3.14, "вещь", "вещи", "вещей", "вещи")
+  #   Russina.pluralize(5, "Произошла %n ошибка", "Произошло %n ошибки", "Произошло %n ошибок")
+  def pluralize(n, *variants)
+    raise ArgumentError, "Must have a Numeric as a first parameter" unless n.is_a?(Numeric)
+    raise ArgumentError, "Must have at least 3 variants for pluralization" if variants.size < 3
+    raise ArgumentError, "Must have at least 4 variants for pluralization" if (variants.size < 4 && n != n.round)
+    variants_hash = pluralization_variants_to_hash(n, *variants)
+    I18n.backend.send(:pluralize, LOCALE, variants_hash, n)
+  end
+  alias :p :pluralize
+
+  # Transliteration for russian language
+  #
+  # Usage:
+  #  Russian.translit("рубин")
+  #  Russian.transliterate("рубин")
+  def transliterate(str)
+    Russian::Transliteration.transliterate(str)
+  end
+  alias :translit :transliterate
+
+  protected
+    
+    def check_strftime_format(object, format)
+      %w(A a B b).each do |key|
+        if format =~ /%\^#{key}/ 
+          if RUBY_ENGINE == "jruby"
+            format = format.gsub("%^#{key}", UnicodeUtils.upcase(localize(object, { :format => "%#{key}" } )))
+          else
+            format = format.gsub("%^#{key}", Unicode::upcase(localize(object, { :format => "%#{key}" } )))
+          end
+        end
+      end
+
+      format
+    end
+
+    # Returns all locale files shipped with library
+    def locale_files
+      Dir[File.join(File.dirname(__FILE__), "russian", "locale", "**/*")]
+    end
+
+    # Converts an array of pluralization variants to a Hash that can be used
+    # with I18n pluralization.
+    def pluralization_variants_to_hash(n, *variants)
+      variants.map!{ |variant| variant.gsub '%n', n.to_s }
+      {
+        :one => variants[0],
+        :few => variants[1],
+        :many => variants[2],
+        :other => variants[3]
+      }
+    end
+end
+
+Russian.init_i18n

data/russian.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+$: << File.expand_path('../lib', __FILE__)
+require 'russian/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rs_russian"
+  spec.version       = Russian::VERSION::STRING
+  spec.authors       = ["glebtv", "Yaroslav Markin"]
+  spec.email         = ["glebtv@gmail.com", "yaroslav@markin.net"]
+  spec.description   = %q{Russian language support for Ruby and Rails}
+  spec.summary       = %q{Russian language support for Ruby and Rails}
+  spec.homepage      = "https://github.com/rs-pro/russian"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'i18n', '~> 0.6.0'
+
+  unless RUBY_PLATFORM =~ /java/
+    spec.add_dependency 'unicode', '~> 0.4.4'
+  else
+    spec.add_dependency 'unicode_utils', '~> 1.4.0'
+  end
+  
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'activesupport', '>= 3.0.0'
+end

data/spec/fixtures/en.yml

@@ -0,0 +1,4 @@
+# Fixture dummy translation
+# Need this to test if we preserve translation data that is already loaded when switching backends
+en:
+  foo: "bar"

data/spec/fixtures/ru.yml

@@ -0,0 +1,4 @@
+ru:
+  date:
+    formats:
+      default: "override"

data/spec/i18n/locale/datetime_spec.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*- 
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe I18n, "Russian Date/Time localization" do
+  before(:all) do
+    Russian.init_i18n
+    @date = Date.parse("1985-12-01")
+    @time = Time.local(1985, 12, 01, 16, 05)
+  end
+
+  describe "with date formats" do
+    it "should use default format" do
+      l(@date).should == "01.12.1985"
+    end
+
+    it "should use short format" do
+      l(@date, :format => :short).should == "01 дек"
+    end
+
+    it "should use long format" do
+      l(@date, :format => :long).should == "01 декабря 1985"
+    end
+  end
+
+  describe "with date day names" do
+    it "should use day names" do
+      l(@date, :format => "%d %B (%A)").should == "01 декабря (воскресенье)"
+      l(@date, :format => "%d %B %Y года было %A").should == "01 декабря 1985 года было воскресенье"
+    end
+
+    it "should use standalone day names" do
+      l(@date, :format => "%A").should == "Воскресенье"
+      l(@date, :format => "%A, %d %B").should == "Воскресенье, 01 декабря"
+    end
+
+    it "should use abbreviated day names" do
+      l(@date, :format => "%a").should == "Вс"
+      l(@date, :format => "%a, %d %b %Y").should == "Вс, 01 дек 1985"
+    end
+
+    it "should use uppercased day names" do
+      Russian::strftime(@date, "%^a").should == "ВС"
+      Russian::strftime(@date, "%^A").should == "ВОСКРЕСЕНЬЕ"
+    end
+  end
+
+  describe "with month names" do
+    it "should use month names" do
+      l(@date, :format => "%d %B").should == "01 декабря"
+      l(@date, :format => "%-d %B").should == "1 декабря"
+
+      if RUBY_VERSION > "1.9.2"
+        l(@date, :format => "%1d %B").should == "1 декабря"
+        l(@date, :format => "%2d %B").should == "01 декабря"
+        l(@date, :format => "%10d %B").should == "0000000001 декабря"
+        l(@date, :format => "%-e %B %Y").should == "1 декабря 1985"
+        l(@date, :format => "%_3d %B %Y").should == "  1 декабря 1985"
+        l(@date, :format => "%3_d %B %Y").should == "%3_d Декабрь 1985"
+      end
+
+      l(@date, :format => "%e %B %Y").should == " 1 декабря 1985"
+      l(@date, :format => "<b>%d</b> %B").should == "<b>01</b> декабря"
+      l(@date, :format => "<strong>%e</strong> %B %Y").should == "<strong> 1</strong> декабря 1985"
+      l(@date, :format => "А было тогда %eе число %B %Y").should == "А было тогда  1е число декабря 1985"
+    end
+
+    it "should use standalone month names" do
+      l(@date, :format => "%B").should == "Декабрь"
+      l(@date, :format => "%B %Y").should == "Декабрь 1985"
+    end
+
+    it "should use abbreviated month names" do
+      @date = Date.parse("1985-03-01")
+      l(@date, :format => "%d %b").should == "01 мар"
+      l(@date, :format => "%e %B %Y").should == " 1 марта 1985"
+      l(@date, :format => "<b>%d</b> %B").should == "<b>01</b> марта"
+      l(@date, :format => "<strong>%e</strong> %B %Y").should == "<strong> 1</strong> марта 1985"
+    end
+
+    it "should use uppercased month names" do
+      Russian::strftime(@date, "%^b").should == "ДЕК"
+      Russian::strftime(@date, "%^B").should == "ДЕКАБРЬ"
+    end
+
+    it "should use standalone abbreviated month names" do
+      @date = Date.parse("1985-03-01")
+      l(@date, :format => "%b").should == "мар"
+      l(@date, :format => "%b %Y").should == "мар 1985"
+    end
+  end
+
+  it "should define default date components order: day, month, year" do
+    I18n.backend.translate(Russian.locale, :"date.order").should == [:day, :month, :year]
+  end
+
+  describe "with time formats" do
+    it "should use default format" do
+      l(@time).should match(/^Вс, 01 дек 1985, 16:05:00/)
+    end
+
+    it "should use short format" do
+      l(@time, :format => :short).should == "01 дек, 16:05"
+    end
+
+    it "should use long format" do
+      l(@time, :format => :long).should == "01 декабря 1985, 16:05"
+    end
+
+    it "should define am and pm" do
+      I18n.backend.translate(Russian.locale, :"time.am").should_not be_nil
+      I18n.backend.translate(Russian.locale, :"time.pm").should_not be_nil
+    end
+  end
+
+  protected
+    def l(object, options = {})
+      I18n.l(object, options.merge( { :locale => Russian.locale }))
+    end
+end

data/spec/i18n/locale/pluralization_spec.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*- 
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe I18n, "Russian pluralization" do
+  before(:each) do
+    @hash = {}
+    %w(one few many other).each do |key|
+      @hash[key.to_sym] = key
+    end
+    @backend = I18n.backend
+  end
+  
+  it "should pluralize correctly" do
+    @backend.send(:pluralize, :'ru', @hash, 1).should == 'one'
+    @backend.send(:pluralize, :'ru', @hash, 2).should == 'few'
+    @backend.send(:pluralize, :'ru', @hash, 3).should == 'few'
+    @backend.send(:pluralize, :'ru', @hash, 5).should == 'many'
+    @backend.send(:pluralize, :'ru', @hash, 10).should == 'many'
+    @backend.send(:pluralize, :'ru', @hash, 11).should == 'many'
+    @backend.send(:pluralize, :'ru', @hash, 21).should == 'one'
+    @backend.send(:pluralize, :'ru', @hash, 29).should == 'many'
+    @backend.send(:pluralize, :'ru', @hash, 131).should == 'one'
+    @backend.send(:pluralize, :'ru', @hash, 1.31).should == 'other'
+    @backend.send(:pluralize, :'ru', @hash, 2.31).should == 'other'
+    @backend.send(:pluralize, :'ru', @hash, 3.31).should == 'other'
+  end
+end

data/spec/locale_spec.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*- 
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Russian, "loading locales" do
+  before(:all) do
+    Russian.init_i18n
+  end
+  
+  %w(
+    date.formats.default
+    date.formats.short
+    date.formats.long
+    date.day_names
+    date.standalone_day_names
+    date.abbr_day_names
+    date.month_names
+    date.standalone_month_names
+    date.abbr_month_names
+    date.standalone_abbr_month_names
+    date.order
+    
+    time.formats.default
+    time.formats.short
+    time.formats.long
+    time.am
+    time.pm
+  ).each do |key| 
+    it "should define '#{key}' in datetime translations" do
+      lookup(key).should_not be_nil
+    end
+  end
+  
+  it "should load pluralization rules" do
+    lookup(:'i18n.plural.rule').should_not be_nil
+    lookup(:'i18n.plural.rule').is_a?(Proc).should be_true
+  end
+
+  it "should load transliteration rule" do
+    lookup(:'i18n.transliterate.rule').should_not be_nil
+    lookup(:'i18n.transliterate.rule').is_a?(Proc).should be_true
+  end
+  
+  def lookup(*args)
+    I18n.backend.send(:lookup, Russian.locale, *args)
+  end
+end

data/spec/russian_spec.rb

@@ -0,0 +1,133 @@
+# -*- encoding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Russian do
+  describe "with locale" do
+    it "should define :'ru' LOCALE" do
+      Russian::LOCALE.should == :'ru'
+    end
+
+    it "should provide 'locale' proxy" do
+      Russian.locale.should == Russian::LOCALE
+    end
+  end
+
+  describe "during i18n initialization" do
+    after(:each) do
+      I18n.load_path = []
+      Russian.init_i18n
+    end
+
+    it "should keep existing translations while switching backends" do
+      I18n.load_path << File.join(File.dirname(__FILE__), 'fixtures', 'en.yml')
+      Russian.init_i18n
+      I18n.t(:foo, :locale => :'en').should == "bar"
+    end
+
+    it "should keep existing :ru translations while switching backends" do
+      I18n.load_path << File.join(File.dirname(__FILE__), 'fixtures', 'ru.yml')
+      Russian.init_i18n
+      I18n.t(:'date.formats.default', :locale => :'ru').should == "override"
+    end
+
+    it "should NOT set default locale to Russian locale" do
+      locale = I18n.default_locale
+      Russian.init_i18n
+      I18n.default_locale.should == locale
+    end
+  end
+
+  describe "with localize proxy" do
+    before(:each) do
+      @time = mock(:time)
+      @options = { :format => "%d %B %Y" }
+    end
+
+    %w(l localize).each do |method|
+      it "'#{method}' should call I18n backend localize" do
+        I18n.should_receive(:localize).with(@time, @options.merge({ :locale => Russian.locale }))
+        Russian.send(method, @time, @options)
+      end
+    end
+  end
+
+  describe "with translate proxy" do
+    before(:all) do
+      @object = :bar
+      @options = { :scope => :foo }
+    end
+
+    %w(t translate).each do |method|
+      it "'#{method}' should call I18n backend translate" do
+        I18n.should_receive(:translate).with(@object, @options.merge({ :locale => Russian.locale }))
+        Russian.send(method, @object, @options)
+      end
+    end
+  end
+
+  describe "strftime" do
+    before(:each) do
+      @time = mock(:time)
+    end
+
+    it "should call localize with object and format" do
+      format = "%d %B %Y"
+      Russian.should_receive(:localize).with(@time, { :format => format })
+      Russian.strftime(@time, format)
+    end
+
+    it "should call localize with object and default format when format is not specified" do
+      Russian.should_receive(:localize).with(@time, { :format => :default })
+      Russian.strftime(@time)
+    end
+  end
+
+  describe "with pluralization" do
+    %w(p pluralize).each do |method|
+      it "'#{method}' should pluralize with variants given" do
+        variants = %w(вещь вещи вещей вещи)
+
+        Russian.send(method, 1, *variants).should == "вещь"
+        Russian.send(method, 2, *variants).should == 'вещи'
+        Russian.send(method, 3, *variants).should == 'вещи'
+        Russian.send(method, 5, *variants).should == 'вещей'
+        Russian.send(method, 10, *variants).should == 'вещей'
+        Russian.send(method, 21, *variants).should == 'вещь'
+        Russian.send(method, 29, *variants).should == 'вещей'
+        Russian.send(method, 129, *variants).should == 'вещей'
+        Russian.send(method, 131, *variants).should == 'вещь'
+        Russian.send(method, 3.14, *variants).should == 'вещи'
+      end
+
+      it "should pluralize with %n as number" do
+        variants = ['Произошла %n ошибка', 'Произошло %n ошибки', 'Произошло %n ошибок', 'Произошло %n ошибки']
+
+        Russian.send(method, 1, *variants).should == 'Произошла 1 ошибка'
+        Russian.send(method, 2, *variants).should == 'Произошло 2 ошибки'
+        Russian.send(method, 3, *variants).should == 'Произошло 3 ошибки'
+        Russian.send(method, 5, *variants).should == 'Произошло 5 ошибок'
+        Russian.send(method, 10, *variants).should == 'Произошло 10 ошибок'
+        Russian.send(method, 21, *variants).should == 'Произошла 21 ошибка'
+        Russian.send(method, 29, *variants).should == 'Произошло 29 ошибок'
+        Russian.send(method, 129, *variants).should == 'Произошло 129 ошибок'
+        Russian.send(method, 131, *variants).should == 'Произошла 131 ошибка'
+        Russian.send(method, 3.14, *variants).should == 'Произошло 3.14 ошибки'
+      end
+
+      it "should raise an exception when first parameter is not a number" do
+        lambda { Russian.send(method, nil, "вещь", "вещи", "вещей") }.should raise_error(ArgumentError)
+        lambda { Russian.send(method, "вещь", "вещь", "вещи", "вещей") }.should raise_error(ArgumentError)
+      end
+
+      it "should raise an exception when there are not enough variants" do
+        lambda { Russian.send(method, 1) }.should raise_error(ArgumentError)
+        lambda { Russian.send(method, 1, "вещь") }.should raise_error(ArgumentError)
+        lambda { Russian.send(method, 1, "вещь", "вещи") }.should raise_error(ArgumentError)
+        lambda { Russian.send(method, 1, "вещь", "вещи", "вещей") }.should_not raise_error(ArgumentError)
+        lambda { Russian.send(method, 3.14, "вещь", "вещи", "вещей") }.should raise_error(ArgumentError)
+        lambda { Russian.send(method, 3.14, "вещь", "вещи", "вещей", "вещи") }.should_not raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*- 
+
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'russian'
+