rutils 0.1.2 → 0.1.3

data/lib/gilenson/gilenson.rb

@@ -1,279 +1,624 @@
-class RuTils::Gilenson::New < String #:nodoc:
+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
 
-  def initialize(*args)
-    # Задача (вкратце) состоит в том чтобы все ступени разработки развести в отдельные методы
-    # и тестировать их отдельно друг от друга (а также иметь возможность их по-одному включать и выключать).
-    # Фильтры, которые начинаются с lift работают с блоком (например - вытащить таги, провести обработку
-    # текста и вернуть все назад)
-        
-    # Фильтры обрабатываются именно в таком порядке. Этот массив стравнивается с настройками, и если настройки
-    # для конкретного фильтра установлены в false этот фильтр обработан не будет.
-    # Каждый фильтр должен именоваться process_{filter}, принимать аргументом текст для обработки и возвращать его же!
-    # После того как фильтр включен в массив order_of_filters и для него написан метод фильтр по лумолчанию включается,
-    # и его настройку можно поменять с помощью аксессора с соотв. именем. Это делается автоматом.
-    # Главный обработчик должен сам понимать, использовать ли блок (если метод-делегат начинается с lift_)
-    # или просто process.
+# ==Что такое Gilenson  
+# Обработчик типографских символов в HTML согласно общепринятым правилам. Пока присутствует только в CVS.
+# Посвящается П.Г.Гиленсону[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 => 'И&#160;вот они&#160;таки &#171;приехали&#187;'
+# Все дополнительные настройки в таком случае передаются форматтеру
+#   %{ И вот они таки "приехали"}.gilensize(:laquo=>false) => 'И&#160;вот они&#160;таки "приехали"'
+#
+# Если форматтер надо настроить более тонко, можно использовать его и так:
+#   typ = RuTils::Gilenson.new('Эти "так называемые" великие деятели')
+#   typ.to_html => 'Эти &#171;так называемые&#187; великие деятели'
+# 
+# или как фильтр
+#   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] = '&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
   
-    @@order_of_filters = [
-        :inches,
-        :dashes,
-        :emdashes,
-        :specials,
-        :spacing,
-        :dashglue,
-        :nonbreakables,
-        :plusmin,
-        :degrees,
-        :phones,
-        :simple_quotes,
-        :typographer_quotes,
-        :compound_quotes,
-    ] 
-  
-    # Символы, используемые в подстановках. Меняются через substitute_set(subst_name, subst_content)
-    # Нужно потому как ващето &nbsp; недопустим в XML, равно как и всякие mdash.
-    @@spec_chars = {
-      :laquo=>'&laquo;', #left acute
-      :raquo=>'&raquo;', #right acute
-      :ndash=>'&ndash;', #en dash
-      :mdash=>'&mdash;', #en dash
-      :inch=>'&quot;', #en dash
-      :nbsp=>'&nbsp;', #non-breakable
-    }   
-
-    @@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]+)/,
-                    ],[   
-                     '<nobr>\1&ndash;\2&ndash;\3&nbsp;\4:\5:\6</nobr>',
-                     '<nobr>\1&ndash;\2&ndash;\3</nobr>',
-                     '<nobr>\1&nbsp;\2&ndash;\3&ndash;\4</nobr>',
-                     '<nobr>\1&nbsp;\2&ndash;\3&ndash;\4</nobr>',
-                     '<nobr>\1&nbsp;\2&ndash;\3</nobr>',
-                     '<nobr>\1&nbsp;\2&ndash;\3</nobr>',
-                     '<nobr>\1&ndash;\2&ndash;\3</nobr>',
-                     '<nobr>\1&ndash;\2&ndash;\3</nobr>',
-                     '<nobr>\1&ndash;\2&ndash;\3</nobr>',
-                     '<nobr>\1&ndash;\2</nobr>',
-                     '<nobr>\1&ndash;\2</nobr>'
-                  ]]
-                
-    @@glueleft =  ['рис.', 'табл.', 'см.', 'им.', 'ул.', 'пер.', 'кв.', 'офис', 'оф.', 'г.']
-    @@glueright = ['руб.', 'коп.', 'у.е.', 'мин.']
-
-    @@settings = {
-                    "inches" => true, # преобразовывать дюймы в &quot;
-                    "laquo" => true,  # кавычки-ёлочки
-                    "farlaquo" => false,  # кавычки-ёлочки для фара (знаки "больше-меньше")
-                    "quotes" => true, # кавычки-английские лапки
-                    "dash" => true,   # короткое тире (150)
-                    "emdash" => true, # длинное тире двумя минусами (151)
-                    "(c)" => true, 
-                    "(r)" => true,
-                    "(tm)" => true,
-                    "(p)" => true,
-                    "+-" => true, # спецсимволы, какие - понятно
-                    "degrees" => true, # знак градуса
-                    "<-->" => true,    # отступы $Indent*
-                    "dashglue" => true, "wordglue" => true, # приклеивание предлогов и дефисов
-                    "spacing" => true, # запятые и пробелы, перестановка
-                    "phones" => true,  # обработка телефонов
-                    "fixed" => false,   # подгон под фиксированную ширину
-                    "html" => false     # запрет тагов html
-                 }
-    # irrelevant - indentation with images
-    @@indent_a = "<!--indent-->"
-    @@indent_b = "<!--indent-->"
-  
-    @@mark_tag = "\xF0\xF0\xF0\xF0" # Подстановочные маркеры тегов - BOM
-    @@mark_ignored = "\xFF\xFF\xFF\xFF" # Подстановочные маркеры неизменяемых групп - BOM+ =)
-  
-    @@ignore = /notypo/ # regex, который игнорируется. Этим надо воспользоваться для обработки pre и code
+    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 = '\xF0\xF0\xF0\xF0' #:nodoc:
 
