qipowl 0.9.3 → 0.9.7

data/features/bowler.feature

@@ -6,3 +6,17 @@ Feature: Mapper-Ruler-Bowler abstraction produces valid bowlers
     Given we use "html" bowler
     When the input string is ""
     Then bowler has all the method aliases
+
+  Scenario: Config params set properly
+    Given nothing
+    When we request param "bowlers"
+    Then param value ends with "/qipowl/config/bowlers"
+
+  Scenario: Additional map mergeg properly
+    Given we add additional bowler directory "spec"
+    And we use "html" bowler with additional map "html_additional_test"
+    When the input string is "This is ⌚striked⌚ out."
+    And the execute method is called on bowler
+    Then the result should equal to "<p>This is <del>striked</del> out.</p>"
+
+

data/features/html.feature

@@ -46,11 +46,16 @@ Feature: All the possibilities of HTML parser
 
   Scenario: Block tag Λ
     Given we use "html" bowler
-    When the input string is "Λ ruby @mapping[:block] = ≡bold≡ Λ"
+    When the input string is
+    """
+    Λ ruby
+      @mapping[:block] = ≡bold≡
+    Λ
+    """
     And the execute method is called on bowler
     Then the result should equal to
     """
-    
+
     <pre class='ruby'>@mapping[:block] = ≡bold≡</pre>
     """
 
@@ -106,7 +111,7 @@ Feature: All the possibilities of HTML parser
         | "Wikipedia¹http://wikipedia.org"    | "<p><a href='http://wikipedia.org'>Wikipedia</a></p>" |
         | "Wikipedia†Best knowledge base†"    | "<p><abbr title='Best knowledge base'>Wikipedia</abbr></p>" |
         | "Inplace picture¹http://mudasobwa.ru/images/am.jpg goes here." | "<p><img class='inplace' alt='Inplace picture' src='http://mudasobwa.ru/images/am.jpg'/> goes here.</p>" |
-        | "http://mudasobwa.ru/images/am.jpg Standalone picture" | " ␍ <figure> ␍   <img src='http://mudasobwa.ru/images/am.jpg'/> ␍   <figcaption> ␍     <p> ␍       Standalone picture ␍     </p> ␍   </figcaption> ␍ </figure> ␍ " |
+        | "http://mudasobwa.ru/images/am.jpg Standalone picture" | " ␍ <figure> ␍  <img src='http://mudasobwa.ru/images/am.jpg'/> ␍  <figcaption> ␍  <p>Standalone picture</p> ␍  </figcaption> ␍ </figure> ␍ " |
 
   Scenario Outline: Markdown atavisms ⇒ links
     Given we use "html" bowler
@@ -117,7 +122,7 @@ Feature: All the possibilities of HTML parser
     Examples:
         | input               | output                             |
         | "Here ![Image](http://mudasobwa.ru/images/am.jpg) goes" | "<p>Here <img class='inplace' alt='Image' src='http://mudasobwa.ru/images/am.jpg'/> goes</p>" |
-        | "![Figure](http://mudasobwa.ru/images/am.jpg)" | " ␍ <figure> ␍   <img src='http://mudasobwa.ru/images/am.jpg'/> ␍   <figcaption> ␍     <p> ␍       Figure ␍     </p> ␍   </figcaption> ␍ </figure> ␍ " |
+        | "![Figure](http://mudasobwa.ru/images/am.jpg)" | " ␍ <figure> ␍  <img src='http://mudasobwa.ru/images/am.jpg'/> ␍  <figcaption> ␍  <p>Figure</p> ␍  </figcaption> ␍ </figure> ␍ " |
         | "Here [Link](http://wikipedia.org/) goes" | "<p>Here <a href='http://wikipedia.org/'>Link</a> goes</p>" |
         | "Here *italic* goes" | "<p>Here <em>italic</em> goes</p>" |
         | "Here inplace*it*alic goes" | "<p>Here inplace<em>it</em>alic goes</p>" |
@@ -135,12 +140,12 @@ Feature: All the possibilities of HTML parser
 
     Examples:
         | input               | output                             |
