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

rutils 1.1.4 → 2.0.0

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

@@ -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