qipowl 0.9.0

data/lib/qipowl/bowlers/html.rb

@@ -0,0 +1,409 @@
+# encoding: utf-8
+
+require 'net/http'
+require 'htmlbeautifier'
+
+require_relative '../core/bowler'
+require_relative '../bowlers/htmldoc'
+
+module Qipowl
+  # Module placeholder for dynamically created bowlers
+  module Bowlers
+    class Html < Bowler
+##############################################################################
+###              Default handlers for all the types of markup              ###
+##############################################################################
+
+      # `:grip` default handler
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Array] the array of words with trimmed `grip` tag
+      def ∀_grip *args
+        text = [*args].join(SEPARATOR)
+        mine, rest = text.split("#{__callee__}∎", 2)
+        [tagify(∃_grip_tag(__callee__), {:class => ∃_grip(__callee__)[:class]}, mine), rest]
+      end
+
+      # `:alone` default handler
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Array] the array of words with prepended `alone` tag
+      def ∀_alone *args
+        [standalone(∃_alone_tag(__callee__), {:class => ∃_alone(__callee__)[:class]}), args]
+      end
+
+      # `:block` default handler
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @param [String] param the text to be places on the same string as
+      # opening tag
+      # @return [Nil] nil
+      def ∀_block param, args
+        harvest __callee__, 
+                tagify(
+                  ∃_block_tag(__callee__), 
+                  {:class => (param.strip.empty? ? ∃_block(__callee__)[:class] : param.strip)}, 
+                  args.hsub(String::HTML_ENTITIES)
+                )
+      end
+  
+      # `:magnet` default handler
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Array] the array of words with trimmed `magnet` tag
+      def ∀_magnet *args
+        param, *rest = args.flatten
+        param = param.unbowl.to_s.prepend("#{__callee__}#{String::NBSP}")
+        [tagify(∃_magnet_tag(__callee__), {:class => ∃_magnet(__callee__)[:class]}, param), rest]
+      end
+  
+      # `:regular` default handler
+      # @param [Array] args the words, gained since last call to {#harvest}
+      def ∀_regular *args
+        harvest __callee__,
+                tagify(
+                  ∃_regular_tag(canonize(__callee__)),
+                  {:class => ∃_regular(canonize(__callee__))[:class]},
+                  args
+                )
+      end
+    
+##############################################################################
+###              Grip :: Specific handlers                                 ###
+##############################################################################
+      # Handler for abbrs.
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Array] the array of words with trimmed `abbr` tag
+      def † *args
+        term, *title = args.flatten
+        mine, rest = [*title].join(SEPARATOR).split("#{__callee__}∎", 2)
+        [tagify(∃_grip_tag(__callee__), {:title => mine, :class => ∃_grip(__callee__)[:class]}, term), rest]
+      end
+
+      # Handler for anchors.
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Array] the array of words with trimmed `a` tag
+      def ⚓ *args
+        href, *title = args.flatten
+        mine, rest = [*title].join(SEPARATOR).split("#{__callee__}∎", 2)
+        href = href.unbowl
+        [
+          case get_href_content(href)
+          when :img 
+            standalone :img, { :src => href, :alt => [*mine].join(SEPARATOR), :class => 'inplace' }
+          else 
+            tagify ∃_grip_tag(__callee__), {:href => href}, mine
+          end, rest
+        ]
+      end
+  
+##############################################################################
+###             Alone :: Specific handlers                                 ###
+##############################################################################
+      # `:alone` handler for horizontal rule; it differs from default
+      # handler since orphans around must be handled as well.
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Nil] nil
+      def —— *args
+        harvest nil, orphan(args.join(SEPARATOR)) unless args.vacant?
+        harvest __callee__, standalone(∃_alone_tag(__callee__))
+      end
+
+##############################################################################
+###             Block :: Specific handlers                                 ###
+##############################################################################
+      # `:block` handler for comment (required because comments are
+      # formatted in HTML in some specific way.)
+      # @param [String] param the text to be places on the same string as opening tag
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Nil] nil
+      def ✍ *args
+        []
+      end
+
+##############################################################################
+###            Magnet :: Specific handlers                                 ###
+##############################################################################
+      # `:magnet` handler for reference to Livejournal user.
+      # @param [String] param the text to be places on the same string as opening tag
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Nil] nil
+      def ✎ *args
+        param, *rest = args.flatten
+        param = param.unbowl
+        ljref = "<span style='white-space: nowrap;'><a href='http://#{param}.livejournal.com/profile?mode=full'><img src='http://l-stat.livejournal.com/img/userinfo.gif' alt='[info]' style='border: 0pt none ; vertical-align: bottom; padding-right: 1px;' height='17' width='17'></a><a href='http://#{param}.livejournal.com/?style=mine'><b>#{param}</b></a></span>"
+        [ljref, rest]
+      end
+      
+      def ☇ *args
+        param, *rest = args.flatten
+        [tagify(∃_magnet_tag(__callee__), {:name => param.unbowl}, String::ZERO_WIDTH_SPACE), rest]
+      end
+    
+##############################################################################
+###           Regular :: Specific handlers                                 ###
+##############################################################################
+      # Handler for Youtube video
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Nil] nil
+      def ✇ *args
+        id, *rest = args.flatten
+        harvest nil, orphan(rest.join(SEPARATOR)) unless rest.vacant?
+        harvest __callee__, %Q(
+<iframe class='youtube' width='560' height='315' src='http://www.youtube.com/embed/#{id.unbowl}' 
+        frameborder='0' allowfullscreen></iframe>
+)
+      end
+      
+      # Handler for standalone pictures and
+      # @todo Make it to understand quotes when there is a plain HTML on the other side
+      # 
+      # @param 
+      # @return [Nil] nil
+      def ⚘ *args
+        href, *title = args.flatten
+        harvest __callee__, %Q(
+<figure>
+  <img src='#{href.unbowl}'/>
+  <figcaption>
+    <p>
+      #{title.join(SEPARATOR)}
+    </p>
+  </figcaption>
+</figure>
+)
+      end
+
+      # `:regular` handler for data lists (required since data list items
+      # consist of two tags: `dt` and `dd`.)
+      # @param [Array] args the words, gained since last call to {#harvest}
+      # @return [Nil] nil
+      def ▶ *args
+        dt, dd = args.join(SEPARATOR).split(/\s+(?:—)\s+/)
+        harvest __callee__, %Q(
+#{tagify :dt, {}, dt}
+#{tagify :dd, {}, dd}
+)
+      end
+      # Alias for {#▶}, according to YAML rules specifies additional 
+      # class for the data list `<dl>` tag behind (`dl-horizontal`.)
+      alias_method :▷, :▶
+
+    protected
+      # Computes the level of the `:linewide` element by counting
+      # preceeding non-breakable spaces. For instance, nested lists
+      # are produced by appending `"\u{00A0}"` to the line item
+      # DSL tag: 
+      # 
+      #     li = "• li1 \u{00A0}• nested 1 \u{00A0}• nested 2 • li2"
+      #     
+      # @param [Symbol|String] callee the DSL symbol to get the level information for.
+      # @return [Integer] the level requested. 
+      #
+      def level callee
+        (callee = callee.to_s).gsub(/#{String::NBSP}/, '').empty? ?
+          -1 : (0..callee.length-1).each { |i| break i if callee[i] != String::NBSP }
+      end
+      
+      def canonize callee
+        callee.to_s.gsub(/^#{String::NBSP}*/, '').to_sym if callee
+      end
+
+      # @see Qipowl::Bowler#harvest
+      # 
+      # Additionally it checks if there was a `:linewide` item, requiring
+      # surrounding html element (like `<ul>` aroung several `<li>`s.)
+      # 
+      # @param [Symbol] callee of method
+      # @param [String] str to be harvested
+      def harvest callee, str
+        if callee.nil? || callee != @callee
+          level(callee).downto(level(@callee) + 1) { |i|
+            str += i.␚ify
+          } unless ∃_enclosures(canonize(callee)).nil?
+  
+          if prev = ∃_enclosures(canonize(@callee))
+            level(@callee).downto(level(callee) + 1) { |i|
+              @yielded.last.sub!(/\A/, opening(prev[:tag], {:class => prev[:class]}))
+              @yielded.each { |s| s.gsub!(/#{i.␚ify}/) { closing(prev[:tag]) } }
+            }
+          end
+          
+          @callee = callee
+        end
+        super callee, str
+      end
+
+    private
+      # Hence we cannot simply declare the DSL for it, we need to handle 
+      # calls to all the _methods_, starting with those symbols.
+      # 
+      # @param [Symbol] method as specified by caller (`method_missing`.)
+      # @param [Array] args as specified by caller (`method_missing`.)
+      # @param [Proc] block as specified by caller (`method_missing`.)
+      # 
+      # @return [Array] the array of words
+      def special_handler method, *args, &block
+        # Sublevel markers, e.g. “ •” is level 2 line-item
+        return [method, args].flatten \
+          unless level(method) > 0 && self.class::REGULAR_TAGS.keys.include?(canonize(method))
+        
+        self.class.class_eval "alias_method :#{method}, :#{canonize(method)}"
+        send method, args, block
+      end
+
+      # Produces html paragraph tag (`<p>`) with class `owl`.
+      # @see Qipowl::Bowler#orphan
+      # @param str the words, to be put in paragraph tag.
+      # @return [String] tagged words.
+      def orphan str
+        "#{tagify(:p, {}, str.to_s.strip)}"
+      end
+      # Constructs opening html tag for the input given.
+      # 
+      # To construct `abbr` tag with `title` _Title_ and class _default_:
+      # 
+      #     opening :abbr, { :title=>'Title', :class=>'default' }
+      # 
+      # @param [String] tag to produce opening tag string from.
+      # @param [Hash] params to be put into opening tag as attributes. 
+      # @return [String] opening tag for the input given.
+      def opening tag, params={}
+        attrs = params.inject("") { |m, el| m.prepend " #{el.first}='#{el.last}'" unless el.last.nil? ; m }
+        "<#{tag}#{attrs}>"
+      end
+      
+      # Constructs closing html tag for the input given.
+      # 
+      # @param [String] tag to produce closing tag string from.
+      # @return [String] opening tag for the input given.
+      def closing tag
+        "</#{tag}>"
+      end
+  
+      # (see opening)
+      # Acts most like an {#opening} method, but closes an element inplace
+      # (used for `hr`, `br`, `img`).
+      def standalone tag, params={}
+        opening(tag, params).sub('>', '/>')
+      end
+      # Constructs valid tag for the input given, concatenating
+      # opening and closing tags around the text passed in `args`.
+      # 
+      # @param [String] tag to produce html tag string from.
+      # @param [Hash] params to be put into opening tag as attributes. 
+      # @param [Array] args the words, to be tagged around. 
+      # @return [String] opening tag for the input given.
+      def tagify tag, params, *args
+        text = [*args].join(SEPARATOR)
+        text.vacant? ? '' : "#{opening tag, params}#{text}#{closing tag}"
+      end
+
+
+      # Determines content of remote link by href.
+      # TODO Make image patterns configurable.
+      # @param [String] href link to remote resource
+      # @return [Symbol] content type (`:img` or `:text` currently)
+      def get_href_content href
+        href = href.to_s.unbowl.strip
+        if href.end_with?(* %w{png jpg jpeg gif PNG JPG JPEG GIF})
+          :img
+        elsif /\/\/i\.chzbgr/ =~ href
+          :img
+        else
+          :text
+        end
+          
+      #  uri = URI(href.to_s.unbowl)
+      #  Net::HTTP.start(uri.host, uri.port) do |http|
+      #    http.open_timeout = 1
+      #    http.read_timeout = 1
+      #
+      #    request = Net::HTTP::Head.new uri
+      #    response = http.request request
+      #    case response.to_hash["content-type"].first
+      #    when /image/ then return :img
+      #    when /text/ then return :text
+      #    end
+      #  end
+      #  :unknown
+      #rescue
+      #  logger.warn "Unable to determine link [#{href.to_s.unbowl}] type: no internet connection. Reverting to default."
+      #  :unknown
+      end
+
+    end
+  end
+end
+=begin
+  # Markup processor for Html output.
+  # 
+  # This class produces HTML from markup as Markdown does.
+    
+    # Amount of unnamed instances of the class (needed for new class name generation)
+    @@inst_count = 0
+    
+    
+    # `:handshake` default handler
+    # @param [String] from packed as string operand “before”
+    # @param [String] from packed as string operand “after”
+    # @return 
+    def ∈ *args
+      from, till, *rest = args.flatten
+      tag = @mapping.handshake(__callee__)
+      tag = tag[:tag] if Hash === tag
+      [tagify(tag, {}, "#{from.unbowl}#{__callee__}#{till.unbowl}".gsub(String::SYMBOL_FOR_SPACE, ' ')), rest]
+    end
+    alias_method :⊂, :∈
+    
+
+    
+    # @see {Qipowl::Bowler#defreeze}
+    # 
+    # Additionally it checks if tag is a `:block` tag and 
+    # substitutes all the carriage returns (`$/`) with special symbol
+    # {String::CARRIAGE_RETURN} to prevent format damage.
+    # 
+    # @param [String] str to be defreezed
+    def defreeze str
+      str = super str
+      @mapping[:block].each { |tag, htmltag|
+        str.gsub!(/(#{tag})(.*?)$(.*?)(#{tag}|\Z)/m) { |m|
+          "#{$1}('#{$2}', '#{$3}')\n\n"
+        }
+      }
+      str
+    end
+
+    # @see {Qipowl::Bowler#serveup}
+    #
+    # Additionally it beatifies the output HTML
+    # 
+    # @param [String] str to be roasted
+    def serveup str
+      result = ''
+      %w(. , : ; ! ? »).map(&:bowl).each { |punct|
+        str.gsub!(/(?:\p{Space}|#{String::CARRIAGE_RETURN})*(#{punct})/, '\1')
+#        str.gsub!(/(#{punct})(?=\p{Alnum})/, '\1 ')
+      }
+      %w(«).map(&:bowl).each { |punct|
+        str.gsub!(/(#{punct})(?:\p{Space}|#{String::CARRIAGE_RETURN})*/, '\1')
+        str.gsub!(/(?<=\p{Alnum})(#{punct})/, ' \1')
+      }
+      served = super(str)
+      begin
+        HtmlBeautifier::Beautifier.new(result).scan(served)
+      rescue
+        logger.error "Was unable to tidyfy resulting HTML. Returning as is."
+        result = served
+      end
+      result
+    end
+
+end
+
+if __FILE__ == $0
+  
+  i = 0
+  Dir.glob("#{File.dirname(__FILE__)}/../../../data/octopress-site/source/_posts/**/*.owl").each {|f|
+    puts "Processing ##{i += 1}: #{f}"
+    Qipowl::Html.parse File.read(f)
+  }
+end
+=end

data/lib/qipowl/bowlers/htmldoc.rb

@@ -0,0 +1,268 @@
+# encoding: utf-8
+
+require 'nokogiri'
+require 'fileutils'
+require 'yaml'
+require_relative '../core/monkeypatches.rb'
+require_relative '../utils/hash_recursive_merge.rb'
+
+module Qipowl
+
+  class HtmlDoc < Nokogiri::XML::SAX::Document
+    attr_reader :qp, :tags
+    def initialize mapping
+      @mapping = mapping
+      @inside = nil
+      @collector = {}
+      @tags = {:inplace => {}, :linewide => {}}
+      @qp = ''
+      @level = 0
+    end
+
+    def start_element name, attributes = []
+      current_attrs = Hash[attributes]
+      
+      @qp +=  case name.to_sym
+              when :p, :div
+                if current_attrs['class']
+                  @collector[name.to_sym] = "✿_#{name.to_sym}_#{current_attrs['class'].gsub(/\s+/, '_')}".to_sym
+                  @tags[:linewide][@collector[name.to_sym]] = "#{name.to_sym}†#{current_attrs['class'].gsub(/\s+/, '†')}".to_sym
+                  "\n\n#{@collector[name.to_sym]} "
+                else
+                  "\n\n"
+                end
+              when :ul, :ol, :table, :dl
+                @inside = name.to_sym
+                "\n"
+              when :pre then "\n\nΛ\n"
+              when :tr then " ┇ "
+              when :td then " ┆ "
+              when :a
+                @inside = :a
+                @collector[:href] = current_attrs['href']
+                @collector[:name] = current_attrs['name']
+                ''
+              when :li then (@inside == :ol) ? "◦ " : "• "
+              when :b, :strong then "≡"
+              when :i, :em, :nobr then "≈"
+              when :strike, :del, :s then "─"
+              when :small then "↓"
+              when :u then "▁"
+              when :code, :tt then "λ"
+              when :dfn, :abbr, :cite
+                @inside = name.to_sym
+                @collector[:title] = current_attrs['title']
+              when :hr then "\n\n——\n\n"
+              when :br then " ⏎\n"
+              when :center then "\n— "
+              when :dt then "▷ "
+              when :dd then " — "
+              when :h1 then "§1 "
+              when :h2 then "§2 "
+              when :h3 then "§3 "
+              when :h4 then "§4 "
+              when :h5 then "§5 "
+              when :h6 then "§6 "
+              when :blockquote then "\n\n〉 "
+              when :figure
+                @inside = :figure
+                "\n\n"
+              when :figcaption then " "
+              when :img then fix_href(current_attrs['src'])
+              when :span, :sup
+                if current_attrs['class'].nil?
+                  ''
+                else
+                  @collector[name.to_sym] = "✿_span_#{current_attrs['class'].gsub(/\s+/, '_')}".to_sym
+                  @tags[:inplace][@collector[name.to_sym]] = "span†#{current_attrs['class'].gsub(/\s+/, '†')}".to_sym
+                  " #{@collector[name.to_sym]}"
+                end
+              when :embed, :iframe then "\n\n#{current_attrs['src']}\n\n"
+              when :html, :body, :object, :param, :thead, :tbody, :font, :'lj-embed', :'lj-cut'
+                ''
+              else
+                raise "=== Unhandled: #{name} with attrs: [#{current_attrs}]"
+                ''
+              end
+    end
+
+    def characters str
+      case @inside 
+      when :a, :dfn, :abbr
+        @collector[:text] = str
+      else
+        @qp += str
+      end
+    end
+
+    def end_element name
+      @qp +=  case name.to_sym
+              when :p, :div
+                @collector.delete(name.to_sym)
+                "\n\n"
+              when :a
+                @inside = nil
+                (href= @collector.delete(:href)) ?
+                  " #{(@collector.delete(:text) || '').gsub(/\s+/, "\u{00A0}")}¹#{fix_href href} " :
+                  "☇ #{@collector.delete(:name)} #{@collector.delete(:text)}"
+              when :dfn, :abbr, :cite
+                @inside = nil
+                result = " #{@collector.delete(:text).gsub(/\s+/, "\u{00A0}")}†#{@collector.delete(:title)}† " rescue ''
+                result
+              when :ul, :ol, :table, :dl
+                @inside = nil
+                "\n"
+              when :li then "\n"
+              when :pre then "\nΛ\n\n"
+              when :b, :strong then "≡"
+              when :i, :em, :nobr then "≈"
+              when :u then "▁"
+              when :dd then "\n"
+              when :strike, :del, :s then "─"
+              when :small then "↓"
+              when :code, :tt then "λ"
+              when :span, :sup
+                "#{@collector.delete(name.to_sym)} "
+              when :h1, :h2, :h3, :h4, :h5, :h6 then "\n\n"
+              when :blockquote then "\n\n"
+              when :figure
+                @inside = nil
+                "\n\n"
+              else
+                ''
+              end
+    end
+    
+  private
+    def fix_href href, site = 'http://mudasobwa.ru/'
+      href.start_with?('http') ? href : href.gsub(/\A\/+/, '').prepend(site)
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  
+def prepare str
+  str.gsub(/&[nm]dash;/, '—')            # dashes
+     .gsub(/&nbsp;/, ' ')            # dashes
+     .gsub(/\s+--\s+/, ' — ')            # dashes
+     .gsub(/^\s*/, '')            # leading spaces
+     .gsub(/<img src="\/i\/>/, '')
+     .gsub(/&trade;/, '™')               # other entities
+     .gsub(/&copy;/, '©')               # other entities
+     .gsub(/(1st@1stone.ru|am@secondiary.ru)/, 'am@mudasobwa.ru')
+     .gsub(/http:\/\/(www\.)?(secondiary|1stone|matiouchkine.net)\.ru/, 'http://mudasobwa.ru')  # obsolete site name
+     .gsub(/\[(http[^\]]*)\]/, '\1')     # obsolete markdown pics
+     .gsub(/<span>\s*<\/span>/, 'λ\1λ')     # obsolete markdown pics
+     .gsub(/<lj (?:comm|user)="(.*?)">/, '✎ \1')     # obsolete markdown pics
+     .gsub(/<([^<>]*?@[^<>]*?)>/, '\1')     # obsolete markdown pics
+     .gsub(/<imgsrc=/, '<img src=')     # obsolete markdown pics
+     .gsub(/<ahref=/, '<a href=')     # obsolete markdown pics
+     .gsub(/<\/p>\s*<p>\s*—/, " ⏎\n—")  # direct speech
+     .gsub(/<br(?:\s*\/?\s*)>\s*<br(?:\s*\/?\s*)>/, "\n\n")  # old-fashioned carriage     
+     .gsub(/<[!]--[^<>]*?-->/, '')            # comments
+#     .gsub(/([\.,:;!?])(?=\S)/, '\1 ')            # fix punctuation
+end
+
+def postpare str
+  str.gsub(/\R{2,}/, "\n\n")
+     .gsub(/\A(\s|⏎)*/, '')
+     .gsub(/(\s|⏎)*\Z/, '')
+end
+
+tags = {
+  :magnet => {:✎ => :lj, :☇ => :a},
+  :inplace => {:▁ => :u, :─ => :del},
+  :linewide => {:☛ => :twit},
+  :block => {:✁ => :cut}
+}
+file = "#{File.dirname(__FILE__)}/../../../data/internals/posts.csv"
+file_errors = "#{File.dirname(__FILE__)}/../../../data/internals/errors.txt"
+FileUtils.rm file_errors if File.exist? file_errors
+
+FileUtils.mkdir("#{File.dirname(__FILE__)}/../../../data/site")                
+# %w{txt pic ref twt}.each {|d| FileUtils.mkdir("#{File.dirname(__FILE__)}/../../../data/site/#{d}")}
+
+puts "Reading #{file} …"
+File.readlines(file).each { |l|
+  data = l.split('☢')
+  puts "Processing record #{data[0]}"
+  begin
+    html_doc = Qipowl::HtmlDoc.new nil
+    parser = Nokogiri::HTML::SAX::Parser.new(html_doc)
+    parser.parse(prepare data[2])
+    tags.rmerge! html_doc.tags
+    body = postpare(html_doc.qp)
+    
+    body = body.strip if body
+    
+    id    = data[0]
+    title = data[1].gsub(/'/, "’")
+    date  = data[3]
+    img   = data[4]
+
+    if img && !img.empty? && !img.start_with?('http://')
+      img = "http://mudasobwa.ru/i/#{img.gsub(/\A\/+/, '')}"
+    end
+    
+    q_doc = Qipowl::HtmlDoc.new nil
+    q_parser = Nokogiri::HTML::SAX::Parser.new(q_doc)
+    q_parser.parse(prepare data[5])
+    tags.rmerge! q_doc.tags
+    quote = postpare(q_doc.qp)
+
+    q_url = data[6]
+    type  = data[7].to_i  # 1 => text, 2 => image, 3 => quote, 4 => twit
+    stype = case type
+            when 1 then :txt
+            when 2 then :pic
+            when 3 then :ref
+            when 4 then :twt
+            else :txt
+            end
+  
+    owl_text = %Q(---
+title: '#{title}'
+id: #{id}
+date: '#{date}'
+categories: [#{stype}]
+---
+
+)
+#    owl_text << (type == 4 ? "☛ " : "§1 ")
+#    owl_text << title
+#    owl_text << "\n\n"
+
+    owl_text << case type
+                when 2
+                  "#{img} #{body.gsub(/\R/, ' ⏎ ')}"
+                when 3
+                  q_ref = q_url[/http:\/\/(.*?)\/|\Z/, 1].split('.').last(2).join('.') rescue nil
+                  "\n〉 #{quote.strip}\n‒ #{q_ref ? q_ref : q_url}, #{q_url}\n\n#{body}"
+                else body
+                end
+
+    fname = "#{date.split.first}-#{title.to_filename}.owl"
+    fname = (1..100).each {|i|
+      break "#{date.split.first}-#{title.to_filename}-#{i}.owl" \
+        unless File.exist?("#{File.dirname(__FILE__)}/../../../data/site/#{date.split.first}-#{title.to_filename}-#{i}.owl")
+    } if File.exist?("#{File.dirname(__FILE__)}/../../../data/site/#{fname}")
+    File.open("#{File.dirname(__FILE__)}/../../../data/site/#{fname}", 'a') { |f| f.write(owl_text) }
+
+  rescue Exception => e
+    puts '—'*40
+    puts 'Error occured'
+    puts prepare(data[2])
+    puts '—'*40
+    puts prepare(data[5])
+    puts '—'*40
+    raise e
+  end
+}
+
+File.open("#{File.dirname(__FILE__)}/../../../data/site/rules.yaml", 'a') { |f|
+  f.write(tags.to_yaml)
+}
+
+end