rutils 0.2.0 → 0.2.1

data/CHANGELOG

@@ -1,3 +1,6 @@
+Версия 0.2.1 - 02.04.2007
+* Восстановлен в gemspec gilenson.rb (Сергей Барабаш)
+
 Версия 0.2.0 - 02.04.2007
 * Фикс squeeze в dirify (Сергей Барабаш)
 * Формат даты по умолчанию - %F (Сергей Барабаш)

data/lib/gilenson/gilenson.rb

@@ -0,0 +1,617 @@
+module RuTils
+  module Gilenson
+    # Позволяет возвращать класс форматтера при вызове
+    #  RuTils::Gilenson.new
+    def self.new(*args) #:nodoc:
+      RuTils::Gilenson::Formatter.new(*args)
+    end
+    
+    # Загружаем "старый" Гиленсон если он будет нужен
+    def self.const_missing(const) #:nodoc:
+      super(const) unless const == :Obsolete
+      require File.dirname(__FILE__) + '/gilenson_port'
+      return RuTils::Gilenson::Obsolete
+    end
+  end
+end
+
+# ==Что такое Gilenson  
+# Обработчик типографских символов в HTML согласно общепринятым правилам.
+# Посвящается П.Г.Гиленсону[http://www.rudtp.ru/lib.php?book=172], благодаря которому русские правила тех.
+# редактуры еще как минимум 20 лет останутся столь-же бессмысленно старомодными и строгими.
+#
+# Gilenson расставит в тексте "умные" правильные кавычки (русские - для кириллицы, английские - для латиницы),
+# заменит "хитрые" пунктуационные символы на entities и отформатирует знаки типа (c), (tm), телефоны и адреса.
+#
+# Gilenson базируется на коде Typografica[http://pixel-apes.com/typografica] от PixelApes,
+# который был приведен к положенному в Ruby стандарту. Основные отличия Gilenson от Typografica на PHP:
+#   * работа только и полностью в UTF-8 (включая entities, применимые в XML)
+#   * поддержка "raw"-вывода (символов вместо entities) - текст выводимый GIlenson можно верстать на бумаге
+#
+# Если вам нужно получать идентичный Typografica вывод, пользуйтесь RuTils::Gilenson::Obsolete
+# вместо RuTils::Gilenson::Formatter.
+#
+# ==Использование
+# Быстрее всего - через метод ++gilensize++ для любой строковой переменной
+#   %{ И вот они таки "приехали"}.gilensize => 'И вот они таки «приехали»'
+# Все дополнительные настройки в таком случае передаются форматтеру
+#   %{ И вот они таки "приехали"}.gilensize(:laquo=>false) => 'И вот они таки "приехали"'
+#
+# Если форматтер надо настроить более тонко, можно использовать его и так:
+#   typ = RuTils::Gilenson.new('Эти "так называемые" великие деятели')
+#   typ.to_html => 'Эти «так называемые» великие деятели'
+# 
+# или как фильтр
+#   formatter = RuTils::Gilenson.new
+#   formatter.configure(:dash=>true)
+#   for string in strings
+#     puts formatter.process(string)
+#   end
+#
+# ==Настройки
+# Настройки регулируются через методы
+#   formatter.dashglue = true
+# или ассоциированным хешем
+#   formatter.configure!(:dash=>true, :quotes=>false)
+#
+# Хеш также можно передавать как последний аргумент методам process и to_html,
+# в таком случае настройки будут применены только при этом вызове
+#
+#   beautified = formatter.process(my_text, :dash=>true)
+#
+# В параметры можно подставить также ключ :all чтобы временно включить или выключить все фильтры
+#
+#   beautified = formatter.process(my_text, :all=>true)
+#
+# Помимо этого можно пользоваться каждым фильтром по отдельности используя метод +apply+
+#
+# Можно менять глифы, которые форматтер использует для подстановок. К примеру,
+#   formatter.glyph[:nbsp] = ' '
+# заставит форматтер расставлять "традиционные" неразрывные пробелы. Именно это - большая глупость,
+# но другие глифы заменить может быть нужно.
+#
+# ==Настройки форматтера
+#   "inches" - преобразовывать дюймы в знак дюйма;
+#   "laquo" - кавычки-ёлочки
+#   "quotes" - кавычки-английские лапки
+#   "dash" -  проставлять короткое тире (150)
+#   "emdash" - длинное тире двумя минусами (151)
+#   "initials" - проставлять тонкие шпации в инициалах
+#   "copypaste" - замена непечатных и "специальных" юникодных символов на entities
+#   "(c)" - обрабатывать знак копирайта
+#   "(r)", "(tm)", "(p)", "+-" - спецсимволы, какие - понятно
+#   "degrees" - знак градуса
+#   "dashglue", "wordglue" - приклеивание предлогов и дефисов
+#   "spacing" - запятые и пробелы, перестановка
+#   "phones" - обработка телефонов
+#   "html" - при false - запрет использования тагов html
+#   "de_nobr" - при true все <nobr/> заменяются на <span class="nobr"/>
+#   "raw_output" - (по умолчанию false) - при true вместо entities выводятся UTF-символы
+#   "skip_attr" - (по умолчанию false) - при true не отрабатывать типографику в атрибутах тегов (title, alt)
+#   "skip_code" - (по умолчанию true) - при true не отрабатывать типографику внутри <code/>, <tt/>, CDATA
+  
+class RuTils::Gilenson::Formatter
+    attr_accessor :glyph
+  
+    SETTINGS = {
+       "inches"    => true,    # преобразовывать дюймы в знак дюйма;
+       "laquo"     => true,    # кавычки-ёлочки
+       "quotes"    => true,    # кавычки-английские лапки
+       "dash"      => true,    # короткое тире (150)
+       "emdash"    => true,    # длинное тире двумя минусами (151)
+       "initials"  => true,    # тонкие шпации в инициалах
+       "copypaste" => false,   # замена непечатных и "специальных" юникодных символов на entities
+       "(c)"       => true,    # обрабатывать знак копирайта
+       "(r)"       => true,
+       "(tm)"      => true,
+       "(p)"       => true,
+       "+-"        => true,    # спецсимволы, какие - понятно
+       "degrees"   => true,    # знак градуса
+       "dashglue"  => true, "wordglue" => true, # приклеивание предлогов и дефисов
+       "spacing"   => true,    # запятые и пробелы, перестановка
+       "phones"    => true,    # обработка телефонов
+       "html"      => true,    # разрешение использования тагов html
+       "de_nobr"   => false,   # при true все <nobr/> заменяются на <span class="nobr"/>
+       "raw_output" => false,  # выводить UTF-8 вместо entities
+       "skip_attr" => false,   # при true не отрабатывать типографику в атрибутах тегов
+       "skip_code" => true,    # при true не отрабатывать типографику внутри <code/>, <tt/>, CDATA
+     } #:nodoc:
+     
+     # Глифы, использующиеся в подстановках по-умолчанию
+     GLYPHS = {
+       :quot       => "&#34;",     # quotation mark
+       :amp        => "&#38;",     # ampersand
+       :apos       => "&#39;",     # apos
+       :gt         => "&#62;",     # greater-than sign
+       :lt         => "&#60;",     # less-than sign
+       :nbsp       => "&#160;",    # non-breaking space
+       :sect       => "&#167;",    # section sign
+       :copy       => "&#169;",    # copyright sign
+       :laquo      => "&#171;",    # left-pointing double angle quotation mark = left pointing guillemet
+       :reg        => "&#174;",    # registered sign = registered trade mark sign
+       :deg        => "&#176;",    # degree sign
+       :plusmn     => "&#177;",    # plus-minus sign = plus-or-minus sign
+       :para       => "&#182;",    # pilcrow sign = paragraph sign
+       :middot     => "&#183;",    # middle dot = Georgian comma = Greek middle dot
+       :raquo      => "&#187;",    # right-pointing double angle quotation mark = right pointing guillemet
+       :ndash      => "&#8211;",   # en dash
+       :mdash      => "&#8212;",   # em dash
+       :lsquo      => "&#8216;",   # left single quotation mark
+       :rsquo      => "&#8217;",   # right single quotation mark
+       :ldquo      => "&#8220;",   # left double quotation mark
+       :rdquo      => "&#8221;",   # right double quotation mark
+       :bdquo      => "&#8222;",   # double low-9 quotation mark
+       :bull       => "&#8226;",   # bullet = black small circle
+       :hellip     => "&#8230;",   # horizontal ellipsis = three dot leader
+       :numero     => "&#8470;",   # numero
+       :trade      => "&#8482;",   # trade mark sign
+       :minus      => "&#8722;",   # minus sign
+       :inch       => "&#8243;",   # inch/second sign (u0x2033) (не путать с кавычками!)
+       :thinsp     => "&#8201;",   # полукруглая шпация (тонкий пробел)
+       :nob_open   => '<nobr>',    # открывающий блок без переноса слов
+       :nob_close  => '</nobr>',    # открывающий блок без переноса слов
+     } #:nodoc:
+     
+     # Нормальные "типографские" символы в UTF-виде. Браузерами обрабатываются плохонько, поэтому
+     # лучше заменять их на entities.
+     VERBATIM_GLYPHS = {
+       ' '         => :nbsp,# alt+0160 (NBSP here)
+       '«'         => :laquo,
+       '»'         => :raquo,
+       '§'         => :sect,
+       '©'         => :copy,
+       '®'         => :reg,
+       '°'         => :deg,
+       '±'         => :plusmn,
+       '¶'         => :para,
+       '·'         => :middot,
+       '–'         => :ndash,
+       '—'         => :mdash,
+       '‘'         => :lsquo,
+       '’'         => :rsquo,
+       '“'         => :ldquo,
+       '”'         => :rdquo,
+       '„'         => :bdquo,
+       '•'         => :bull,
+       '…'         => :hellip,
+       '№'         => :numero,
+       '™'         => :trade,
+       '−'         => :minus,
+       ' '         => :thinsp,
+       '″'         => :inch,
+      } #:nodoc:
+      
+     # Для маркера мы применяем invalid UTF-sequence чтобы его НЕЛЬЗЯ было перепутать с частью
+     # любого другого мультибайтного глифа. Thanks to huNter.
+     REPLACEMENT_MARKER = RuTils::SUBSTITUTION_MARKER #:nodoc:
+
+     # Кто придумал &#147;? Не учите людей плохому...
+     # Привет А.Лебедеву http://www.artlebedev.ru/kovodstvo/62/
+     # Используем символы, потом берем по символам из glyphs форматтера.
+     # Молодец mash!
+     FORBIDDEN_NUMERIC_ENTITIES = {
+       '132'       => :bdquo,
+       '133'       => :hellip,
+       '146'       => :apos,
+       '147'       => :ldquo,
+       '148'       => :rdquo,
+       '149'       => :bull,
+       '150'       => :ndash,
+       '151'       => :mdash,
+       '153'       => :trade,
+    } #:nodoc:
+    
+    PROTECTED_SETTINGS = [ :raw_output ] #:nodoc:
+         
+    def initialize(*args)
+      @_text = args[0].is_a?(String) ? args[0] : ''
+      setup_default_settings!
+      accept_configuration_arguments!(args.last) if args.last.is_a?(Hash)
+    end
+    
+    # Настраивает форматтер ассоциированным хешем
+    #  formatter.configure!(:dash=>true, :wordglue=>false)
+    def configure!(*config)
+      accept_configuration_arguments!(config.last) if config.last.is_a?(Hash)
+    end
+    
+    alias :configure :configure! #Дружественный API
+  
+    # Неизвестные методы - настройки. С = - установка ключа, без - получение значения
+    def method_missing(meth, *args) #:nodoc:
+      setting = meth.to_s.gsub(/=$/, '')
+      super(meth, *args) unless @settings.has_key?(setting) #this will pop the exception if we have no such setting
+    
+      return (@settings[setting] = args[0])
+    end
+
+    # Обрабатывает text_to_process с сохранением настроек, присвоенных обьекту-форматтеру
+    # Дополнительные аргументы передаются как параметры форматтера и не сохраняются после прогона.
+    def process(text_to_process, *args)
+      @_text = text_to_process
+      if args.last.is_a?(Hash)
+        with_configuration(args.last) { self.to_html }
+      else
+        self.to_html
+      end
+    end
+
+    # Обрабатывает текст, присвоенный форматтеру при создании и возвращает результат обработки.
+    def to_html()
+      return '' unless @_text
+      
+      text = @_text.strip
+
+      # -4. запрет тагов html
+      process_escape_html(text) unless @settings["html"]
+
+      # -3. Никогда (вы слышите?!) не пущать лабуду &#not_correct_number;
+      FORBIDDEN_NUMERIC_ENTITIES.dup.each_pair do | key, rep |
+        text.gsub!(/&##{key};/, glyph[rep])
+      end
+
+      # -2. Чистим copy&paste
+      process_copy_paste_clearing(text) if @settings['copypaste']
+
+      # -1. Замена &entity_name; на входе ('&nbsp;' => '&#160;' и т.д.)
+      process_html_entities(text)
+
+      # 0. Вырезаем таги
+      tags = lift_ignored_elements(text) if @skip_tags
+
+      # 1. Запятые и пробелы
+      process_spacing(text) if @settings["spacing"]
+
+      # 3. Спецсимволы
+      # 0. дюймы с цифрами
+      # заменено на инчи
+      process_inches(text) if @settings["inches"]
+
+      # 1. лапки
+      process_quotes(text) if @settings["quotes"]
+      
+      # 2. ёлочки
+      process_laquo(text) if @settings["laquo"]
+
+      # 2b. одновременно ёлочки и лапки
+      process_compound_quotes(text) if (@settings["quotes"] && @settings["laquo"])
+
+      # 3. тире
+      process_dash(text) if @settings["dash"]
+
+      # 3a. тире длинное
+      process_emdash(text) if @settings["emdash"]
+
+      # 5. +/-
+      process_plusmin(text) if @settings["+-"]
+
+      # 5a. 12^C
+      process_degrees(text) if @settings["degrees"]
+
+      # 6. телефоны
+      process_phones(text) if @settings["phones"]
+
+      # 7. Короткие слова и &nbsp;
+      process_wordglue(text) if @settings["wordglue"]
+
+      # 8. Склейка ласт. Тьфу! дефисов.
+      process_dashglue(text) if @settings["dashglue"]
+
+      # 8a. Инициалы
+      process_initials(text) if @settings['initials']
+
+      # 8b. Троеточия
+      process_ellipsises(text) if @settings["wordglue"]
+      
+      # БЕСКОНЕЧНОСТЬ. Вставляем таги обратно.
+      reinsert_fragments(text, tags) if @skip_tags
+
+      # фуф, закончили.
+      process_span_instead_of_nobr(text) if @settings["de_nobr"]
+
+      # заменяем entities на истинные символы
+      process_raw_output(text) if @settings["raw_output"]
+      
+      text.strip
+    end
+
+    
+    # Применяет отдельный фильтр к text и возвращает результат. Например:
+    #  formatter.apply(:wordglue, "Вот так") => "Вот&#160;так"
+    # Удобно применять когда вам нужно задействовать отдельный фильтр Гиленсона, но не нужна остальная механика
+    # Последний аргумент определяет, нужно ли при применении фильтра сохранить в неприкосновенности таги и другие
+    # игнорируемые фрагменты текста (по умолчанию они сохраняются).
+    def apply(filter, text, lift_ignored_elements = true)
+      copy = text.dup
+      unless lift_ignored_elements
+        self.send("process_#{filter}".to_sym, copy)
+      else
+        lifting_fragments(copy) { self.send("process_#{filter}".to_sym, copy) }
+      end
+      copy
+    end
+          
+    private
+      
+      def setup_default_settings!
+         @skip_tags = true;
+         @ignore = /notypo/ # regex, который игнорируется. Этим надо воспользоваться для обработки pre и code
+
+         @glueleft =  ['рис.', 'табл.', 'см.', 'им.', 'ул.', 'пер.', 'кв.', 'офис', 'оф.', 'г.']
+         @glueright = ['руб.', 'коп.', 'у.е.', 'мин.']
+
+         # Установки можно менять в каждом экземпляре
+         @settings = SETTINGS.dup
+
+         @mark_tag = REPLACEMENT_MARKER
+         # Глифы можено подменять в экземпляре форматтера поэтому копируем их из константы
+         @glyph = GLYPHS.dup
+         
+         @phonemasks = [[  /([0-9]{4})\-([0-9]{2})\-([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2})/,
+                           /([0-9]{4})\-([0-9]{2})\-([0-9]{2})/,
+                           /(\([0-9\+\-]+\)) ?([0-9]{3})\-([0-9]{2})\-([0-9]{2})/,
+                           /(\([0-9\+\-]+\)) ?([0-9]{2})\-([0-9]{2})\-([0-9]{2})/,
+                           /(\([0-9\+\-]+\)) ?([0-9]{3})\-([0-9]{2})/,
+                           /(\([0-9\+\-]+\)) ?([0-9]{2})\-([0-9]{3})/,
+                           /([0-9]{3})\-([0-9]{2})\-([0-9]{2})/,
+                           /([0-9]{2})\-([0-9]{2})\-([0-9]{2})/,
+                           /([0-9]{1})\-([0-9]{2})\-([0-9]{2})/,
+                           /([0-9]{2})\-([0-9]{3})/,
+                           /([0-9]+)\-([0-9]+)/,
+                         ],[    
+                          ':nob_open\1:ndash\2:ndash\3:nbsp\4:\5:\6:nob_close',
+                          ':nob_open\1:ndash\2:ndash\3:nob_close',
+                          ':nob_open\1:nbsp\2:ndash\3:ndash\4:nob_close',
+                          ':nob_open\1:nbsp\2:ndash\3:ndash\4:nob_close',
+                          ':nob_open\1:nbsp\2:ndash\3:nob_close',
+                          ':nob_open\1:nbsp\2:ndash\3:nob_close',
+                          ':nob_open\1:ndash\2:ndash\3:nob_close',
+                          ':nob_open\1:ndash\2:ndash\3:nob_close',
+                          ':nob_open\1:ndash\2:ndash\3:nob_close',
+                          ':nob_open\1:ndash\2:nob_close',
+                          ':nob_open\1:ndash\2:nob_close'
+                       ]]
+      end
+      
+      # Позволяет получить процедуру, при вызове возвращающую значение глифа
+      def lookup(glyph_to_lookup)
+        return Proc.new { self.glyph[glyph_to_lookup] }
+      end
+
+      # Подставляет "символы" (двоеточие + имя глифа) на нужное значение глифа заданное в данном форматтере
+      def substitute_glyphs_in_string(str)
+        re = str.dup
+        @glyph.each_pair do | key, subst |
+          re.gsub!(":#{key.to_s}", subst)
+        end
+        re
+      end
+
+      # Выполняет блок, временно включая настройки переданные в +hash+
+      def with_configuration(hash, &block)
+        old_settings, old_glyphs = @settings.dup, @glyph.dup
+        accept_configuration_arguments!(hash)
+          txt = yield
+        @settings, @glyph = old_settings, old_glyphs
+        
+        return txt
+      end
+      
+      def accept_configuration_arguments!(args_hash)
+        
+        # Специальный случай - :all=>true|false
+        if args_hash.has_key?(:all)
+          if args_hash[:all]
+            @settings.each_pair {|k, v| @settings[k] = true unless PROTECTED_SETTINGS.include?(k.to_sym)}
+          else
+            @settings.each_pair {|k, v| @settings[k] = false unless PROTECTED_SETTINGS.include?(k.to_sym)}
+          end
+        else     
+          
+          # Кинуть ошибку если настройка нам неизвестна
+          unknown_settings = args_hash.keys.collect{|k|k.to_s} - @settings.keys.collect { |k| k.to_s } 
+          raise RuTils::Gilenson::UnknownSetting, unknown_settings if unknown_settings.any?
+               
+          args_hash.each_pair do | key, value |
+            @settings[key.to_s] = (value ? true : false)
+          end
+        end
+      end
+
+      # Вынимает игнорируемые фрагменты и заменяет их маркером, выполняет переданный блок и вставляет вынутое на место
+      def lifting_fragments(text, &block)
+        lifted = lift_ignored_elements(text)
+          yield
+        reinsert_fragments(text, lifted)
+      end
+      
+      #Вынимает фрагменты из текста и возвращает массив с фрагментами
+      def lift_ignored_elements(text)
+       #     re =  /<\/?[a-z0-9]+("+ # имя тага
+        #                              "\s+("+ # повторяющая конструкция: хотя бы один разделитель и тельце
+        #                                     "[a-z]+("+ # атрибут из букв, за которым может стоять знак равенства и потом
+        #                                              "=((\'[^\']*\')|(\"[^\"]*\")|([0-9@\-_a-z:\/?&=\.]+))"+ # 
+        #                                           ")?"+
+        #                                  ")?"+
+        #                            ")*\/?>|\xA2\xA2[^\n]*?==/i;
+
+        re_skipcode = '((<(code|tt)[ >](.*?)<\/(code|tt)>)|(<!\[CDATA\[(.*?)\]\]>))|' if @settings['skip_code']
+        re =  /(#{re_skipcode}<\/?[a-z0-9]+(\s+([a-z]+(=((\'[^\']*\')|(\"[^\"]*\")|([0-9@\-_a-z:\/?&=\.]+)))?)?)*\/?>)/uim
+        tags = text.scan(re).map{ |tag| tag[0] } # первая группа!
+        text.gsub!(re, @mark_tag) #маркер тега, мы используем Invalid UTF-sequence для него
+        return tags
+      end
+      
+      def reinsert_fragments(text, fragments)
+        fragments.each do |fragment|
+          fragment.gsub!(/ (href|src|data)=((?:(\')([^\']*)(\'))|(?:(\")([^\"]*)(\")))/uim) do
+            " #{$1}=" + $2.gsub(/&(?!(#0*38)|(amp);)/, self.glyph[:amp])
+          end # unless @settings['raw_output'] -- делать это надо всегда (mash)
+          
+          unless @settings['skip_attr']
+            fragment.gsub!(/ (title|alt)=((?:(\')([^\']*)(\'))|(?:(\")([^\"]*)(\")))/uim) do
+              " #{$1}=#{$3}" + self.process($4.to_s) + "#{$5}#{$6}" + self.process($7.to_s) + "#{$8}"
+            end 
+          end
+          text.sub!(@mark_tag, fragment)
+        end
+      end
+
+      ### Имплементации фильтров
+      def process_html_entities(text)
+        self.glyph.each { |key, value| text.gsub!(/&#{key};/, value)}
+      end
+
+      def process_initials(text)
+        initials = /([А-Я])[\.]{1,2}[\s]*?([А-Я])[\.]*[\s]*?([А-Я])([а-я])/u
+        replacement = substitute_glyphs_in_string('\1.\2.:thinsp\3\4')
+        text.gsub!(initials, replacement)
+      end
+  
+      def process_copy_paste_clearing(text)
+        VERBATIM_GLYPHS.each {|key,value| text.gsub!(/#{key}/, glyph[value]) }
+      end
+      
+      def process_spacing(text)
+        text.gsub!( /(\s*)([,]*)/sui, '\2\1');
+        text.gsub!( /(\s*)([\.?!]*)(\s*[ЁА-ЯA-Z])/su, '\2\1\3');
+      end
+      
+      def process_dashglue(text)
+        text.gsub!( /([a-zа-яА-Я0-9]+(\-[a-zа-яА-Я0-9]+)+)/ui, glyph[:nob_open]+'\1'+glyph[:nob_close])
+      end
+      
+      def process_escape_html(text)
+        text.gsub!(/&/, self.glyph[:amp])
+        text.gsub!(/</, self.glyph[:lt])
+        text.gsub!(/>/, self.glyph[:gt])
+      end
+      
+      def process_span_instead_of_nobr(text)
+        text.gsub!(/<nobr>/, '<span class="nobr">')
+        text.gsub!(/<\/nobr>/, '</span>')
+      end
+      
+      def process_dash(text)
+        text.gsub!( /(\s|;)\-(\s)/ui, '\1'+self.glyph[:ndash]+'\2')
+      end
+      
+      def process_emdash(text)
+        text.gsub!( /(\s|;)\-\-(\s)/ui, '\1'+self.glyph[:mdash]+'\2')
+        # 4. (с)
+        text.gsub!(/\([сСcC]\)((?=\w)|(?=\s[0-9]+))/u, self.glyph[:copy]) if @settings["(c)"]
+        # 4a. (r)
+        text.gsub!( /\(r\)/ui, '<sup>'+self.glyph[:reg]+'</sup>') if @settings["(r)"]
+
+        # 4b. (tm)
+        text.gsub!( /\(tm\)|\(тм\)/ui, self.glyph[:trade]) if @settings["(tm)"]
+        # 4c. (p)   
+        text.gsub!( /\(p\)/ui, self.glyph[:sect]) if @settings["(p)"]
+      end
+      
+      def process_ellipsises(text)
+        text.gsub!( '...', self.glyph[:hellip])
+      end
+      
+      def process_laquo(text)
+        text.gsub!( /\"\"/ui, self.glyph[:quot]*2);
+        text.gsub!( /(^|\s|#{@mark_tag}|>|\()\"((#{@mark_tag})*[~0-9ёЁA-Za-zА-Яа-я\-:\/\.])/ui, '\1'+self.glyph[:laquo]+'\2');
+        _text = '""';
+        until _text == text do
+          _text = text;
+          text.gsub!( /(#{self.glyph[:laquo]}([^\"]*)[ёЁA-Za-zА-Яа-я0-9\.\-:\/\?\!](#{@mark_tag})*)\"/sui, 
+            '\1'+self.glyph[:raquo])
+        end
+      end
+             
+      def process_quotes(text)
+        text.gsub!( /\"\"/ui, self.glyph[:quot]*2)
+        text.gsub!( /\"\.\"/ui, self.glyph[:quot]+"."+self.glyph[:quot])
+        _text = '""';
+        until _text == text do  
+          _text = text.dup
+          text.gsub!( /(^|\s|#{@mark_tag}|>)\"([0-9A-Za-z\'\!\s\.\?\,\-\&\;\:\_\#{@mark_tag}]+(\"|#{self.glyph[:rdquo]}))/ui, '\1'+self.glyph[:ldquo]+'\2')
+          #this doesnt work in-place. somehow.
+          text.gsub!( /(#{self.glyph[:ldquo]}([A-Za-z0-9\'\!\s\.\?\,\-\&\;\:\#{@mark_tag}\_]*).*[A-Za-z0-9][\#{@mark_tag}\?\.\!\,]*)\"/ui, '\1'+self.glyph[:rdquo])
+        end
+      end
+      
+      def process_compound_quotes(text)
+        text.gsub!(/(#{self.glyph[:ldquo]}(([A-Za-z0-9'!\.?,\-&;:]|\s|#{@mark_tag})*)#{self.glyph[:laquo]}(.*)#{self.glyph[:raquo]})#{self.glyph[:raquo]}/ui,'\1'+self.glyph[:rdquo]);
+      end
+
+      def process_degrees(text)
+        text.gsub!( /-([0-9])+\^([FCС])/, self.glyph[:ndash]+'\1'+self.glyph[:deg]+'\2') #deg
+        text.gsub!( /\+([0-9])+\^([FCС])/, '+\1'+self.glyph[:deg]+'\2')
+        text.gsub!( /\^([FCС])/, self.glyph[:deg]+'\1')
+      end
+      
+      def process_wordglue(text)
+        text.replace(" " + text + " ")
+        _text = " " + text + " "
+        
+        until _text == text
+           _text = text
+           text.gsub!( /(\s+)([a-zа-яА-Я]{1,2})(\s+)([^\\s$])/ui, '\1\2'+self.glyph[:nbsp]+'\4')
+           text.gsub!( /(\s+)([a-zа-яА-Я]{3})(\s+)([^\\s$])/ui,   '\1\2'+self.glyph[:nbsp]+'\4')
+        end
+
+        text.gsub!(/(\s+)([a-zа-яА-Я]{1,2}[\)\]\!\?,\.;]{0,3}\s$)/ui, self.glyph[:nbsp]+'\2')
+
+        @glueleft.each { | i |  text.gsub!( /(\s)(#{i})(\s+)/sui, '\1\2' + self.glyph[:nbsp]) }
+
+        @glueright.each { | i | text.gsub!( /(\s)(#{i})(\s+)/sui, self.glyph[:nbsp]+'\2\3') }
+        
+        text.strip!
+      end
+      
+      def process_phones(text)
+        @phonemasks[0].each_with_index do |pattern, i|
+          replacement = substitute_glyphs_in_string(@phonemasks[1][i])
+          text.gsub!(pattern, replacement)
+        end
+      end
+      
+      def process_inches(text)
+        text.gsub!(/\s([0-9]{1,2}([\.,][0-9]{1,2})?)\"/ui, ' \1'+self.glyph[:inch])
+      end
+      
+      def process_plusmin(text)
+        text.gsub!(/[^+]\+\-/ui, self.glyph[:plusmn]) 
+      end
+
+      # Подменяет все юникодные entities в тексте на истинные UTF-8-символы
+      def process_raw_output(text)
+        # Все глифы
+        @glyph.values.each do | entity | 
+          next unless entity =~ /^&#(\d+);/
+          text.gsub!(/#{entity}/, entity_to_raw_utf8(entity))
+        end
+      end
+      
+      # Конвертирует юникодные entities в UTF-8-codepoints
+      def entity_to_raw_utf8(entity)
+        entity =~ /^&#(\d+);/
+        $1 ? [$1.to_i].pack("U") : entity 
+      end
+end #end Gilenson
+
+# Выбрасывается если форматтеру задается неизвестная настройка
+class RuTils::Gilenson::UnknownSetting < RuntimeError
+end
+
+module RuTils::Gilenson::StringFormatting
+  # Форматирует строку с помощью Gilenson::Formatter. Все дополнительные опции передаются форматтеру.
+  def gilensize(*args)
+    opts = args.last.is_a?(Hash) ? args.last : {}
+    RuTils::Gilenson::Formatter.new(self, *opts).to_html
+  end
+  
+  # Форматирует строку с помощью Gilenson::Obsolete. Всe дополнительные опции передаются форматтеру.
+  def o_gilensize(*args)
+    opts = args.last.is_a?(Hash) ? args.last : {}
+    RuTils::Gilenson::Obsolete.new(self, *opts).to_html
+  end
+end
+
+Object::String.send(:include, RuTils::Gilenson::StringFormatting)

data/lib/rutils.rb

@@ -6,7 +6,7 @@ module RuTils
   INSTALLATION_DIRECTORY = File.expand_path(File.dirname(__FILE__) + '/../') #:nodoc:
   MAJOR = 0
   MINOR = 2
-  TINY = 0
+  TINY = 1
 
   # Версия RuTils
   VERSION = [MAJOR, MINOR ,TINY].join('.') #:nodoc:

data/test/t_gilenson.rb

@@ -0,0 +1,324 @@
+$KCODE = 'u'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/rutils'
+
+
+# Cюда идут наши тесты типографа. Мы содержим их отдельно поскольку набор тестов Типографицы нами не контролируется.
+# Когда у рутилей появятся собственные баги под каждый баг следует завести тест
+class GilensonOwnTest < Test::Unit::TestCase
+  
+  def setup
+    @gilenson = RuTils::Gilenson::Formatter.new
+  end
+
+  def test_tag_lift
+    assert_equal "Вот&#160;такие<tag some='foo>' />  <tagmore></tagmore> дела", "Вот такие<tag some='foo>' />  <tagmore></tagmore> дела".gilensize
+  end
+  
+  def test_byte_pass
+    assert_equal '<p>Теперь добираться до офиса Студии автортранспортом стало удобнее. ' +
+                  'Для этого мы разместили в разделе <a href="#">«Контакт»</a> окно вебкамеры, ' +
+                  'которая непрерывно транслирует дорожную обстановку на Садовом кольце по адресу Земляной Вал, 23. <br>' +
+                  'Удачной дороги! </p>',
+                  '<p>Теперь добираться до офиса Студии автортранспортом стало удобнее. ' +
+                  'Для этого мы разместили в разделе <a href="#">«Контакт»</a> окно вебкамеры, ' +
+                  'которая непрерывно транслирует дорожную обстановку на Садовом кольце по адресу Земляной Вал, 23. <br>' +
+                  'Удачной дороги! </p>'.gilensize
+  end
+
+  def test_phones
+    assert_equal '<nobr>3&#8211;12&#8211;30</nobr>', '3-12-30'.gilensize
+    assert_equal '<nobr>12&#8211;34&#8211;56</nobr>', '12-34-56'.gilensize
+    assert_equal '<nobr>88&#8211;25&#8211;04</nobr>', '88-25-04'.gilensize
+    assert_equal '+7 <nobr>(99284)&#160;65&#8211;818</nobr>', '+7 (99284) 65-818'.gilensize
+    assert_equal '<nobr>725&#8211;01&#8211;10</nobr>', '725-01-10'.gilensize
+  end
+
+  def test_address  
+    assert_equal 'табл.&#160;2, рис.&#160;2.10', 'табл. 2, рис. 2.10'.gilensize
+    assert_equal 'офис&#160;415, оф.340, д.5, ул.&#160;Народной Воли, пл. Малышева', 'офис 415, оф.340, д.5, ул. Народной Воли, пл. Малышева'.gilensize
+  end
+
+  def test_html_entities_replace
+    assert_equal '&#34; &#38; &#39; &#62; &#60; &#160; &#167; &#169; &#171; &#174; &#176; &#177; &#183; &#187; &#8211; &#8212; &#8216; &#8217; &#8220; &#8221; &#8222; &#8226; &#8230; &#8482; &#8722;', '&quot; &amp; &apos; &gt; &lt; &nbsp; &sect; &copy; &laquo; &reg; &deg; &plusmn; &middot; &raquo; &ndash; &mdash; &lsquo; &rsquo; &ldquo; &rdquo; &bdquo; &bull; &hellip; &trade; &minus;'.gilensize
+  end
+
+  def test_ugly_entities_replace1 # not_correct_number
+    assert_equal '&#8222; &#8230; &#39; &#8220; &#8221; &#8226; &#8211; &#8212; &#8482;', '&#132; &#133; &#146; &#147; &#148; &#149; &#150; &#151; &#153;'.gilensize
+  end
+
+  def test_specials
+    assert_equal '&#169; 2002, &#169; 2003, &#169; 2004, &#169; 2005 &#8212; тоже без&#160;пробелов: &#169;2002, &#169;Кукуц. однако: варианты (а) и&#160;(с)', '(с) 2002, (С) 2003, (c) 2004, (C) 2005 -- тоже без пробелов: (с)2002, (c)Кукуц. однако: варианты (а) и (с)'.gilensize
+    assert_equal '+5&#176;С, +7&#176;C, &#8211;5&#176;F', '+5^С, +17^C, -275^F'.gilensize
+    assert_equal 'об&#160;этом подробнее &#8212; читай &#167;25', 'об этом подробнее -- читай (p)25'.gilensize
+    assert_equal 'один же&#160;минус &#8211; краткое тире', 'один же минус - краткое тире'.gilensize
+    assert_equal 'Sharpdesign&#8482;, Microsoft<sup>&#174;</sup>', 'Sharpdesign(tm), Microsoft(r)'.gilensize
+  end
+
+  def test_breaking
+    assert_equal 'скажи, мне, ведь не&#160;даром! Москва, клеймённая пожаром. Французу отдана', 'скажи ,мне, ведь не даром !Москва, клеймённая пожаром .Французу отдана'.gilensize
+    assert_equal 'so&#160;be it, my&#160;liege. Tiny dwellers roam thru midnight! Hell raised, the&#160;Balrog is&#160;hiding in&#160;your backyard!', 'so be it ,my liege .Tiny dwellers roam thru midnight !Hell raised, the Balrog is hiding in your backyard!'.gilensize
+    assert_equal 'при&#160;установке командой строки в&#160;?page=help <nobr>бла-бла-бла-бла</nobr>', 'при установке командой строки в ?page=help бла-бла-бла-бла'.gilensize
+    assert_equal 'как&#160;интересно будет переноситься со&#160;строки на&#160;строку <nobr>что-то</nobr> разделённое дефисом, ведь дефис тот&#160;тоже ведь из&#160;наших. <nobr>Какие-то</nobr> браузеры думают, что&#160;следует переносить и&#160;его&#8230;', 'как интересно будет переноситься со строки на строку что-то разделённое дефисом, ведь дефис тот тоже ведь из наших. Какие-то браузеры думают, что следует переносить и его...'.gilensize
+  end
+  
+  def test_quotes  
+    assert_equal 'english &#8220;quotes&#8221; should be&#160;quite like this', 'english "quotes" should be quite like this'.gilensize
+    assert_equal 'русские же&#160;&#171;оформляются&#187; подобным образом', 'русские же "оформляются" подобным образом'.gilensize
+    assert_equal 'кавычки &#171;расставлены&#187; &#8220;in a&#160;chaotic order&#8221;', 'кавычки "расставлены" "in a chaotic order"'.gilensize
+    assert_equal 'диагональ моего монитора &#8212; 17&#8243;, а&#160;размер пениса &#8212; 1,5&#8243;', 'диагональ моего монитора -- 17", а размер пениса -- 1,5"'.gilensize
+    assert_equal 'в&#160;толщину, &#171;вложенные &#8220;quotes&#8221; вот&#160;так&#187;, &#8220;or it&#160;&#171;будет вложено&#187; elsewhere&#8221;', 'в толщину, "вложенные "quotes" вот так", "or it "будет вложено" elsewhere"'.gilensize
+    assert_equal '&#8220;complicated &#171;кавычки&#187;, &#171;странные &#8220;includements&#8221; кавычек&#187;', '"complicated "кавычки", "странные "includements" кавычек"'.gilensize
+    assert_equal '&#8220;double &#8220;quotes&#8221;', '"double "quotes"'.gilensize
+    assert_equal '&#171;дважды вложенные &#171;кавычки&#187;', '"дважды вложенные "кавычки"'.gilensize
+    assert_equal '&#171;01/02/03&#187;, дискеты в&#160;5.25&#8243;', '"01/02/03", дискеты в 5.25"'.gilensize
+    assert_equal 'после троеточия правая кавычка &#8212; &#171;Вот&#8230;&#187;', 'после троеточия правая кавычка -- "Вот..."'.gilensize
+    assert_equal 'setlocale(LC_ALL, &#8220;ru_RU.UTF8&#8221;);', 'setlocale(LC_ALL, "ru_RU.UTF8");'.gilensize
+    assert_equal '&#8220;read, write, delete&#8221; с&#160;флагом &#8220;only_mine&#8221;', '"read, write, delete" с флагом "only_mine"'.gilensize
+    assert_equal '&#171;Двоеточие:&#187;, &#171;такую умную тему должен писать чувак умеющий скрипты скриптить.&#187;', '"Двоеточие:", "такую умную тему должен писать чувак умеющий скрипты скриптить."'.gilensize
+    assert_equal '(&#171;Вики != HTML&#187; &#8212; &#171;Вики != HTML&#187; &#8212; (&#171;всякая чушь&#187;))', '("Вики != HTML" -- "Вики != HTML" -- ("всякая чушь"))'.gilensize
+    assert_equal '&#171;фигня123&#187;, &#8220;fignya123&#8221;', '"фигня123", "fignya123"'.gilensize
+#      assert_equal '&#171;сбалансированные &#171;кавычки<!--notypo--><!--/notypo--> (четыре в&#160;конце) &#8212; связано с&#160;синтаксисом ваки', '"сбалансированные "кавычки"""" (четыре в конце) -- связано с синтаксисом ваки'.gilensize
+    assert_equal '&#171;несбалансированные &#171;кавычки&#34;&#34;" (три в&#160;конце) &#8212; связано с&#160;синтаксисом ваки', '"несбалансированные "кавычки""" (три в конце) -- связано с синтаксисом ваки'.gilensize
+    assert_equal '&#171;разноязыкие quotes&#187;', '"разноязыкие quotes"'.gilensize
+    assert_equal '&#171;multilanguage кавычки&#187;', '"multilanguage кавычки"'.gilensize
+  end
+
+  def test_additional_quote_cases
+    assert_equal  "&#171;И это&#160;называется языком?&#187;, &#8212; таков был&#160;его вопрос", 
+                      %q{ "И это называется языком?", -- таков был его вопрос }.gilensize
+
+    assert_equal  "&#171;Он &#8212; сволочь!&#187;, сказал&#160;я", 
+                      %q{ "Он -- сволочь!", сказал я }.gilensize
+  end
+
+  def test_initials
+    assert_equal 'Это&#160;нам сказал П.И.&#8201;Петров', 'Это нам сказал П. И. Петров'.gilensize
+
+    assert_equal "А&#160;Ефимов&#8230;",
+      @gilenson.process("А Ефимов...")
+
+    assert_equal "Обратился за&#160;ПО. К&#160;негодяям.",
+      @gilenson.process("Обратился за ПО. К негодяям.")
+
+    assert_equal "ГО&#160;Самарской обл.",
+      @gilenson.process("ГО Самарской обл.")
+
+    assert_equal "ГОР&#160;Самарской обл.",
+      @gilenson.process("ГОР Самарской обл.")
+    
+    assert_equal "КОШМАР Самарской обл.",
+      @gilenson.process("КОШМАР Самарской обл.")
+    
+    assert_equal "УФПС Самарской обл.",
+      @gilenson.process("УФПС Самарской обл.")
+
+  end
+
+  def test_nbsp_last_letters
+    assert_equal  "сказал&#160;я", "сказал я".gilensize
+    assert_equal  "сказал&#160;я!", "сказал я!".gilensize
+    assert_equal  "сказал&#160;я?", "сказал я?".gilensize
+    assert_equal  "сказал&#160;я&#8230;", "сказал я...".gilensize
+    assert_equal  "сказал&#160;он&#8230;", "сказал он...".gilensize
+    assert_equal  "сказали&#160;мы?..", "сказали мы?..".gilensize
+    assert_equal  "сказали&#160;мы?!", "сказали мы?!".gilensize
+    assert_equal  "сказали мы?!!!", "сказали мы?!!!".gilensize
+    assert_equal  "сказали нам", "сказали нам".gilensize
+    assert_equal  "(сказали&#160;им)", "(сказали им)".gilensize
+  end
+  
+  def test_marker_bypass
+    assert_equal "<p><nobr>МИЭЛЬ-Недвижимость</nobr></p>", "<p>МИЭЛЬ-Недвижимость</p>".gilensize
+  end
+  
+  def test_skip_code
+    @gilenson.configure!(:all => true, :skip_code => true)
+    
+    assert_equal "<code>Скип -- скип!</code>",
+      @gilenson.process("<code>Скип -- скип!</code>")
+    
+    assert_equal '<code attr="test -- attr">Скип -- скип!</code>',
+      @gilenson.process('<code attr="test -- attr">Скип -- скип!</code>')
+    
+    assert_equal "<tt>Скип -- скип!</tt> test &#8212; test <tt attr='test -- attr'>Скип -- скип!</tt>",
+      @gilenson.process("<tt>Скип -- скип!</tt> test -- test <tt attr='test -- attr'>Скип -- скип!</tt>")
+    
+    assert_equal "<tt>Скип -- скип!</tt><tt>Скип -- скип!</tt> &#8212; <code attr='test -- attr'>Скип -- скип!</code>",
+      @gilenson.process("<tt>Скип -- скип!</tt><tt>Скип -- скип!</tt> -- <code attr='test -- attr'>Скип -- скип!</code>")
+    
+    assert_equal "<ttt>Скип &#8212; скип!</tt>",
+      @gilenson.process("<ttt>Скип -- скип!</tt>")
+    
+    assert_equal "<tt>Скип &#8212; скип!</ttt>",
+      @gilenson.process("<tt>Скип -- скип!</ttt>")
+    
+    assert_equal "Ах, &#8212; <code>var x = j // -- тест</code>",
+      @gilenson.process("Ах, -- <code>var x = j // -- тест</code>")
+    
+    assert_equal "<![CDATA[ CDATA -- ]]> &#8212; CDATA",
+      @gilenson.process("<![CDATA[ CDATA -- ]]> -- CDATA")
+    
+    assert_equal "<![CDATA[ CDATA -- >] -- CDATA ]]> &#8212; <![CDATA[ CDATA ]> -- CDATA ]]>",
+      @gilenson.process("<![CDATA[ CDATA -- >] -- CDATA ]]> -- <![CDATA[ CDATA ]> -- CDATA ]]>")
+    
+    assert_equal "<![CDATA[ CDATA -- >] -- CDATA ]]> &#8212; <![CDATA[ CDATA ]> -- CDATA ]]>  &#8212; CDATA ]]>",
+      @gilenson.process("<![CDATA[ CDATA -- >] -- CDATA ]]> -- <![CDATA[ CDATA ]> -- CDATA ]]>  -- CDATA ]]>")
+    
+    @gilenson.configure!(:skip_code => false)
+    
+    assert_equal "Ах, &#8212; <code>var x&#160;= j&#160;// &#8212; тест</code>",
+      @gilenson.process("Ах, -- <code>var x = j // -- тест</code>")
+  end
+
+  def test_skip_attr
+    @gilenson.configure!(:skip_attr => true)
+    
+    assert_equal "<a href='#' attr='смотри -- смотри' title='test -- me' alt=\"смотри -- смотри\">just &#8212; test</a>",
+      @gilenson.process("<a href='#' attr='смотри -- смотри' title='test -- me' alt=\"смотри -- смотри\">just -- test</a>")
+    
+    assert_equal 'мы&#160;напишем title="test &#8212; me" и&#160;alt=\'test &#8212; me\', вот',
+      @gilenson.process('мы напишем title="test -- me" и alt=\'test -- me\', вот')
+    
+    @gilenson.configure!(:skip_attr => false)
+    
+    assert_equal "<a href='#' attr='смотри -- смотри' title='test &#8212;&#160;me' alt=\"смотри &#8212; смотри\">just &#8212; test</a>",
+      @gilenson.process("<a href='#' attr='смотри -- смотри' title='test -- me' alt=\"смотри -- смотри\">just -- test</a>")
+    
+    assert_equal 'мы&#160;напишем title="test &#8212; me" и&#160;alt=\'test &#8212; me\', вот',
+      @gilenson.process('мы напишем title="test -- me" и alt=\'test -- me\', вот')
+  end
+  
+  def test_escape_html
+    assert_equal "Используйте &#38; вместо &#38;amp;",
+      @gilenson.process("Используйте &#38; вместо &#38;amp;")
+    
+    @gilenson.configure!(:html => false)
+    
+    assert_equal "&#38;#38; &#8212; &#38;amp; &#60;code/&#62; &#60;some_tag&#62;таги не&#160;пройдут!&#60;/some_tag&#62;. Ну&#160;и?..",
+      @gilenson.process("&#38; -- &amp; <code/> <some_tag>таги не пройдут!</some_tag>. Ну и?..")
+    
+    assert_equal "Используйте &#38;#38; вместо &#38;amp;",
+      @gilenson.process("Используйте &#38; вместо &amp;")
+    
+  end
+
+  def test_ampersand_in_urls
+    
+    @gilenson.configure!(:html=>false)
+    
+    assert_equal "&#60;a href='test?test5=5&#38;#38;test6=6'&#62;test&#38;#38;&#60;/a&#62;",
+      @gilenson.process("<a href='test?test5=5&#38;test6=6'>test&#38;</a>")
+    
+    @gilenson.configure!(:html=>true)
+    
+    assert_equal "<a href='test?test7=7&#38;test8=8'>test&#38;</a>",
+      @gilenson.process("<a href='test?test7=7&#38;test8=8'>test&#38;</a>")
+    
+    assert_equal "<a href='test?test9=9&#038;test10=10'>test&#038;</a>",
+      @gilenson.process("<a href='test?test9=9&#038;test10=10'>test&#038;</a>")
+    
+    assert_equal "<a href='test?test11=11&#38;test12=12'>test&</a>",
+      @gilenson.process("<a href='test?test11=11&test12=12'>test&</a>")
+    
+    assert_equal "<a href='test?test12=12&#38;'>test</a>",
+      @gilenson.process("<a href='test?test12=12&amp;'>test</a>")
+    
+    assert_equal "<a href='test?x=1&#38;y=2' title='&#38;-amp, &#8230;-hellip'>test</a>",
+      @gilenson.process("<a href='test?x=1&y=2' title='&#38;-amp, &#8230;-hellip'>test</a>")
+    
+    assert_equal "<a href='test?x=3&#38;#039;y=4'>test</a>",
+      @gilenson.process("<a href='test?x=3&#039;y=4'>test</a>")
+    
+    
+    @gilenson.glyph[:amp] = '&amp;'
+    
+    assert_equal "<a href='test?test11=11&amp;test12=12'>test&</a>",
+      @gilenson.process("<a href='test?test11=11&test12=12'>test&</a>")
+    
+    assert_equal "<a href='test?test13=13&amp;test14=14'>test&</a>",
+      @gilenson.process("<a href='test?test13=13&amp;test14=14'>test&</a>")
+    
+    assert_equal "<a href='test?test15=15&amp;amppp;test16=16'>test&</a>",
+      @gilenson.process("<a href='test?test15=15&amppp;test16=16'>test&</a>")
+    
+  end
+end
+
+
+class GilensonConfigurationTest < Test::Unit::TestCase
+  def setup
+    @gilenson = RuTils::Gilenson::Formatter.new
+  end
+  
+  def test_settings_as_tail_arguments
+
+    assert_equal "Ну&#160;и куда вот&#160;&#8212; да&#160;туда!", 
+      @gilenson.process("Ну и куда вот -- да туда!")
+
+    assert_equal "Ну и куда вот &#8212; да туда!", 
+      @gilenson.process("Ну и куда вот -- да туда!", :dash => false, :dashglue => false, :wordglue => false)
+
+    assert_equal "Ну&#160;и куда вот&#160;&#8212; да&#160;туда!", 
+      @gilenson.process("Ну и куда вот -- да туда!")
+      
+    @gilenson.configure!(:dash => false, :dashglue => false, :wordglue => false)
+
+    assert_equal "Ну и куда вот &#8212; да туда!", 
+      @gilenson.process("Ну и куда вот -- да туда!")    
+
+    @gilenson.configure!(:all => true)
+
+    assert_equal "Ну&#160;и куда вот&#160;&#8212; да&#160;туда!", 
+      @gilenson.process("Ну и куда вот -- да туда!")
+
+    @gilenson.configure!(:all => false)
+
+    assert_equal "Ну и куда вот -- да туда!", 
+      @gilenson.process("Ну и куда вот -- да туда!")
+  end
+  
+  def test_glyph_override
+    assert_equal 'скажи, мне, ведь не&#160;даром! Москва, клеймённая пожаром. Французу отдана',
+      @gilenson.process('скажи ,мне, ведь не даром !Москва, клеймённая пожаром .Французу отдана')
+
+    @gilenson.glyph[:nbsp] = '&nbsp;'
+    assert_equal 'скажи, мне, ведь не&nbsp;даром! Москва, клеймённая пожаром. Французу отдана',
+      @gilenson.process('скажи ,мне, ведь не даром !Москва, клеймённая пожаром .Французу отдана')
+  end
+  
+  def test_ugly_entities_replace2 # copy&paste
+    @gilenson.configure!(:copypaste => true)
+    assert_equal '&#160; &#171; &#187; &#167; &#169; &#174; &#176; &#177; &#182; &#183; &#8211; &#8212; &#8216; &#8217; &#8220; &#8221; &#8222; &#8226; &#8230; &#8470; &#8482; &#8722; &#8201; &#8243;', @gilenson.process('  « » § © ® ° ± ¶ · – — ‘ ’ “ ” „ • … № ™ −   ″')
+  end
+  
+  def test_raise_on_unknown_setting
+    assert_raise(RuTils::Gilenson::UnknownSetting) { @gilenson.configure!(:bararara => true) }
+  end
+  
+  def test_raw_utf8_output
+    @gilenson.configure!(:raw_output=>true)
+    assert_equal '&#38442; Это просто «кавычки»',
+      @gilenson.process('&#38442; Это просто "кавычки"')    
+  end
+  
+  def test_configure_alternate_names
+    assert @gilenson.configure(:raw_output=>true)    
+    assert @gilenson.configure!(:raw_output=>true)    
+  end
+
+end
+
+# class TypograficaTrakoEntries < Test::Unit::TestCase
+#     def test_cpp
+#       assert_equal "C++-API", "C++-API".gilensize
+#     end
+#     
+#     def test_symmetricity # http://pixel-apes.com/typografica/trako/12
+#       assert_equal "&#171;Справка&#160;09&#187;", '"Справка 09"'.gilensize
+#     end
+#     
+#     def test_paths # http://pixel-apes.com/typografica/trako/13
+#       assert_equal '&#171;c:\www\sites\&#187;', '"c:\www\sites\"'.gilensize
+#     end
+# end

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: rutils
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 date: 2007-04-03 00:00:00 +02:00
 summary: Simple processing of russian strings
 require_paths: 
@@ -33,6 +33,7 @@ files:
 - bin/rutilize
 - test/run_tests.rb
 - test/t_datetime.rb
+- test/t_gilenson.rb
 - test/t_integration.rb
 - test/t_pluralize.rb
 - test/t_rutils_base.rb
@@ -47,6 +48,7 @@ files:
 - lib/transliteration
 - lib/countries/countries.rb
 - lib/datetime/datetime.rb
+- lib/gilenson/gilenson.rb
 - lib/gilenson/gilenson_port.rb
 - lib/integration/blue_cloth_override.rb
 - lib/integration/integration.rb