rotuka-rutils 0.2.4

data/lib/integration/red_cloth_override.rb

@@ -0,0 +1,27 @@
+if defined?(Object::RedCloth) && !RedCloth.instance_methods.include?(:htmlesc_without_rutils)
+  # RuTils выполняет перегрузку Textile Glyphs в RedCloth, перенося форматирование спецсимволов на Gilenson.
+  class RedCloth  < String #:nodoc:
+    
+    # Этот метод в RedCloth при наличии Гиленсона надо отключать    
+    alias_method  :htmlesc_without_rutils, :htmlesc
+    def htmlesc(text, mode=0) #:nodoc:
+      RuTils::overrides_enabled? ?  text :  htmlesc_without_rutils(text, mode)
+    end
+    
+    # А этот метод обрабатывает Textile Glyphs - ту самую типографицу.
+    # Вместо того чтобы влезать в чужие таблицы мы просто заменим Textile Glyphs на Gilenson - и все будут рады.  
+    alias_method  :pgl_without_rutils, :pgl
+    def pgl(text) #:nodoc:
+      if RuTils::overrides_enabled?
+        # Suspend the spaces in the start and end of the block because Gilenson chews them off, and RedCloth feeds them to us in packs
+        # that appear between tag starts/stops. We mess up the formatting but preserve the spacing.
+        spaces =  Array.new(2,'')
+        text.gsub!(/\A([\s]+)/) { spaces[0] = $1; '' }
+        text.gsub!(/(\s+)\Z/) { spaces[1] = $1; '' }
+        text.replace(spaces[0].to_s + RuTils::Gilenson::Formatter.new(text).to_html + spaces[1].to_s)
+      else
+        pgl_without_rutils(text)
+      end
+    end
+  end 
+end

data/lib/pluralizer/pluralizer.rb

