julik-rutils 1.0.2

data/lib/gilenson/helper.rb

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*- 
+# Включается на правах хелпера в Rails-приложение
+module RuTils::Gilenson::Helper
+
+  # Возвращает текст обработанный Гиленсоном
+  def gilensize(text, options = {})
+    return "" if text.blank?
+    f = RuTils::Gilenson::Formatter.new
+    f.configure!(options)
+    f.process(text)
+  end
+  
+  # Возвращает текст обработанный Текстилем и Гиленсоном
+  # <i>Метод доступен только при включенном RedCloth</i>
+  def textilize(text)
+    return "" if text.blank?
+    if RuTils.overrides_enabled?
+      RuTils::Gilenson::RedClothExtra.new(text, [ :hard_breaks ]).to_html
+    else
+      super(text)
+    end
+  end
+  
+  # Возвращает текст с кодом Markdown превращенным в HTML, попутно обработанный Гиленсоном
+  # <i>Метод доступен только при наличии BlueCloth</i>.
+  def markdown(text)
+    return "" if text.blank?
+    if RuTils.overrides_enabled?
+      RuTils::Gilenson::BlueClothExtra.new(text).to_html
+    else
+      super(text)
+    end
+  end
+end

data/lib/gilenson/maruku_extra.rb

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*- 
+# Maruku с поддержкой Gilenson
+class RuTils::Gilenson::MarukuExtra < Maruku
+  def to_html(*anything)
+    suspended = super
+    
+    # Return quotes to original state
+    [187, 171, 8220, 8221].map do |e| 
+      suspended.gsub! /&\##{e};/, '"'
+    end
+    
+    # Return spaces to original state
+    [160].map do |e| 
+      suspended.gsub! /&\##{e};/, ' '
+    end
+    
+    suspended.gilensize
+  end
+end

data/lib/gilenson/rdiscount_extra.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*- 
+# RDiscount с поддержкой Gilenson
+class RuTils::Gilenson::RDiscountExtra < RDiscount
+  def to_html(*opts)
+    RuTils::Gilenson::Formatter.new(super(*opts)).to_html
+  end
+end

data/lib/gilenson/redcloth_extra.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*- 
+if RedCloth.class == Module
+  # RedCloth 4 - частичная поддержка
+  class RuTils::Gilenson::RedClothExtra < RedCloth::TextileDoc
+    def to_html(*anything)
+      suspended = super(*anything)
+      
+      # Return quotes to original state
+      [187, 171, 8220, 8221].map do |e| 
+        suspended.gsub! /&\##{e};/, '"'
+      end
+      
+      # Return spaces to original state
+      [160].map do |e| 
+        suspended.gsub! /&\##{e};/, ' '
+      end
+      
+      suspended.gilensize
+    end
+  end
+else 
+  # RedCloth 3 - RuTils выполняет перегрузку Textile Glyphs в RedCloth, перенося форматирование спецсимволов на Gilenson.
+  # Применять как стандартный RedCloth
+  #    RuTils::Gilenson::RedClothExtra.new(some_text).to_html
+  class RuTils::Gilenson::RedClothExtra  < RedCloth
+    # Этот метод в RedCloth при наличии Гиленсона становится заглушкой
+    def htmlesc(text, mode=0)
+      text
+    end
+    
+    # А этот метод обрабатывает Textile Glyphs - ту самую типографицу.
+    # Вместо того чтобы влезать в чужие таблицы мы просто заменим Textile Glyphs на Gilenson - и все будут рады.  
+    def pgl(text) #:nodoc:
+      # Подвешиваем пробелы в начале и в конце каждого блока. Тряпка требует чтобы эти пробелы приехали
+      # назад нетронутыми.
+      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)
+    end
+  end
+end

data/lib/integration/integration.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/rails_date_helper_override' if defined?(ActionView)

data/lib/integration/rails_date_helper_override.rb

