pseudohikiparser 0.0.3 → 0.0.4.develop

data/lib/pseudohiki/htmlformat.rb

@@ -10,24 +10,31 @@ module PseudoHiki
     include BlockParser::BlockElement
     include TableRowParser::InlineElement
 
-    #for InlineParser
+    # for InlineParser
     LINK, LITERAL, PLUGIN = %w(a code span)
     BLANK, SPACE = "", " "
     HREF, SRC, ALT, ID, CLASS, ROWSPAN, COLSPAN = %w(href src alt id class rowspan colspan)
-    #for BlockParser
+    # for BlockParser
     DT, DD, LI = %w(dt dd li)
-    DescSep = [InlineParser::DescSep]
+    DescSep, LinkSep = [InlineParser::DescSep], [InlineParser::LinkSep]
 
     Formatter = {}
 
+    class << self
+      attr_accessor :auto_link_in_verbatim
+    end
+
+    @auto_link_in_verbatim = true
+
     attr_reader :element_name
-    attr_writer :generator, :formatter
+    attr_writer :generator, :formatter, :format_class
 
     def self.setup_new_formatter(new_formatter, generator)
       new_formatter.each do |node_class, formatter|
         new_formatter[node_class] = formatter.clone
         new_formatter[node_class].generator = generator
         new_formatter[node_class].formatter = new_formatter
+        new_formatter[node_class].format_class = self
       end
     end
 
@@ -39,19 +46,29 @@ module PseudoHiki
       self
     end
 
-    def self.format(tree)
-      formatter = self.get_plain
+    def self.default_options
+      { :auto_link_in_verbatim => @auto_link_in_verbatim }
+    end
+
+    def self.format(tree, options=nil)
+      cur_auto_link_setting = @auto_link_in_verbatim
+      options = default_options unless options
+      @auto_link_in_verbatim = options[:auto_link_in_verbatim]
+      formatter = get_plain
       tree.accept(formatter)
+    ensure
+      @auto_link_in_verbatim = cur_auto_link_setting
     end
 
     def initialize(element_name, generator=HtmlElement)
       @element_name = element_name
       @generator = generator
       @formatter = Formatter
+      @format_class = self.class
     end
 
     def visited_result(element)
-      visitor = @formatter[element.class]||@formatter[PlainNode]
+      visitor = @formatter[element.class] || @formatter[PlainNode]
       element.accept(visitor)
     end
 
@@ -60,17 +77,19 @@ module PseudoHiki
     end
 
     def visit(tree)
-      htmlelement = create_self_element(tree)
+      htmlelement = create_element(tree)
+      decorate(htmlelement, tree)
       push_visited_results(htmlelement, tree)
       htmlelement
     end
 
-    def create_self_element(tree=nil)
+    def create_element(tree=nil)
       @generator.create(@element_name)
     end
 
     def split_into_parts(tree, separator)
       chunks = []
+      tree = tree.dup
       while sep_index = tree.index(separator)
         chunks.push tree.shift(sep_index)
         tree.shift
@@ -78,45 +97,61 @@ module PseudoHiki
       chunks.push tree
     end
 
+    def decorate(htmlelement, tree)
+      each_decorator(htmlelement, tree) do |elm, decorator|
+        elm[CLASS] = HtmlElement.escape(decorator[CLASS].id) if decorator[CLASS]
+        if id_item = decorator[ID] || decorator[:id]
+          elm[ID] = HtmlElement.escape(id_item.id).upcase
+        end
+      end
+    end
+
+    def each_decorator(element, tree)
+      return unless element.kind_of? HtmlElement
+      return unless tree.kind_of? BlockParser::BlockNode and tree.decorator
+      tree.decorator.tap {|decorator| yield element, decorator }
+    end
+
     class ListLeafNodeFormatter < self
-      def create_self_element(tree)
-        super(tree).tap do |element|
-          element[ID] = tree.node_id.upcase if tree.node_id
+      def create_element(tree)
+        super(tree).tap do |elm|
+          elm[ID] = tree.node_id.upcase if tree.node_id
         end
       end
     end
 