-        | "List: • li1 • li2" | "<p>List:</p> <ul class='fancy'><li>li1 </li> <li>li2</li></ul>" |
-        | "List: • li1  • nested 1  • nested 2 • li2" | "<p>List:</p> <ul class='fancy'><li>li1 </li> <ul class='fancy'><li>nested 1 </li> <li>nested 2  </li></ul> <li>li2</li></ul>" |
-        | "Data: ▶ dt — dd ▶ dt — dd" | "<p>Data:</p> <dl> ␍ <dt>dt</dt> ␍ <dd>dd </dd> ␍   ␍ <dt>dt</dt> ␍ <dd>dd</dd> ␍ </dl>" |
+        | "List: • li1 • li2" | "<p>List:</p> <ul class='fancy'><li>li1</li> <li>li2</li></ul>" |
+        | "List: • li1  • nested 1  • nested 2 • li2" | "<p>List:</p> <ul class='fancy'><li>li1</li> <ul class='fancy'><li>nested 1</li> <li>nested 2</li></ul> <li>li2</li></ul>" |
+        | "Data: ▶ dt — dd ▶ dt — dd" | "<p>Data:</p> <dl> ␍ <dt>dt</dt> ␍ <dd>dd</dd> ␍   ␍ <dt>dt</dt> ␍ <dd>dd</dd> ␍ </dl>" |
         | "§1 Header" | "<h1>Header</h1>" |
         | "〉 Blockquote" | "<blockquote><p class='blockquote'>Blockquote</p></blockquote>" |
-        
+
   Scenario Outline: Self tags
     Given we use "html" bowler
     When the input string is <input>
@@ -148,8 +153,12 @@ Feature: All the possibilities of HTML parser
     Then the result should equal to <output>
 
     Examples:
-        | input                        | output                                     |
-        | "here qipowl goes"           | "<p>here <strong>qipowl</strong> goes</p>" |
+        | input                | output                                         |
+        | "here qipowl goes"   | "<p>here <strong><a href='http://qipowl.github.com'>qipowl</a></strong> goes</p>"     |
+        | "here Qipowl goes"   | "<p>here <strong><a href='http://Qipowl.github.com'>Qipowl</a></strong> goes</p>"     |
+        | "here tag goes"      | "<p>here <a href='/tags/tag'>tag</a> goes</p>" |
+        | "here tag2 goes"     | "<p>here <b><a href='/tags/tag2'>tag2</a></b> goes</p>" |
+        | "here tag3 goes"     | "<p>here <b><a href='/tags/tag3'>tag3</a></b> goes</p>" |
 
   Scenario: Address tag
     Given we use "html" bowler
@@ -162,7 +171,7 @@ Feature: All the possibilities of HTML parser
     When the input string is "List: × li1 line item × li2"
     And rule "×" is added to mapping as "li" in "regular" section with "ol" enclosure
     And the execute method is called on bowler
-    Then the result should equal to "<p>List:</p> <ol><li>li1 line item </li> <li>li2</li></ol>"
+    Then the result should equal to "<p>List:</p> <ol><li>li1 line item</li> <li>li2</li></ol>"
 
   Scenario: Entity removal
     Given we use "html" bowler
@@ -178,19 +187,19 @@ Feature: All the possibilities of HTML parser
       ✍
       Preamble: given
       ✍
-      
+
       〉 http://mudasobwa.ru/i/self.jpg With caption
         ‒ Wiki, http://wikipedia.ru
-      
+
       Nice?
       """
     And the execute method is called on bowler
     Then the result should equal to
     """
-    
-    
+
+
     <blockquote><p class='blockquote'>http://mudasobwa.ru/i/self.jpg With caption
-    <br/> <small><a href='http://wikipedia.ru'>Wiki</a></small> </p></blockquote>
+    <br/> <small><a href='http://wikipedia.ru'>Wiki</a></small></p></blockquote>
     <p>Nice?</p>
     """
 
@@ -201,13 +210,13 @@ Feature: All the possibilities of HTML parser
       ---
       This is a comment text
       ---
-      
+
       Nice?
       """
     And the execute method is called on bowler
     Then the result should equal to
     """
-    
+
     <p>Nice?</p>
     """
 