@@ -0,0 +1,127 @@
+# -*- encoding: utf-8 -*- 
+module Object::ActionView::Helpers::DateHelper
+  # Несколько хаков для корректной работы модуля с Rails 1.2--2.0 одновременно с Rails 2.1 и выше.
+
+  # Хелперы DateHelper принимают параметр <tt>html_options</tt> (идет последним) начиная с Rails 2.1.
+  # Нужно понять, имеем ли мы дело с Rails 2.1+, для этого проверяем наличие классметода helper_modules у
+  # ActionView::Base, который появился как раз в версии 2.1.
+  DATE_HELPERS_RECEIVE_HTML_OPTIONS = ActionView::Base.respond_to?(:helper_modules) #:nodoc:
+
+  # В Rails Edge (2.1+) определяется <tt>Time.current</tt> для работы с временными зонами.
+  unless Time.respond_to? :current
+    class << ::Time # :nodoc:
+      def current; now; end
+    end
+  end
+
+  # В Rails Edge (2.1+) определяется <tt>Date.current</tt> для работы с временными зонами.
+  unless Date.respond_to? :current
+    class << ::Date # :nodoc:
+      def current; now; end
+    end
+  end
+  
+  # Заменяет <tt>ActionView::Helpers::DateHelper::distance_of_time_in_words</tt> на русское сообщение.
+  #
+  # Целые числа интерпретируются как секунды.
+  # <tt>distance_of_time_in_words(50)</tt> возвращает "меньше минуты".
+  alias :stock_distance_of_time_in_words :distance_of_time_in_words
+  def distance_of_time_in_words(*args)
+    RuTils::overrides_enabled? ? RuTils::DateTime::distance_of_time_in_words(*args) : stock_distance_of_time_in_words
+  end
+
+  # Заменяет ActionView::Helpers::DateHelper::select_month меню выбора русских месяцев.
+  #
+  #   select_month(Date.today)                             # Использует ключи "Январь", "Март"
+  #   select_month(Date.today, :use_month_numbers => true) # Использует ключи "1", "3"
+  #   select_month(Date.today, :add_month_numbers => true) # Использует ключи "1 - Январь", "3 - Март"
+  def select_month(date, options = {}, html_options = {})
+    locale = options[:locale] unless RuTils::overrides_enabled?
+    
+    val = date ? (date.kind_of?(Fixnum) ? date : date.month) : ''
+    if options[:use_hidden]
+      if self.class.private_instance_methods.include? "_date_hidden_html"
+        _date_hidden_html(options[:field_name] || 'month', val, options)
+      else
+        hidden_html(options[:field_name] || 'month', val, options)
+      end
+    else
+      month_options = [] 
+      if RuTils::overrides_enabled?
+        month_names = case true
+          when options[:use_short_month]
+            Date::RU_ABBR_MONTHNAMES
+          # использование в контексте date_select с днями требует родительный падеж
+          when options[:order] && options[:order].include?(:day)
+            Date::RU_INFLECTED_MONTHNAMES
+          else
+            Date::RU_MONTHNAMES
+        end
+      else
+        if defined? I18n
+          month_names = options[:use_month_names] || begin
+            key = options[:use_short_month] ? :'date.abbr_month_names' : :'date.month_names'
+            I18n.translate key, :locale => locale
+          end
+        else
+          month_names = options[:use_short_month] ? Date::ABBR_MONTHNAMES : Date::MONTHNAMES
+        end
+      end
+      month_names.unshift(nil) if month_names.size < 13
+
+      1.upto(12) do |month_number|
+        month_name = if options[:use_month_numbers]
+          month_number
+        elsif options[:add_month_numbers]
+          month_number.to_s + ' - ' + month_names[month_number]
+        else
+          month_names[month_number]
+        end
+  
+        month_options << ((val == month_number) ?
+          content_tag(:option, month_name, :value => month_number, :selected => "selected") :
+          content_tag(:option, month_name, :value => month_number)
+        )
+        month_options << "\n"
+      end
+      
+      if DATE_HELPERS_RECEIVE_HTML_OPTIONS
+        if self.class.private_instance_methods.include? "_date_select_html"
+          _date_select_html(options[:field_name] || 'month', month_options.join, options, html_options)
+        else
+          select_html(options[:field_name] || 'month', month_options.join, options, html_options)
+        end
+      else
+        select_html(options[:field_name] || 'month', month_options.join, options)
+      end
+    end
+  end
+  
+  alias :stock_select_date :select_date
+  # Заменяет ActionView::Helpers::DateHelper::select_date меню выбора русской даты.
+  def select_date(date = Date.current, options = {}, html_options = {})
+    options[:order] ||= [:day, :month, :year]
+    if DATE_HELPERS_RECEIVE_HTML_OPTIONS
+      stock_select_date(date, options, html_options)
+    else
+      stock_select_date(date, options)
+    end
+  end
+end
+
+module Object::ActionView::Helpers
+  if defined?(InstanceTag) && InstanceTag.private_method_defined?(:date_or_time_select)
+    class InstanceTag #:nodoc:
+      private
+        alias :stock_date_or_time_select :date_or_time_select
+        def date_or_time_select(options, html_options = {})
+          options[:order] ||= [:day, :month, :year]
+          if DATE_HELPERS_RECEIVE_HTML_OPTIONS
+            stock_date_or_time_select(options, html_options)
+          else
+            stock_date_or_time_select(options)
+          end
+        end
+    end
+  end
+end

data/lib/integration/rails_pre_filter.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*- 
+class ActionController::Base
+  before_filter { RuTils::overrides = true }
+end

data/lib/pluralizer/pluralizer.rb

@@ -0,0 +1,261 @@
+# -*- 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.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
+    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