-    [ [EmNode, "em"],
-      [StrongNode, "strong"],
-      [DelNode, "del"],
-      [LiteralNode, LITERAL],
-      [PluginNode, PLUGIN],
-      [LinkNode, LINK],
-      [InlineLeaf, nil],
-      [PlainNode, nil], #Until here is for InlineParser
-      [DescNode, "dl"],
-      [QuoteNode, "blockquote"],
-      [TableNode, "table"],
-      [ParagraphNode, "p"],
-      [HrNode, "hr"],
-      [ListNode, "ul"],
-      [EnumNode, "ol"],
-      [TableLeaf, "tr"],
-      [VerbatimNode, "pre"],
-      [CommentOutNode, nil],
-      [HeadingNode, "section"],
-      [DescLeaf, DT],
-      [TableCellNode, nil],
-      [HeadingLeaf, "h"], #Until here is for BlockParser
-    ].each {|node_class, element| Formatter[node_class] = self.new(element) }
-
-    #for InlineParser
-    ImgFormat = self.new("img")
-    #for BlockParser
+    [[EmNode, "em"],
+     [StrongNode, "strong"],
+     [DelNode, "del"],
+     [LiteralNode, LITERAL],
+     [PluginNode, PLUGIN],
+     [LinkNode, LINK],
+     [InlineLeaf, nil],
+     [PlainNode, nil], # Until here is for InlineParser
+     [DescNode, "dl"],
+     [QuoteNode, "blockquote"],
+     [TableNode, "table"],
+     [ParagraphNode, "p"],
+     [HrNode, "hr"],
+     [ListNode, "ul"],
+     [EnumNode, "ol"],
+     [TableLeaf, "tr"],
+     [VerbatimNode, "pre"],
+     [SectioningNode, "section"],
+     [CommentOutNode, nil],
+     [HeadingNode, "section"],
+     [DescLeaf, DT],
+     [TableCellNode, nil],
+     [HeadingLeaf, "h"], # Until here is for BlockParser
+    ].each {|node_class, elm| Formatter[node_class] = new(elm) }
+
+    # for InlineParser
+    ImgFormat = new("img")
+    # for BlockParser
     Formatter[ListWrapNode] = ListLeafNodeFormatter.new(LI)
     Formatter[EnumWrapNode] = ListLeafNodeFormatter.new(LI)
 
-    #for InlineParser
+    # for InlineParser
 
     class << Formatter[PluginNode]
       def visit(tree)
@@ -134,31 +169,26 @@ module PseudoHiki
     class << Formatter[LinkNode]
       def visit(tree)
         not_from_thumbnail = tree.first.class != LinkNode
-        tree = tree.dup
-        caption = get_caption(tree)
-        begin
-          ref = tree.last.join
-        rescue NoMethodError
-          raise NoMethodError unless tree.empty?
-          STDERR.puts "No uri is specified for #{caption}"
-        end
-        if ImageSuffix =~ ref and not_from_thumbnail
-          htmlelement = ImgFormat.create_self_element
-          htmlelement[SRC] = tree.join
+        caption, ref = caption_and_ref(tree)
+        if IMAGE_SUFFIX_RE =~ ref and not_from_thumbnail
+          htmlelement = ImgFormat.create_element
+          htmlelement[SRC] = ref
           htmlelement[ALT] = caption.join if caption
         else
-          htmlelement = create_self_element
-          url = tree.join
-          htmlelement[HREF] = url.start_with?("#".freeze) ? url.upcase : url
-          htmlelement.push caption||url
+          htmlelement = create_element
+          htmlelement[HREF] = ref.start_with?("#".freeze) ? ref.upcase : ref
+          htmlelement.push caption || ref
         end
         htmlelement
       end
 
-      def get_caption(tree)
-        first_part, second_part = split_into_parts(tree, [LinkSep])
-        return nil unless second_part
-        first_part.map {|token| visited_result(token) }
+      def caption_and_ref(tree)
+        caption, ref = split_into_parts(tree, LinkSep)
+        caption = ref ? caption.map {|token| visited_result(token) } : nil
+        return caption, (ref || tree).join
+      rescue NoMethodError
+        raise NoMethodError unless (ref || tree).empty?
+        STDERR.puts "No uri is specified for #{caption}"
       end
     end
 
@@ -169,20 +199,63 @@ module PseudoHiki
     end
 
     class << Formatter[PlainNode]
-      def create_self_element(tree=nil)
+      def create_element(tree=nil)
         @generator::Children.new
       end
     end
 