@@ -216,28 +225,28 @@ Feature: All the possibilities of HTML parser
     When the input string is
     """
     §2 Blockquotes
-    
+
     〉 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer posuere
     erat a ante.
        〉 Nested blockquote first line
      〉 Nested blockquote second line
     〉 Lorem ipsum para text 2.
-    
+
     Some para text.
-    
+
     〉 Intro 1.
      • list item ≡with bold≡ 1
-     • list item ≈emphasized≈ 
+     • list item ≈emphasized≈
       • nested list item 1
-      • nested list item 2 
-    
+      • nested list item 2
+
     〉 Blockquote standalone.
-    
+
     〉 Intro 2.
-     • list item 2.1 
+     • list item 2.1
      • list item 2.2
     〉 Continuing intro 2.
-    
+
     Blockquote standalone.
     """
     And the execute method is called on bowler
@@ -245,3 +254,43 @@ Feature: All the possibilities of HTML parser
     And the result should match "</li> <ul class='fancy'><li>nested list item 1"
     And the result should match "<p>Blockquote standalone.</p>"
 
+  Scenario Outline: Postprocessing: spaces
+    Given we use "html" bowler
+    When the input string is <input>
+    And the execute method is called on bowler
+    Then the result should equal to <output>
+
+    Examples:
+        | input                  | output                                    |
+        | "here «quote» goes"    | "<p>here «quote» goes</p>"     |
+        | "here « quote¹http://wikipedia.org » goes"    | "<p>here «<a href='http://wikipedia.org'>quote</a>» goes</p>"     |
+        | "This is λsystem.dllλ file."  | "<p>This is <code>system.dll</code> file.</p>" |
+        | "This is ✓8:35✓ time."       | "<p>This is <span class='notypo'>8:35</span> time.</p>" |
+
+  Scenario: Video embedded
+    Given we use "html" bowler
+    When the input string is
+    """
+    http://qipowl.herokuapp.com/images/owl.png
+
+    ☞ Video embedded:
+
+    http://www.youtube.com/watch?v=KFKxlYNfT_o
+    """
+    And the execute method is called on bowler
+    Then the result should equal to
+    """
+
+    <figure>
+     <img src='http://qipowl.herokuapp.com/images/owl.png'/>
+     <figcaption>
+     <p></p>
+     </figcaption>
+    </figure>
+
+    <p class='text-info'>Video embedded:</p>
+
+    <iframe class='youtube' width='560' height='315' src='http://www.youtube.com/embed/KFKxlYNfT_o'
+            frameborder='0' allowfullscreen></iframe>
+
+    """

data/features/step_definitions/bowler_steps.rb

@@ -1,10 +1,17 @@
 # encoding: utf-8
 
+Given(/^nothing$/) do
+end
+
 Given(/^we use "(.*?)" bowler$/) do |f|
 #  @f = "config/bowlers/#{f}.yaml"
   @bowler = Qipowl::Ruler.new_bowler f
 end
 
+Given(/^we use "(.*?)" bowler with additional map "(.*?)"$/) do |f, map|
+  @bowler = Qipowl::Ruler.new_bowler(f, additional_maps: map)
+end
+
 When(/^the input string is "(.*?)"$/) do |input|
   @input = input
 end
@@ -25,6 +32,16 @@ When(/^rule "(.*?)" is removed from mapping$/) do |key|
   @bowler.remove_entity key
 end
 
+When(/^we request param "(.*?)"$/) do |param|
+  @param_value = Qipowl["#{param}".to_sym]
+end
+
+When(/^we add additional bowler directory "(.*?)"$/) do |dir|
+  Qipowl::configure do
+    add :bowlers, dir
+  end
+end
+
 Then(/^bowler has all the method aliases$/) do
   puts @bowler.class.instance_methods(false)
   puts '='*60
@@ -39,3 +56,6 @@ Then(/^the output is "(.*?)"$/) do |result|
   expect(@result).to eq(result)
 end
 