@@ -0,0 +1,236 @@
+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
+    
+    #  Выполняет преобразование числа из цифрого вида в символьное
+    #   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 = ""
+      case rest1
+        when 0 then tens = ""
+        when 1 # особый случай
+          tens = 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: tens = "двадцать "
+        when 3: tens = "тридцать "
+        when 4: tens = "сорок "
+        when 5: tens = "пятьдесят "
+        when 6: tens = "шестьдесят "
+        when 7: tens = "семьдесят "
+        when 8: tens = "восемьдесят "
+        when 9: tens = "девяносто "
+      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
+          when 4
+            ones = "четыре " if end_word = two_items
+          when 5
+            ones = "пять "
+          when 6
+            ones = "шесть "
+          when 7
+            ones = "семь "
+          when 8
+            ones = "восемь "
+          when 9
+            ones = "девять "
+        end
+      end
+
+      # сборка строки
+      st = ''
+      return [(st << hundreds.to_s << tens.to_s  << ones.to_s << end_word.to_s << " " << into.to_s).strip, 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 => "пятнадцать рублей сорок копеек"
+      def rublej
+        RuTils::Pluralization::rublej(self)
+      end
+    end
+  end
+end
+
+class Object::Numeric
+  include RuTils::Pluralization::NumericFormatting
+end
+
+
+class Object::Float
+  include RuTils::Pluralization::FloatFormatting
+end

data/lib/rutils.rb

@@ -0,0 +1,32 @@
+$KCODE = 'u'
+
+# Главный контейнер модуля
+module RuTils
+  # Папка, куда установлен модуль RuTils. Нужно чтобы автоматически копировать RuTils в другие приложения.
+  INSTALLATION_DIRECTORY = File.expand_path(File.dirname(__FILE__) + '/../') #:nodoc:
+  MAJOR = 0
+  MINOR = 2
+  TINY = 3
+
+  # Версия RuTils
+  VERSION = [MAJOR, MINOR ,TINY].join('.') #:nodoc:
+  
+  # Стандартный маркер для подстановок - invalid UTF sequence
+  SUBSTITUTION_MARKER = "\xF0\xF0\xF0\xF0" #:nodoc:
+  
+  def self.load_component(name) #:nodoc:
+    require File.join(RuTils::INSTALLATION_DIRECTORY, "lib", name.to_s, name.to_s)
+  end
+
+  def self.reload_component(name) #:nodoc:
+    load File.join(RuTils::INSTALLATION_DIRECTORY, "lib", name.to_s, "#{name}.rb")
+  end
+end
+
+
+RuTils::load_component :pluralizer #Выбор числительного и сумма прописью
+RuTils::load_component :gilenson # Гиленсон
+RuTils::load_component :datetime # Дата и время без локалей
+RuTils::load_component :transliteration # Транслит
+RuTils::load_component :integration # Интеграция с rails, textile и тд
+RuTils::load_component :countries # Данные о странах на русском и английском

data/lib/transliteration/bidi.rb

@@ -0,0 +1,71 @@
+# Реализует транслитерацию "в обе стороны", дающую возможность автоматически использовать URL как ключ записи
+module RuTils::Transliteration::BiDi
+  TABLE_TO = {
+    "А"=>"A","Б"=>"B","В"=>"V","Г"=>"G","Д"=>"D",
+    "Е"=>"E","Ё"=>"JO","Ж"=>"ZH","З"=>"Z","И"=>"I",
+    "Й"=>"JJ","К"=>"K","Л"=>"L","М"=>"M","Н"=>"N",
+    "О"=>"O","П"=>"P","Р"=>"R","С"=>"S","Т"=>"T",
+    "У"=>"U","Ф"=>"F","Х"=>"KH","Ц"=>"C","Ч"=>"CH",
+    "Ш"=>"SH","Щ"=>"SHH","Ъ"=>"_~","Ы"=>"Y","Ь"=>"_'",
+    "Э"=>"EH","Ю"=>"JU","Я"=>"JA","а"=>"a","б"=>"b",
+    "в"=>"v","г"=>"g","д"=>"d","е"=>"e","ё"=>"jo",
+    "ж"=>"zh","з"=>"z","и"=>"i","й"=>"jj","к"=>"k",
+    "л"=>"l","м"=>"m","н"=>"n","о"=>"o","п"=>"p",
+    "р"=>"r","с"=>"s","т"=>"t","у"=>"u","ф"=>"f",
+    "х"=>"kh","ц"=>"c","ч"=>"ch","ш"=>"sh","щ"=>"shh",
+    "ъ"=>"~","ы"=>"y","ь"=>"'","э"=>"eh","ю"=>"ju",
+    "я"=>"ja",
+    # " "=>"__","_"=>"__"
+    # так сразу не получится, будут проблемы с "Ь"=>"_'"
+  }.sort do |one, two|
+    two[1].split(//).size <=> one[1].split(//).size
+  end
+
+  TABLE_FROM = TABLE_TO.unshift([" ","__"]).clone
+  TABLE_TO.unshift(["_","__"])
+
+  def self.translify(str, allow_slashes = true)
+    slash = allow_slashes ? '/' : '';
+
+    s = str.clone.gsub(/[^\- _0-9a-zA-ZА-ёЁ#{slash}]/, '')
+    lang_fr = s.scan(/[А-ёЁ ]+/)
+    lang_fr.each do |fr|
+      TABLE_TO.each do | translation |
+        fr.gsub!(/#{translation[0]}/, translation[1])
+      end
+    end
+
+    lang_sr = s.scan(/[0-9A-Za-z\_\-\.\/\']+/)
+
+    string = ""
+    if s =~ /\A[А-ёЁ ]/
+      lang_fr, lang_sr = lang_sr, lang_fr
+      string = "+"
+    end
+
+    0.upto([lang_fr.length, lang_sr.length].min-1) do |x|
+      string += lang_sr[x] + "+" + lang_fr[x] + "+";
+    end
+
+    if (lang_fr.length < lang_sr.length)
+      string += lang_sr[lang_sr.length-1]
+    else
+      string[0, string.length-1]
+    end
+  end
+
+  def self.detranslify(str, allow_slashes = true)
+    slash = allow_slashes ? '/' : '';
+
+    str.split('/').inject(out = "") do |out, pg|
+      strings = pg.split('+')
+      1.step(strings.length-1, 2) do |x|
+        TABLE_FROM.each do | translation |
+          strings[x].gsub!(/#{translation[1]}/, translation[0])
+        end
+      end
+      out << slash << strings.to_s
+    end
+    out[slash.length, out.length-slash.length]
+  end
+end

data/lib/transliteration/simple.rb

@@ -0,0 +1,74 @@
+# Реализует простейшую транслитерацию
+#   "вот мы и здесь".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

data/lib/transliteration/transliteration.rb

@@ -0,0 +1,51 @@
+module RuTils
+  module Transliteration #:nodoc:
+  end
+end
+
+require File.join(File.dirname(__FILE__), 'simple')
+require File.join(File.dirname(__FILE__), 'bidi')
+
+    
+# Реализует транслитерацию любого объекта, реализующего String или to_s
+module RuTils::Transliteration::StringFormatting
+  
+  # Транслитерирует строку в латиницу, и возвращает измененную строку
+  def translify
+    RuTils::Transliteration::Simple::translify(self.to_s)
+  end
+
+  # Транслитерирует строку, меняя объект  
+  def translify!
+    self.replace(self.translify)
+  end
+  
+  # Транслитерирует строку, делая ее пригодной для применения как имя директории или URL
+  def dirify
+    RuTils::Transliteration::Simple::dirify(self.to_s)
+  end
+  
+  # Транслитерирует строку (взаимно-однозначный транслит), и возвращает измененную строку
+  def bidi_translify(allow_slashes = true)
+    RuTils::Transliteration::BiDi::translify(self.to_s, allow_slashes)
+  end
+  
+  # Транслитерирует строку (взаимно-однозначный транслит), меняя объект
+  def bidi_translify!(allow_slashes = true)
+    self.replace(RuTils::Transliteration::BiDi::translify(self.to_s, allow_slashes))
+  end
+
+  # Заменяет латиницу на кириллицу (взаимно-однозначный транслит), меняя объект
+  def bidi_detranslify!(allow_slashes = true)
+    self.replace(RuTils::Transliteration::BiDi::detranslify(self.to_s, allow_slashes))
+  end
+  
+  # Заменяет латиницу на кириллицу (взаимно-однозначный транслит), и возвращает измененную строку
+  def bidi_detranslify(allow_slashes = true)
+    RuTils::Transliteration::BiDi::detranslify(self.to_s, allow_slashes)
+  end
+end
+
+class Object::String
+  include RuTils::Transliteration::StringFormatting
+end