-    #for BlockParser
+    # for BlockParser
+
+    class << Formatter[TableNode]
+      def decorate(htmlelement, tree)
+        each_decorator(htmlelement, tree) do |elm, decorator|
+          summary = decorator["summary"] && decorator["summary"].value.join
+          htmlelement["summary"] = HtmlElement.escape(summary) if summary
+        end
+      end
+    end
 
     class << Formatter[VerbatimNode]
       def visit(tree)
-        create_self_element.tap do |element|
-          contents = @generator.escape(tree.join).gsub(BlockParser::URI_RE) do |url|
-            @generator.create(LINK, url, HREF => url).to_s
+        contents = add_link(@generator.escape(tree.join))
+        create_element.tap {|elm| elm.push contents }
+      end
+
+      def add_link(verbatim)
+        return verbatim unless @format_class.auto_link_in_verbatim
+        verbatim.gsub(AutoLink::URI_RE) do |url|
+          @generator.create(LINK, url, HREF => url).to_s
+        end
+      end
+    end
+
+    class << Formatter[SectioningNode]
+      ID_MARK = "#"
+
+      alias :orig_create_element :create_element
+
+      def section_with_id(tree, node_id)
+        orig_create_element(tree).tap do |elm|
+          elm[ID] = node_id[1..-1] # remove the first charactor from node_id
+        end
+      end
+
+      def section_for_class(tree, node_id)
+        if HtmlElement::HTML5_TAGS.include? node_id
+          @generator.create(node_id)
+        else
+          orig_create_element(tree).tap do |elm|
+            elm[CLASS] = elm[CLASS] ? "#{elm[CLASS]} #{node_id}" : node_id
           end
-          element.push contents
+        end
+      end
+
+      def create_element(tree)
+        node_id = tree.node_id
+        if node_id.start_with? ID_MARK
+          section_with_id(tree, node_id)
+        else
+          section_for_class(tree, node_id)
         end
       end
     end
@@ -192,46 +265,45 @@ module PseudoHiki
     end
 
     class << Formatter[HeadingNode]
-      def create_self_element(tree)
-        super(tree).tap do |element|
-          heading_level = "h#{tree.first.nominal_level}"
-          element[CLASS] ||= heading_level
-          element[CLASS] +=  SPACE + heading_level unless element[CLASS] == heading_level
+      def create_element(tree)
+        super(tree).tap do |elm|
+          heading_level = "h#{tree.first.level}"
+          elm[CLASS] ||= heading_level
+          elm[CLASS] += SPACE + heading_level unless elm[CLASS] == heading_level
         end
       end
     end
 
     class << Formatter[DescLeaf]
       def visit(tree)
-        tree = tree.dup
-        element = @generator::Children.new
+        elm = @generator::Children.new
         dt_part, dd_part = split_into_parts(tree, DescSep)
         dt = super(dt_part)
-        element.push dt
+        elm.push dt
         unless dd_part.nil? or dd_part.empty?
           dd = @generator.create(DD)
           push_visited_results(dd, dd_part)
-          element.push dd
+          elm.push dd
         end
-        element
+        elm
       end
     end
 
     class << Formatter[TableCellNode]
       def visit(tree)
         @element_name = tree.cell_type
-        super(tree).tap do |element|
-          element[ROWSPAN] = tree.rowspan if tree.rowspan > 1
-          element[COLSPAN] = tree.colspan if tree.colspan > 1
-          # element.push "&#160;" if element.empty? # &#160; = &nbsp; this line would be necessary for HTML 4 or XHTML 1.0
+        super(tree).tap do |elm|
+          elm[ROWSPAN] = tree.rowspan if tree.rowspan > 1
+          elm[COLSPAN] = tree.colspan if tree.colspan > 1
+          # elm.push "&#160;" if elm.empty? # &#160; = &nbsp; this line would be necessary for HTML 4 or XHTML 1.0
         end
       end
     end
 
     class << Formatter[HeadingLeaf]
-      def create_self_element(tree)
-        @generator.create(@element_name+tree.nominal_level.to_s).tap do |element|
-          element[ID] = tree.node_id.upcase if tree.node_id
+      def create_element(tree)
+        @generator.create(@element_name + tree.level.to_s).tap do |elm|
+          elm[ID] = tree.node_id.upcase if tree.node_id
         end
       end
     end