+Then(/^param value ends with "(.*?)"$/) do |s|
+  expect("#{@param_value}").to match(/#{s}$/)
+end

data/lib/qipowl.rb

@@ -18,30 +18,40 @@ Encoding.default_internal = Encoding::UTF_8
 module Qipowl
   extend self
 
-  # Basic single-method DSL with .parameter method
-  # being used to define a set of available settings.
-  # This method takes one or more symbols, with each one being
-  # a name of the configuration option.
-  def params *names
-    names.each do |name|
-      attr_accessor name
-      define_method name do |*values|
-        value = values.first
-        value ? self.send("#{name}=", value) : instance_variable_get("@#{name}")
-      end
-    end
-  end
-
   # A wrapper for the configuration block
-  def config &block
+  def configure &block
     instance_eval(&block)
   end
 
+  def [](key)
+    config[key.to_sym]
+  end
+
+private
+
+  def set(key, value)
+    config[key.to_sym] = value
+  end
+
+  def add(key, value)
+    config[key.to_sym] = [*config[key.to_sym]] << value
+  end
+
+  def config
+    @config ||= Hash.new
+  end
+
+  def method_missing(sym, *args)
+    if sym.to_s =~ /(.+)=$/
+      config[$1.to_sym] = args.first
+    else
+      config[sym.to_sym]
+    end
+  end
 end
 
-Qipowl::config do
-  params :bowlers_dir
-  bowlers_dir File.expand_path(File.join(__dir__, '..', 'config', 'bowlers'))
+Qipowl::configure do
+  set :bowlers, File.expand_path(File.join(__dir__, '..', 'config', 'bowlers'))
 end
 
 class Qipowl::Html
@@ -49,4 +59,4 @@ class Qipowl::Html
   def self.parse s
     (@bowler ||= Qipowl::Ruler.new_bowler "html").execute s
   end
-end
+end

data/lib/qipowl/bowlers/html.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require 'net/http'
+require 'base64'
 require 'typogrowth'
 
 require_relative '../core/bowler'
@@ -8,7 +9,7 @@ require_relative '../core/bowler'
 module Qipowl
   module Mappers
     class HtmlBowlerMapper < BowlerMapper
-      
+
     end
   end
 
@@ -23,59 +24,80 @@ module Qipowl
       # @param [Array] args the words, gained since last call to {#harvest}
       # @return [Array] the array of words with trimmed `grip` tag
       def ∀_grip *args
+        data = ∃_grip(__callee__)
         mine, rest = [*args].join(SEPARATOR).split("#{__callee__}∎", 2)
-        [tagify(∃_grip_tag(__callee__), {:class => ∃_grip(__callee__)[:class]}, mine), rest]
+        [tagify(data[:tag], {:class => data[: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]
+        data = ∃_alone(__callee__)
+        [standalone(data[:tag], {:class => data[:class]}), args]
       end
 
       # `:block` default handler
+      # FIXME TODO make an ability to supply class
       # @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 *args
-        param, *args = args.flatten
-        param = param.to_s
-        harvest __callee__, 
+      def ∀_block arg
+        data = ∃_block(__callee__)
+        param, body = Base64.decode64(
+          "#{arg.to_s.unbowl.uncarriage(false)}"
+        ).force_encoding('UTF-8').split(/\n/, 2)
+        param, body = '', param if body.nil?
+        harvest __callee__,
                 tagify(
-                  ∃_block_tag(__callee__), 
-                  {:class => (param.strip.empty? ? ∃_block(__callee__)[:class] : param.strip)}, 
-                  args.join(SEPARATOR).hsub(String::HTML_ENTITIES)
+                  data[:tag],
+                  {:class => param.strip.empty? ? data[:class] : param.strip },
+                  body.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
+        data = ∃_magnet(__callee__)
         param, *rest = args.flatten
         param = param.unbowl.to_s.prepend("#{__callee__}#{String::NBSP}")
-        [tagify(∃_magnet_tag(__callee__), {:class => ∃_magnet(__callee__)[:class]}, param), rest]
+        [tagify(data[:tag], {:class => data[: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
-                )
+        data = ∃_regular(canonize __callee__)
+        harvest __callee__, tagify(data[:tag], {:class => data[:class]}, args)
       end
-    
+
       # `:self` default handler
       # @param [Array] args the words, gained since last call to {#harvest}
-      def ∀_self *args
-        [tagify(∃_self_tag(__callee__), {:class => ∃_self(__callee__)[:class]}, __callee__), args]
+      def ∀_self *args, &cb
+        data = ∃_self(__callee__)
+        cally = block_given? ? yield : __callee__
+        text = case data[:format]
+               when NilClass then cally
+               when String then cally.to_s.gsub(/(#{cally})/, data[:format])
+#               when Regexp then cally.to_s.gsub(cally.to_s, data[:format])
+               when Symbol then send(data[:format], cally) rescue cally # FIXME Do I need rescue here?!
+               else raise "Bad format specified for #{data[:tag]}"
+               end
+        [data[:tag] ? tagify(data[:tag], {:class => data[:class]}, text) : text, args]
+      end
+
+##############################################################################
+###              Self :: Specific handlers                                 ###
+##############################################################################
+      # Handler for tags.
+      # @param [String] arg the word to be processed
+      # @return [Array] the array of words with procesed tag
+      def tagger_format tag
+        "<a href='/tags/#{tag}'>#{tag}</a>"
       end
-    
 ##############################################################################
 ###              Grip :: Specific handlers                                 ###
 ##############################################################################
@@ -83,28 +105,30 @@ module Qipowl
       # @param [Array] args the words, gained since last call to {#harvest}
       # @return [Array] the array of words with trimmed `abbr` tag
       def † *args
+        data = ∃_grip(__callee__)
         term, *title = args.flatten
         mine, rest = [*title].join(SEPARATOR).split("#{__callee__}∎", 2)
-        [tagify(∃_grip_tag(__callee__), {:title => mine, :class => ∃_grip(__callee__)[:class]}, term), rest]
+        [tagify(data[:tag], {:title => mine, :class => data[: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
+        data = ∃_grip(__callee__)
         href, *title = args.flatten
         mine, rest = [*title].join(SEPARATOR).split("#{__callee__}∎", 2)
         href = href.unbowl
         [
           case get_href_content(href)
-          when :img 
+          when :img
             standalone :img, { :src => href, :alt => [*mine].join(SEPARATOR), :class => 'inplace' }
-          else 
-            tagify ∃_grip_tag(__callee__), {:href => href}, mine
+          else
+            tagify data[:tag], {:href => href}, mine
           end, rest
         ]
       end
-  
+
 ##############################################################################
 ###             Alone :: Specific handlers                                 ###
 ##############################################################################
@@ -114,7 +138,7 @@ module Qipowl
       # @return [Nil] nil
       def —— *args
         harvest nil, orphan(args.join(SEPARATOR)) unless args.vacant?
-        harvest __callee__, standalone(∃_alone_tag(__callee__))
+        harvest __callee__, standalone(∃_alone(__callee__)[:tag])
       end
 
 ##############################################################################
@@ -142,12 +166,12 @@ module Qipowl
         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]
+        [tagify(∃_magnet(__callee__)[:tag], {:name => param.unbowl}, String::ZERO_WIDTH_SPACE), rest]
       end
-    
+
 ##############################################################################
 ###           Regular :: Specific handlers                                 ###
 ##############################################################################
@@ -158,25 +182,24 @@ module Qipowl
         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}' 
+<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 
+      #
+      # @param
       # @return [Nil] nil
       def ⚘ *args
         href, *title = args.flatten
+        title = title.join(SEPARATOR).strip
         harvest __callee__, %Q(
 <figure>
   <img src='#{href.unbowl}'/>
   <figcaption>
-    <p>
-      #{title.join(SEPARATOR)}
-    </p>
+    <p>#{title}</p>
   </figcaption>
 </figure>
 )
@@ -193,35 +216,61 @@ module Qipowl
 #{tagify :dd, {}, dd}
 )
       end
-      # Alias for {#▶}, according to YAML rules specifies additional 
+      # Alias for {#▶}, according to YAML rules specifies additional
       # class for the data list `<dl>` tag behind (`dl-horizontal`.)
       alias_method :▷, :▶
 
     protected
+      def shadows
+        @shadows ||= ([] \
+           << self.class::BLOCK_TAGS.keys.map  {|b| /#{b}.*?#{b}/m } \
+           << self.class::CUSTOM_TAGS.keys.map {|re| /#{re}/m} \
+           << self.class::MAGNET_TAGS.keys.map {|m| /#{m}\s+\S+/} \
+        ).flatten
+      end
+
       # @see {Qipowl::Bowlers::Bowler#defreeze}
-      # 
+      #
       # @param [String] str to be defreezed
       def defreeze str
-        (super str)
+        s = shadows
+        str.typo(sections: [:sequence, :quotes], shadows: s).defuse(shadows: s)
       end
 
+      def serveup str
+        s = [
+          /<pre.*?>.*?<\/pre>/m,
+          /<code.*?>.*?<\/code>/m
+        ]
+
+        str.gsub(/⌦./, '').gsub(/.⌫/, '').typo(
+          sections: [:punctuation, :orphans], shadows: s
+        )
+      end
+
+
       # 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: 
-      # 
+      # 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 }
+      # @param [Symbol|String] cally the DSL symbol to get the level information for.
+      # @return [Integer] the level requested.
+      #
+      def level cally
+        (cally = cally.to_s).gsub(/#{String::NBSP}/, '').empty? ?
+          -1 : (0..cally.length-1).each { |i| break i if cally[i] != String::NBSP }
       end
-      
-      def canonize callee
-        callee.to_s.gsub(/^#{String::NBSP}*/, '').to_sym if callee
+
+      def canonize cally
+        cally.to_s.gsub(/^#{String::NBSP}*/, '').to_sym if cally
+      end
+
+      def normalize cally
+        scally = cally.to_s.unbowl
+        scally.gsub(/\p{L}/, '').empty? ? scally.downcase.bowl.to_sym : cally
       end
 
       # Produces html paragraph tag (`<p>`) with no class.
@@ -233,70 +282,73 @@ module Qipowl
       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 [Symbol] cally of method
       # @param [String] str to be harvested
-      def harvest callee, str
-        if callee.nil? || callee != @callee
-          level(callee).downto(level(@callee) + 1) { |i|
+      def harvest cally, str
+        if cally.nil? || cally != @cally
+          level(cally).downto(level(@cally) + 1) { |i|
             str += i.␚ify
-          } unless ∃_enclosures(canonize(callee)).nil?
-  
-          if prev = ∃_enclosures(canonize(@callee))
-            level(@callee).downto(level(callee) + 1) { |i|
+          } unless ∃_enclosures(canonize cally).nil?
+
+          if prev = ∃_enclosures(canonize(@cally))
+            level(@cally).downto(level(cally) + 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
+
+          @cally = cally
         end
-        super callee, str
+        super cally, str
       end
 
     private
-      # Hence we cannot simply declare the DSL for it, we need to handle 
+      # 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
+        if level(method) > 0 && self.class::REGULAR_TAGS.keys.include?(m = (canonize method))
+          self.class.class_eval "alias_method :#{method}, :#{m}"
+          send method, args, block
+        elsif self.class.instance_methods.include?(m = (normalize method))
+          send(m, args) { yield if block_given? ; method.to_s }
+        else
+          [method, args].flatten
+        end
       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. 
+      # @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`).
@@ -305,14 +357,14 @@ module Qipowl
       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. 
+      # @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}"
+        text.vacant? ? '' : "#{opening tag, params}#{text.strip}#{closing tag}"
       end
 
 
@@ -329,7 +381,7 @@ module Qipowl
         else
           :text
         end
-          
+
       #  uri = URI(href.to_s.unbowl)
       #  Net::HTTP.start(uri.host, uri.port) do |http|
       #    http.open_timeout = 1
@@ -353,17 +405,17 @@ module Qipowl
 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 
+    # @return
     def ∈ *args
       from, till, *rest = args.flatten
       tag = @mapping.handshake(__callee__)
@@ -371,13 +423,13 @@ end
       [tagify(tag, {}, "#{from.unbowl}#{__callee__}#{till.unbowl}".gsub(String::SYMBOL_FOR_SPACE, ' ')), rest]
     end
     alias_method :⊂, :∈
-    
 
-    
+
+
     # @see {Qipowl::Bowler#serveup}
     #
     # Additionally it beatifies the output HTML
-    # 
+    #
     # @param [String] str to be roasted
     def serveup str
       result = ''
@@ -402,11 +454,11 @@ 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
+=end