-    self.methods.each do | m |
-      next unless m.include?("process_")
-      raise NoMethodError, "No hook for " + m unless @@order_of_filters.include?(m.gsub(/process_/, '').to_sym)
+     # Кто придумал &#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
   
-    @@order_of_filters.each do |filter|
-      raise NoMethodError, "No process method for " + filter unless self.methods.include?("process_#{filter}".to_sym)
+    # Неизвестные методы - настройки. С = - установка ключа, без - получение значения
+    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
 
-    super(*args)
+    # Обрабатывает 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
 
-  end
+    # Обрабатывает текст, присвоенный форматтеру при создании и возвращает результат обработки.
+    def to_html()
+      return '' unless @_text
+      
+      text = @_text.strip
 
-  
-  def to_html(*opts)
-    text = self.to_s.clone
-    lift_tags(text) do | text |
-#         lift_ignored(text) do |text|
-        for filter in @@order_of_filters
-          raise "UnknownFilter #process_#{filter} in filterlist!" unless self.respond_to?("process_#{filter}".to_sym)
-          self.send("process_#{filter}".to_sym, text) # if @settings[filter.to_sym] # вызываем конкретный фильтр
-        end
-#         end
+      # -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
-  end
-    
-  # Вытаскивает теги из текста, выполняет переданный блок и возвращает теги на место.
-  # Теги в процессе заменяются на специальный маркер      
-  def lift_tags(text, marker="\xF0\xF0\xF0\xF0", &block)
-    
-   # Выцепляем таги
-   #  re =  /<\/?[a-z0-9]+("+ # имя тага
-   #                              "\s+("+ # повторяющая конструкция: хотя бы один разделитель и тельце
-   #                                     "[a-z]+("+ # атрибут из букв, за которым может стоять знак равенства и потом
-   #                                              "=((\'[^\']*\')|(\"[^\"]*\")|([0-9@\-_a-z:\/?&=\.]+))"+ # 
-   #                                           ")?"+
-   #                                  ")?"+
-   #                            ")*\/?>|\xA2\xA2[^\n]*?==/i;
-
-    re =  /(<\/?[a-z0-9]+(\s+([a-z]+(=((\'[^\']*\')|(\"[^\"]*\")|([0-9@\-_a-z:\/?&=\.]+)))?)?)*\/?>)/ui
-    
-    tags = text.scan(re).inject([]) { | ar, match | ar << match[0] }
-    text.gsub!(re, "\xF0\xF0\xF0\xF0") #маркер тега
-    
-    yield(text, marker) if block_given? #делаем все что надо сделать без тегов
+
     
-    tags.each { | tag | text.sub!(marker, tag) }  # Вставляем таги обратно.
+    # Применяет отдельный фильтр к 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
 
-  end
+         @glueleft =  ['рис.', 'табл.', 'см.', 'им.', 'ул.', 'пер.', 'кв.', 'офис', 'оф.', 'г.']
+         @glueright = ['руб.', 'коп.', 'у.е.', 'мин.']
 
-  # Выцепляет игнорированные символы, выполняет блок с текстом
-  # без этих символов а затем вставляет их на место     
-  def lift_ignored(text, marker = "\xFF\xFF\xFF\xFF", &block)
-    ignored = text.scan(@ignore)
-    text.gsub!(@ignore, marker)
-    
-    # обрабатываем текст
-    yield(text, marker) if block_given?       
-    
-    # возвращаем игнорированные символы
-    ignored.each { | tag | text.sub!(marker, tag) }
-  end
+         # Установки можно менять в каждом экземпляре
+         @settings = SETTINGS.dup
 
-  # Кавычки - лапки     
-  def process_simple_quotes(text)
-      text.gsub!( /\"\"/ui, "&quot;&quot;")
-      text.gsub!( /\"\.\"/ui, "&quot;.&quot;")
-      _text = '""';
-      while _text != text do  
-        _text = text
-        text.gsub!( /(^|\s|\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0|>)\"([0-9A-Za-z\'\!\s\.\?\,\-\&\;\:\_\xF0\xF0\xF0\xF0\xFF\xFF\xFF\xFF]+(\"|&#148;))/ui, '\1&#147;\2')
-        #this doesnt work in-place. somehow.
-        text.replace text.gsub( /(\&\#147\;([A-Za-z0-9\'\!\s\.\?\,\-\&\;\:\xF0\xF0\xF0\xF0\xFF\xFF\xFF\xFF\_]*).*[A-Za-z0-9][\xF0\xF0\xF0\xF0\xFF\xFF\xFF\xFF\?\.\!\,]*)\"/ui, '\1&#148;')
+         @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)
+        gil = self
+        return Proc.new { gil.glyph[glyph_to_lookup] }
       end
-  end
-  
-  # Кавычки - елочки
-  def process_typographer_quotes(text)
-    # 2. ёлочки
-    text.gsub!( /\"\"/ui, "&quot;&quot;");
-    text.gsub!( /(^|\s|\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0|>|\()\"((\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0)*[~0-9ёЁA-Za-zА-Яа-я\-:\/\.])/ui, "\\1&laquo;\\2");
-    # nb: wacko only regexp follows:
-    text.gsub!( /(^|\s|\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0|>|\()\"((\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0|\/&nbsp;|\/|\!)*[~0-9ёЁA-Za-zА-Яа-я\-:\/\.])/ui, "\\1&laquo;\\2")
-    _text = "\"\"";
-    while (_text != text) do
-      _text = text;
-      text.gsub!( /(\&laquo\;([^\"]*)[ёЁA-Za-zА-Яа-я0-9\.\-:\/](\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0)*)\"/sui, "\\1&raquo;")
-      # nb: wacko only regexps follows:
-      text.gsub!( /(\&laquo\;([^\"]*)[ёЁA-Za-zА-Яа-я0-9\.\-:\/](\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0)*\?(\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0)*)\"/sui, "\\1&raquo;")
-      text.gsub!( /(\&laquo\;([^\"]*)[ёЁA-Za-zА-Яа-я0-9\.\-:\/](\xFF\xFF\xFF\xFF|\xF0\xF0\xF0\xF0|\/|\!)*)\"/sui, "\\1&raquo;")
-    end
-  end
-  
-  # Cложные кавычки
-  def process_compound_quotes(text)
-    text.gsub!(/(\&\#147\;(([A-Za-z0-9'!\.?,\-&;:]|\s|\xF0\xF0\xF0\xF0|\xFF\xFF\xFF\xFF)*)&laquo;(.*)&raquo;)&raquo;/ui,"\\1&#148;");
-  end
 
-  # Обрабатывает короткое тире
-  def process_dashes(text)
-    text.gsub!( /(\s|;)\-(\s)/ui, "\\1&ndash;\\2")
-  end
-  
-  # Обрабатывает длинные тире     
-  def process_emdashes(text)
-    text.gsub!( /(\s|;)\-\-(\s)/ui, "\\1&mdash;\\2")
-  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
 
-  # Обрабатывает знаки копирайта, торговой марки и т.д.
-  def process_specials(text)
-    # 4. (с)
-    text.gsub!(/\([сСcC]\)((?=\w)|(?=\s[0-9]+))/u, "&copy;")
-    # 4a. (r)
-    text.gsub!( /\(r\)/ui, "<sup>&#174;</sup>")
-
-    # 4b. (tm)
-    text.gsub!( /\(tm\)|\(тм\)/ui, "&#153;")
-    # 4c. (p)   
-    text.gsub!( /\(p\)/ui, "&#167;")
-  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
         
-  # Склейка дефисоов
-  def process_dashglue(text)
-    text.gsub!( /([a-zа-яА-Я0-9]+(\-[a-zа-яА-Я0-9]+)+)/ui, '<nobr>\1</nobr>')
-  end
-  
-  # Запятые и пробелы
-  def process_spacing(text)
-      text.gsub!( /(\s*)([,]*)/sui, "\\2\\1");
-      text.gsub!( /(\s*)([\.?!]*)(\s*[ЁА-ЯA-Z])/su, "\\2\\1\\3");
-  end
-  
-  # Неразрывные пробелы - пока глючит страшным образом
-  def process_nonbreakables(text)
-      text.replace " " + text + " ";
-      _text = " " + text + " ";
-      until _text == text
-          _text.replace text.clone
-         text.gsub!( /(\s+)([a-zа-яА-Я]{1,2})(\s+)([^\\s$])/ui, '\1\2&nbsp;\4')
-         text.gsub!( /(\s+)([a-zа-яА-Я]{3})(\s+)([^\\s$])/ui,   '\1\2&nbsp;\4')
+        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 unless unknown_settings.empty?
+               
+          args_hash.each_pair do | key, value |
+            @settings[key.to_s] = (value ? true : false)
+          end
+        end
       end
 
-      for i in @glueleft
-         text.gsub!( /(\s)(#{i})(\s+)/sui, '\1\2&nbsp;')
+      # Вынимает игнорируемые фрагменты и заменяет их маркером, выполняет переданный блок и вставляет вынутое на место
+      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;
 
-      for i in @glueright 
-         text.gsub!( /(\s)(#{i})(\s+)/sui, '&nbsp;\2\3')
+        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
       
-  end
+      def reinsert_fragments(text, fragments)
+        fragments.each { |fragment|
+          fragment.gsub!(/ (href|src|data)=((?:(\')([^\']*)(\'))|(?:(\")([^\"]*)(\")))/uim) {
+            " #{$1}=" + $2.gsub(/&(?!(#0*38)|(amp);)/, self.glyph[:amp])
+          } # unless @settings['raw_output'] -- делать это надо всегда (mash)
+          
+          fragment.gsub!(/ (title|alt)=((?:(\')([^\']*)(\'))|(?:(\")([^\"]*)(\")))/uim) {
+            " #{$1}=#{$3}" + self.process($4.to_s) + "#{$5}#{$6}" + self.process($7.to_s) + "#{$8}"
+          } unless @settings['skip_attr']
+          text.sub!(@mark_tag, fragment)
+        }
+      end
 
-  # Знак дюйма            
-  def process_inches(text)
-    text.gsub!(/\s([0-9]{1,2}([\.,][0-9]{1,2})?)\"/ui, ' \1&quot;') if @settings["inches"]
-  end
-  
-  # Обрабатывает знак +/-
-  def process_plusmin(text)
-    text.gsub!(/\+\-/ui, "&#177;") if @settings["+-"]
-  end
+      ### Имплементации фильтров
+      def process_html_entities(text)
+        self.glyph.each { |key, value| text.gsub!(/&#{key};/, value)}
+      end
+
+      def process_initials(text)
+        initials = /([А-Я])[\.]*?[\s]*?([А-Я])[\.]*[\s]*?([А-Я])([а-я])/u
+        replacement = substitute_glyphs_in_string('\1.\2.:thinsp\3\4')
+        text.gsub!(initials, replacement)
+      end
   
-  # Обрабатывает телефоны
-  def process_phones(text)
-    @phonemasks[0].each_with_index do |regex, i|
-      text.gsub!(regex, @phonemasks[1][i])
-    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, '<nobr>\1</nobr>')
+      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');
+        # nb: wacko only regexp follows:
+        # text.gsub!( /(^|\s|#{@mark_tag}|>|\()\"((#{#{@mark_tag}|\/#{self.glyph[:nbsp]}|\/|\!)*[~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])
+          # nb: wacko only regexps follows:
+          #text.gsub!( /(#{self.glyph[:laquo]}([^\"]*)[ёЁA-Za-zА-Яа-я0-9\.\-:\/](#{@mark_tag})*\?(#{#{@mark_tag})*)\"/sui, '\1'+self.glyph[:raquo])
+          # text.gsub!( /(#{self.glyph[:raquo]}([^\"]*)[ёЁ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')
+
+        for i in @glueleft
+           text.gsub!( /(\s)(#{i})(\s+)/sui, '\1\2' + self.glyph[:nbsp])
+        end
+
+        for i in @glueright 
+           text.gsub!( /(\s)(#{i})(\s+)/sui, self.glyph[:nbsp]+'\2\3')
+        end
+        
+        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 #:nodoc:
+  # Форматирует строку с помощью Gilenson::Formatter. Все дополнительные опции передаются форматтеру.
+  def gilensize(*args)
+    opts = args.last.is_a?(Hash) ? args.last : {}
+    RuTils::Gilenson::Formatter.new(self, *opts).to_html
   end
   
-  # Обрабатывает знак градуса, набранный как caret
-  def process_degrees(text)
-    text.gsub!( /-([0-9])+\^([FCС])/, '&ndash;\1&#176\2')
-    text.gsub!( /\+([0-9])+\^([FCС])/, "+\\1&#176\\2")
-    text.gsub!( /\^([FCС])/, "&#176\\1")
+  # Форматирует строку с помощью 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
+end
+
+Object::String.send(:include, RuTils::Gilenson::StringFormatting)