@@ -240,10 +312,12 @@ module PseudoHiki
   class XhtmlFormat < HtmlFormat
     Formatter = HtmlFormat::Formatter.dup
     setup_new_formatter(Formatter, XhtmlElement)
+    @auto_link_in_verbatim = true
   end
 
   class Xhtml5Format < XhtmlFormat
     Formatter = HtmlFormat::Formatter.dup
     setup_new_formatter(Formatter, Xhtml5Element)
+    @auto_link_in_verbatim = true
   end
 end

data/lib/pseudohiki/htmlplugin.rb

@@ -9,7 +9,7 @@ module PseudoHiki
   class HtmlFormat
     class << Formatter[PluginNode]
       def visit(leaf)
-        escape_inline_tags(leaf) { HtmlPlugin.new(@element_name,leaf.join).apply }
+        escape_inline_tags(leaf) { HtmlPlugin.new(@element_name, leaf.join).apply }
       end
     end
   end
@@ -30,20 +30,19 @@ module PseudoHiki
     NUMBER_RE = /(\d+)/
 
     def parse(data)
-      result = nil
+      result = "".freeze
       if PLUGIN_PAT =~ data
         @plugin_name = $1
         @with_paren = true if $2.chomp == "("
-        result = data.chomp.sub(PLUGIN_PAT,"")
-        result[-1,1] = "" if @with_paren
+        result = data.chomp.sub(PLUGIN_PAT, "")
+        result[-1, 1] = "" if @with_paren
       else
         @plugin_name = data.chomp
-        result = ""
       end
       result
     end
 
-    def initialize(tag_type,parsed_data)
+    def initialize(tag_type, parsed_data)
       @tag_type = tag_type
       @plugin_name = nil
       @with_paren = nil
@@ -66,14 +65,14 @@ module PseudoHiki
     #  end
 
     def anchor
-      name, anchor_mark = @data.split(/,\s*/o,2)
+      name, anchor_mark = @data.split(/,\s*/o, 2)
       anchor_mark = "_" if (anchor_mark.nil? or anchor_mark.empty?)
       HtmlElement.create("a", anchor_mark,
                          "name" => name,
-                         "href" => "#"+name)
+                         "href" => "#" + name)
     end
 
-    def HtmlPlugin.add_chemical_formula(chemical_formula="CO2",en_word="carbon dioxide")
+    def HtmlPlugin.add_chemical_formula(chemical_formula="CO2", en_word="carbon dioxide")
       eval(<<-End)
       def #{chemical_formula.downcase}
         #(display=":cf",second_display=nil)
@@ -130,7 +129,7 @@ module PseudoHiki
       @data.scan(/\A(\d+)([^\d].*)/o) do |data|
         weight, molecule = data
         if self.respond_to? molecule
-          return "<sup>#{weight}</sup>" + HtmlPlugin.new("",molecule).apply
+          return "<sup>#{weight}</sup>" + HtmlPlugin.new("", molecule).apply
         else
           return "<sup>#{weight}</sup>" + molecule
         end
@@ -145,21 +144,3 @@ module PseudoHiki
     end
   end
 end
-
-if $0 == __FILE__
-  p HtmlPlugin.new("div","html(
-<ul>
-<li>list
-<li>list
-</ul>)").apply
-  p HtmlPlugin.new("div","inline(
-*list
-*list
-)").apply
-
-p HtmlPlugin.new("div","co2").apply
-p HtmlPlugin.new("div","co2 :en").apply
-p HtmlPlugin.new("div","cb(3km)").apply
-p HtmlPlugin.new("div","per m").apply
-p HtmlPlugin.new("div","iso 18co2").apply
-end

data/lib/pseudohiki/inlineparser.rb

@@ -7,11 +7,7 @@ module PseudoHiki
   RELATIVE_PATH = /^\./o
   ROOT_PATH = /^(\/|\\\\|[A-Za-z]:\\)/o
   FILE_MARK = "file:///"
-  ImageSuffix = /\.(jpg|jpeg|gif|png|bmp)$/io
-
-  def self.subclass_of(parent_class, bound_env, subclass_names)
-    subclass_names. each {|name| eval "class #{name} < #{parent_class}; end", bound_env  }
-  end
+  IMAGE_SUFFIX_RE = /\.(jpg|jpeg|gif|png|bmp)$/io
 
   def self.compile_token_pat(*token_sets)
     tokens = token_sets.flatten.uniq.sort do |x, y|
