RubyGems - rutils - Versions diffs - 1.1.4 → 2.0.0 - Mend

rutils 1.1.4 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

data/.gemtest +0 -0
data/History.txt +10 -0
data/Manifest.txt +4 -8
data/README.txt +20 -172
data/Rakefile.rb +5 -11
data/init.rb +3 -3
data/lib/{gilenson/gilenson_stub.rb → gilenson_stub.rb} +0 -6
data/lib/integration/integration.rb +1 -1
data/lib/integration/rails_date_helper_override.rb +4 -4
data/lib/pluralizer.rb +101 -0
data/lib/rudates.rb +85 -0
data/lib/rutils.rb +13 -7
data/lib/transliteration.rb +30 -0
data/lib/version.rb +1 -1
data/test/extras/integration_rails_filter.rb +1 -1
data/test/extras/integration_rails_gilenson_helpers.rb +1 -1
data/test/extras/integration_rails_helpers.rb +1 -1
data/test/run_tests.rb +1 -1
data/test/test_datetime.rb +16 -7
data/test/test_integration.rb +1 -1
data/test/test_integration_flag.rb +1 -1
data/test/test_pluralize.rb +1 -1
data/test/test_rutils_base.rb +1 -1
data/test/test_transliteration.rb +1 -32
metadata +45 -32
data/bin/rutilize +0 -38
data/lib/countries/countries.rb +0 -1773
data/lib/datetime/datetime.rb +0 -83
data/lib/pluralizer/pluralizer.rb +0 -288
data/lib/transliteration/bidi.rb +0 -21
data/lib/transliteration/simple.rb +0 -75
data/lib/transliteration/transliteration.rb +0 -79

data/lib/datetime/datetime.rb DELETED