@@ -35,10 +31,11 @@ module PseudoHiki
     module InlineElement
       class InlineNode < InlineParser::Node; end
       class InlineLeaf < InlineParser::Leaf; end
-      #  class LinkSepLeaf < InlineLeaf; end
+      # class LinkSepLeaf < InlineLeaf; end
 
-      PseudoHiki.subclass_of(InlineNode, binding,
-                             %w(LinkNode EmNode StrongNode DelNode PlainNode LiteralNode PluginNode))
+      %w(LinkNode EmNode StrongNode DelNode PlainNode LiteralNode PluginNode).each do |subclass|
+        const_set(subclass, Class.new(InlineNode))
+      end
 
       LinkSep, TableSep, DescSep = %w(| || :)
     end
@@ -48,7 +45,7 @@ module PseudoHiki
     TAIL = {}
     NodeTypeToHead = {}
     TokenPat = {}
-    
+
     [[LinkNode, "[[", "]]"],
      [EmNode, "''", "''"],
      [StrongNode, "'''", "'''"],
@@ -60,7 +57,7 @@ module PseudoHiki
       NodeTypeToHead[type] = head
     end
 
-    TokenPat[self] = PseudoHiki.compile_token_pat(HEAD.keys,TAIL.keys,[LinkSep, TableSep, DescSep])
+    TokenPat[self] = PseudoHiki.compile_token_pat(HEAD.keys, TAIL.keys, [LinkSep, TableSep, DescSep])
 
     def initialize(str)
       @tokens = PseudoHiki.split_into_tokens(str, TokenPat[self.class])
@@ -70,8 +67,8 @@ module PseudoHiki
     def convert_last_node_into_leaf
       last_node = remove_current_node
       tag_head = NodeTypeToHead[last_node.class]
-      self.push InlineLeaf.create(tag_head)
-      last_node.each {|leaf| self.push_as_leaf leaf }
+      push InlineLeaf.create(tag_head)
+      last_node.each {|leaf| push_as_leaf leaf }
     end
 
     def node_in_ancestors?(node_class)
@@ -79,23 +76,23 @@ module PseudoHiki
     end
 
     def treated_as_node_end(token)
-      return self.pop if current_node.class == TAIL[token]
+      return pop if current_node.class == TAIL[token]
       return nil unless node_in_ancestors?(TAIL[token])
       convert_last_node_into_leaf until current_node.class == TAIL[token]
-      self.pop
+      pop
     end
 
     def parse
       while token = @tokens.shift
         next if TAIL[token] and treated_as_node_end(token)
-        next if HEAD[token] and self.push HEAD[token].new
-        self.push InlineLeaf.create(token)
+        next if HEAD[token] and push HEAD[token].new
+        push InlineLeaf.create(token)
       end
       self
     end
 
     def self.parse(str)
-      new(str).parse.tree #parser = new(str)
+      new(str).parse.tree # parser = new(str)
     end
   end
 
@@ -120,9 +117,9 @@ module PseudoHiki
 
     class InlineElement::TableCellNode
       def parse_cellspan(token_str)
-        return token_str if m = MODIFIED_CELL_PAT.match(token_str) and m[0].empty? #if token.kind_of? String
-        cell_modifiers = m[0]
-        @cell_type = TH if cell_modifiers[0].chr == TH_PAT
+        m = MODIFIED_CELL_PAT.match(token_str) and cell_modifiers = m[0]
+        return token_str if cell_modifiers.empty?
+        @cell_type = TH if cell_modifiers.start_with? TH_PAT
         @rowspan = cell_modifiers.count(ROW_EXPANDER) + 1
         @colspan = cell_modifiers.count(COL_EXPANDER) + 1
         m.post_match
@@ -134,19 +131,19 @@ module PseudoHiki
       end
 
       def push(token)
-        return super(token) unless self.empty?
+        return super(token) unless empty?
         super(parse_first_token(token))
       end
     end
 
     def treated_as_node_end(token)
       return super(token) unless token == TableSep
-      self.pop
-      self.push TableCellNode.new
+      pop
+      push TableCellNode.new
     end
 
     def parse
-      self.push TableCellNode.new
+      push TableCellNode.new
       super
     end
   end