@@ -1,83 +0,0 @@
-# -*- encoding: utf-8 -*-
-module RuTils
-  module DateTime
-    def self.distance_of_time_in_words(from_time, to_time = 0, include_seconds = false, absolute = false) #nodoc
-      from_time = from_time.to_time if from_time.respond_to?(:to_time)
-      to_time   = to_time.to_time if to_time.respond_to?(:to_time)
-      distance_in_minutes = (((to_time - from_time).abs)/60).round
-      distance_in_seconds = ((to_time - from_time).abs).round
-      case distance_in_minutes
-        when 0..1
-          return (distance_in_minutes==0) ? 'меньше минуты' : '1 минуту' unless include_seconds
-        case distance_in_seconds
-           when 0..5   then 'менее 5 секунд'
-           when 6..10  then 'менее 10 секунд'
-           when 11..20 then 'менее 20 секунд'
-           when 21..40 then 'пол-минуты'
-           when 41..59 then 'меньше минуты'
-           else             '1 минуту'
-         end
-         when 2..45      then distance_in_minutes.to_s +
-                              " " + distance_in_minutes.items("минута", "минуты", "минут")
-         when 46..90     then 'около часа'
-         # исключение, сдвигаем на один влево чтобы соответствовать падежу
-         when 90..1440   then "около " + (distance_in_minutes.to_f / 60.0).round.to_s +
-                              " " + (distance_in_minutes.to_f / 60.0).round.items("часа", 'часов', 'часов')
-         when 1441..2880 then '1 день'
-         else                  (distance_in_minutes / 1440).round.to_s +
-                              " " + (distance_in_minutes / 1440).round.items("день", "дня", "дней")
-       end
-    end
-    def self.ru_strftime(time, format_str='%d.%m.%Y')
-      clean_fmt = format_str.to_s.gsub(/%{2}/, RuTils::SUBSTITUTION_MARKER).
-        gsub(/%a/, Date::RU_ABBR_DAYNAMES[time.wday]).
-        gsub(/%A/, Date::RU_DAYNAMES[time.wday]).
-        gsub(/%b/, Date::RU_ABBR_MONTHNAMES[time.mon]).
-        gsub(/%d(\s)*%B/, '%02d' % time.day + '\1' + Date::RU_INFLECTED_MONTHNAMES[time.mon]).
-        gsub(/%e(\s)*%B/, '%d' % time.day + '\1' + Date::RU_INFLECTED_MONTHNAMES[time.mon]).
-        gsub(/%B/, Date::RU_MONTHNAMES[time.mon]).
-        gsub(/#{RuTils::SUBSTITUTION_MARKER}/, '%%')
-      # Теперь когда все нужные нам маркеры заменены можно отдать это стандартному strftime
-      time.respond_to?(:strftime_norutils) ? time.strftime_norutils(clean_fmt) : time.to_time.strftime_norutils(clean_fmt)
-    end
-  end
-end
-class Date
-  RU_MONTHNAMES = [nil] + %w{ январь февраль март апрель май июнь июль август сентябрь октябрь ноябрь декабрь }
-  RU_DAYNAMES = %w(воскресенье понедельник вторник среда четверг пятница суббота)
-  RU_ABBR_MONTHNAMES = [nil] + %w{ янв фев мар апр май июн июл авг сен окт ноя дек }
-  RU_ABBR_DAYNAMES = %w(вск пн вт ср чт пт сб)
-  RU_INFLECTED_MONTHNAMES = [nil] + %w{ января февраля марта апреля мая июня июля августа сентября октября ноября декабря }
-  RU_DAYNAMES_E = [nil] + %w{первое второе третье четвёртое пятое шестое седьмое восьмое девятое десятое одиннадцатое двенадцатое тринадцатое четырнадцатое пятнадцатое шестнадцатое семнадцатое восемнадцатое девятнадцатое двадцатое двадцать тридцатое тридцатьпервое}
-end
-class Time
-  alias_method :strftime_norutils, :strftime
-  def strftime(fmt)
-    RuTils::overrides_enabled? ? RuTils::DateTime::ru_strftime(self, fmt) : strftime_norutils(fmt)
-  end
-end
-class Date
-  # Inside rails we have date formatting
-  if self.instance_methods.include?('strftime')
-    alias_method :strftime_norutils, :strftime
-    def strftime(fmt='%F')
-      RuTils::overrides_enabled? ? RuTils::DateTime::ru_strftime(self, fmt) : strftime_norutils(fmt)
-    end
-  else
-    def strftime(fmt='%F')
-      RuTils::overrides_enabled? ? RuTils::DateTime::ru_strftime(self, fmt) : to_time.strftime(fmt)
-    end
-  end
-end

data/lib/pluralizer/pluralizer.rb DELETED

@@ -1,288 +0,0 @@
-# -*- encoding: utf-8 -*-
-module RuTils
-  module Pluralization #:nodoc:
-    # Выбирает нужный падеж существительного в зависимости от числа
-    def self.choose_plural(amount, *variants)
-      variant = (amount%10==1 && amount%100!=11 ? 1 : amount%10>=2 && amount%10<=4 && (amount%100<10 || amount%100>=20) ? 2 : 3)
-      variants[variant-1]
-    end
-    # Выводит целое или дробное число как сумму в рублях прописью
-    def self.rublej(amount)
-      pts = []
-      pts << RuTils::Pluralization::sum_string(amount.to_i, 1, "рубль", "рубля", "рублей") unless amount.to_i == 0
-      if amount.kind_of?(Float)
-        remainder = (amount.divmod(1)[1]*100).round
-        if (remainder == 100)
-          pts = [RuTils::Pluralization::sum_string(amount.to_i+1, 1, 'рубль', 'рубля', 'рублей')]
-        else
-          pts << RuTils::Pluralization::sum_string(remainder.to_i, 2, 'копейка', 'копейки', 'копеек')
-        end
-      end
-      pts.join(' ')
-    end
-    # Выводит целое или дробное число как сумму в гривнах прописью
-    def self.griven(amount)
-      pts = []
-      pts << RuTils::Pluralization::sum_string(amount.to_i, 2, "гривна", "гривны", "гривен") unless amount.to_i == 0
-      if amount.kind_of?(Float)
-        remainder = (amount.divmod(1)[1]*100).round
-        if (remainder == 100)
-          pts = [RuTils::Pluralization::sum_string(amount.to_i+1, 2, 'гривна', 'гривны', 'гривен')]
-        else
-          pts << RuTils::Pluralization::sum_string(remainder.to_i, 2, 'копейка', 'копейки', 'копеек')
-        end
-      end
-      pts.join(' ')
-    end
-    def self.kopeek(amount)
-      pts = []
-      r, k = (amount/100.0).floor, (amount - ((amount/100.0).floor * 100)).to_i
-      pts << RuTils::Pluralization::sum_string(r, 1, "рубль", "рубля", "рублей") unless r.zero?
-      pts << RuTils::Pluralization::sum_string(k, 2, 'копейка', 'копейки', 'копеек') unless k.zero?
-      pts.join(' ')
-    end
-    #  Выполняет преобразование числа из цифрого вида в символьное
-    #   amount - числительное
-    #   gender   = 1 - мужской, = 2 - женский, = 3 - средний
-    #   one_item - именительный падеж единственного числа (= 1)
-    #   two_items - родительный падеж единственного числа (= 2-4)
-    #   five_items - родительный падеж множественного числа ( = 5-10)
-    def self.sum_string(amount, gender, one_item='', two_items='', five_items='')
-        into = ''
-        tmp_val ||= 0
-        return "ноль " + five_items if amount == 0
-        tmp_val = amount
-        # единицы
-        into, tmp_val = sum_string_fn(into, tmp_val, gender, one_item, two_items, five_items)
-        return into if tmp_val == 0
-        # тысячи
-        into, tmp_val = sum_string_fn(into, tmp_val, 2, "тысяча", "тысячи", "тысяч")
-        return into if tmp_val == 0
-        # миллионы
-        into, tmp_val = sum_string_fn(into, tmp_val, 1, "миллион", "миллиона", "миллионов")
-        return into if tmp_val == 0
-        # миллиардов
-        into, tmp_val = sum_string_fn(into, tmp_val, 1, "миллиард", "миллиарда", "миллиардов")
-        return into
-    end
-    private
-    def self.sum_string_fn(into, tmp_val, gender, one_item='', two_items='', five_items='')
-      rest, rest1, end_word, ones, tens, hundreds = [nil]*6
-      #
-      rest = tmp_val % 1000
-      tmp_val = tmp_val / 1000
-      if rest == 0
-        # последние три знака нулевые
-        into = five_items + " " if into == ""
-        return [into, tmp_val]
-      end
-      #
-      # начинаем подсчет с Rest
-      end_word = five_items
-      # сотни
-      hundreds = case rest / 100
-        when 0 then ""
-        when 1 then "сто "
-        when 2 then "двести "
-        when 3 then "триста "
-        when 4 then "четыреста "
-        when 5 then "пятьсот "
-        when 6 then "шестьсот "
-        when 7 then "семьсот "
-        when 8 then "восемьсот "
-        when 9 then "девятьсот "
-      end
-      # десятки
-      rest = rest % 100
-      rest1 = rest / 10
-      ones = ""
-      tens = case rest1
-        when 0 then ""
-        when 1 # особый случай
-          case rest
-            when 10 then "десять "
-            when 11 then "одиннадцать "
-            when 12 then "двенадцать "
-            when 13 then "тринадцать "
-            when 14 then "четырнадцать "
-            when 15 then "пятнадцать "
-            when 16 then "шестнадцать "
-            when 17 then "семнадцать "
-            when 18 then "восемнадцать "
-            when 19 then "девятнадцать "
-          end
-        when 2 then "двадцать "
-        when 3 then "тридцать "
-        when 4 then "сорок "
-        when 5 then "пятьдесят "
-        when 6 then "шестьдесят "
-        when 7 then "семьдесят "
-        when 8 then "восемьдесят "
-        when 9 then "девяносто "
-      end
-      #
-      if rest1 < 1 or rest1 > 1 # единицы
-        case rest % 10
-          when 1
-            ones = case gender
-              when 1 then "один "
-              when 2 then "одна "
-              when 3 then "одно "
-            end
-            end_word = one_item
-          when 2
-            if gender == 2
-              ones = "две "
-            else
-              ones = "два "
-            end
-            end_word = two_items
-          when 3
-            ones = "три " if end_word = two_items # TODO - WTF?
-          when 4
-            ones = "четыре " if end_word = two_items  # TODO - WTF?
-          when 5
-            ones = "пять "
-          when 6
-            ones = "шесть "
-          when 7
-            ones = "семь "
-          when 8
-            ones = "восемь "
-          when 9
-            ones = "девять "
-        end
-      end
-      # сборка строки
-      plural = [hundreds, tens, ones, end_word,  " ",  into].join.strip
-      return [plural, tmp_val]
-    end
-    # Реализует вывод прописью любого объекта, реализующего Float
-    module FloatFormatting
-      # Выдает сумму прописью с учетом дробной доли. Дробная доля округляется до миллионной, или (если
-      # дробная доля оканчивается на нули) до ближайшей доли ( 500 тысячных округляется до 5 десятых).
-      # Дополнительный аргумент - род существительного (1 - мужской, 2- женский, 3-средний)
-      def propisju(gender = 2)
-        raise "Это не число!" if self.nan?
-        st = RuTils::Pluralization::sum_string(self.to_i, gender, "целая", "целых", "целых")
-        remainder = self.to_s.match(/\.(\d+)/)[1]
-        signs = remainder.to_s.size- 1
-        it = [["десятая", "десятых"]]
-        it << ["сотая", "сотых"]
-        it << ["тысячная", "тысячных"]
-        it << ["десятитысячная", "десятитысячных"]
-        it << ["стотысячная", "стотысячных"]
-        it << ["миллионная", "милллионных"]
-        it << ["десятимиллионная", "десятимилллионных", "десятимиллионных"]
-        it << ["стомиллионная", "стомилллионных", "стомиллионных"]
-        it << ["миллиардная", "миллиардных", "миллиардных"]
-        it << ["десятимиллиардная", "десятимиллиардных", "десятимиллиардных"]
-        it << ["стомиллиардная", "стомиллиардных", "стомиллиардных"]
-        it << ["триллионная", "триллионных", "триллионных"]
-        while it[signs].nil?
-          remainder = (remainder/10).round
-          signs = remainder.to_s.size- 1
-        end
-        suf1, suf2, suf3 = it[signs][0], it[signs][1], it[signs][2]
-        st + " " + RuTils::Pluralization::sum_string(remainder.to_i, 2, suf1, suf2, suf2)
-      end
-      def propisju_items(gender=1, *forms)
-        if self == self.to_i
-          return self.to_i.propisju_items(gender, *forms)
-        else
-          self.propisju(gender) + " " + forms[1]
-        end
-      end
-    end
-    # Реализует вывод прописью любого объекта, реализующего Numeric
-    module NumericFormatting
-      # Выбирает корректный вариант числительного в зависимости от рода и числа и оформляет сумму прописью
-      #   234.propisju => "двести сорок три"
-      #   221.propisju(2) => "двести двадцать одна"
-      def propisju(gender = 1)
-        RuTils::Pluralization::sum_string(self, gender, "")
-      end
-      def propisju_items(gender=1, *forms)
-        self.propisju(gender) + " " + RuTils::Pluralization::choose_plural(self.to_i, *forms)
-      end
-      # Выбирает корректный вариант числительного в зависимости от рода и числа. Например:
-      # * 4.items("колесо", "колеса", "колес") => "колеса"
-      def items(one_item, two_items, five_items)
-        RuTils::Pluralization::choose_plural(self, one_item, two_items, five_items)
-      end
-      # Выводит сумму в рублях прописью. Например:
-      # * (15.4).rublej => "пятнадцать рублей сорок копеек"
-      # * 1.rubl        => "один рубль"
-      # * (3.14).rublja => "три рубля четырнадцать копеек"
-      def rublej
-        RuTils::Pluralization::rublej(self)
-      end
-      alias :rubl   :rublej
-      alias :rublja :rublej
-      # Выводит сумму в гривнах прописью. Например:
-      # * (15.4).griven => "пятнадцать гривен сорок копеек"
-      # * 1.grivna      => "одна гривна"
-      # * (3.14).grivny => "три гривны четырнадцать копеек"
-      def griven
-        RuTils::Pluralization::griven(self)
-      end
-      alias :grivna :griven
-      alias :grivny :griven
-    end
-    module FixnumFormatting
-      def kopeek
-        RuTils::Pluralization.kopeek(self)
-      end
-      alias :kopeika   :kopeek
-      alias :kopeiki :kopeek
-    end
-  end
-end
-class Object::Numeric
-  include RuTils::Pluralization::NumericFormatting
-end
-class Object::Fixnum
-  include RuTils::Pluralization::FixnumFormatting
-end
-class Object::Float
-  include RuTils::Pluralization::FloatFormatting
-end

data/lib/transliteration/bidi.rb DELETED

@@ -1,21 +0,0 @@
-# -*- encoding: utf-8 -*-
-# ++DEPRECATED++ Этот модуль удален и присутствует только для выдачи сообщения об ошибке.
-module RuTils::Transliteration::BiDi
-  ERR = "Equivalent bidirectional transliteration for URLs is malpractice. BiDi translit has been removed from RuTils"
-  extend self
-  # ++DEPRECATED++
-  def translify(str, allow_slashes = true)
-    bail!
-  end
-  # ++DEPRECATED++
-  def detranslify(str, allow_slashes = true)
-    bail!
-  end
-  def bail! #:nodoc:
-    raise RuTils::RemovedFeature, ERR
-  end
-end

data/lib/transliteration/simple.rb DELETED

@@ -1,75 +0,0 @@
-# -*- encoding: utf-8 -*-
-# Реализует простейшую транслитерацию
-#   "вот мы и здесь".translify => "vot my i zdes"
-#   "vot my i zdes".detranslify => "вот мы и здесь"
-module RuTils::Transliteration::Simple
-  TABLE_LOWER = {
-     "і"=>"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","ъ"=>"'",
-     "ы"=>"yi","ь"=>"","э"=>"e","ю"=>"yu","я"=>"ya"
-  }.sort do | one, two|
-    two[1].size <=> one[1].size
-  end
-  TABLE_UPPER =  {
-    "Ґ"=>"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","Ъ"=>"'","Ы"=>"YI","Ь"=>"",
-     "Э"=>"E","Ю"=>"YU","Я"=>"YA",
-  }.sort do | one, two|
-     two[1].size <=> one[1].size
-  end
-  TABLE = TABLE_UPPER + TABLE_LOWER
-  # Заменяет кириллицу в строке на латиницу. Немного специфично потому что поддерживает
-  # комби-регистр (Щука -> Shuka)
-  def self.translify(str)
-    chars = str.split(//)
-    lowers = TABLE_LOWER.map{|e| e[0] }
-    uppers = TABLE_UPPER.map{|e| e[0] }
-    hashtable = {}
-    TABLE.each do | item |
-      next unless item[0] && item[1]
-      hashtable[item[0]] = item[1]
-    end
-    result = ''
-    chars.each_with_index do | char, index |
-      if uppers.include?(char) && lowers.include?(chars[index+1])
-        # Combined case. Here we deal with Latin letters so there is no problem to use
-        # Ruby's builtin upcase_downcase
-        ch = hashtable[char].downcase.capitalize
-        result << ch
-      elsif uppers.include?(char)
-        result << hashtable[char]
-      elsif lowers.include?(char)
-        result << hashtable[char]
-      else
-        result << char
-      end
-    end
-    return result
-  end
-  # Транслитерирует строку, делая ее пригодной для применения как имя директории или URL
-  def self.dirify(string)
-    st = self.translify(string)
-    st.gsub!(/(\s\&\s)|(\s\&amp\;\s)/, ' and ') # convert & to "and"
-    st.gsub!(/\W/, ' ')  #replace non-chars
-    st.gsub!(/(_)$/, '') #trailing underscores
-    st.gsub!(/^(_)/, '') #leading unders
-    st.strip.translify.gsub(/(\s)/,'-').downcase.squeeze('-')
-  end
-end