pseudohikiparser 0.0.4 → 0.0.5.develop

data/lib/pseudohiki/converter.rb

@@ -3,6 +3,7 @@
 
 require 'optparse'
 require 'erb'
+require 'pseudohiki/version'
 require 'pseudohiki/blockparser'
 require 'pseudohiki/autolink'
 require 'pseudohiki/htmlformat'
@@ -11,6 +12,7 @@ require 'pseudohiki/markdownformat'
 require 'pseudohiki/utils'
 require 'htmlelement/htmltemplate'
 require 'htmlelement'
+require 'htmlelement/utils'
 
 module PseudoHiki
   class PageComposer
@@ -18,142 +20,189 @@ module PseudoHiki
 
     PlainFormat = PlainTextFormat.create
 
-    def initialize(options)
-      @options = options
-      @is_toc_item_pat = proc_for_is_toc_item_pat
-    end
+    class BaseComposer
+      def initialize(options)
+        @options = options
+      end
+
+      def compose_body(tree)
+        @options.formatter.format(tree)
+      end
 
-    def proc_for_is_toc_item_pat
-      proc do |node|
+      def create_style(path_to_css_file); "".freeze; end
+
+      private
+
+      def toc_item_pat?(node)
         node.kind_of?(PseudoHiki::BlockParser::HeadingLeaf) and
           (2..3).include? node.level and
           node.node_id
       end
-    end
 
-    def formatter
-      @formatter ||= @options.html_template.new
-    end
+      def collect_nodes_for_table_of_contents(tree)
+        Utils::NodeCollector.select(tree) {|node| toc_item_pat?(node) }
+      end
 
-    def to_plain(line)
-      PlainFormat.format(line).to_s
+      def to_plain(line)
+        PlainFormat.format(line).to_s
+      end
     end
 
-    def collect_nodes_for_table_of_contents(tree)
-      Utils::NodeCollector.select(tree) {|node| @is_toc_item_pat.call(node) }
-    end
+    class HtmlComposer < BaseComposer
+      TABLE = "table"
 
-    def create_plain_table_of_contents(tree)
-      toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
-        ('*' * toc_node.level) + to_plain(toc_node)
+      def initialize(options)
+        super(options)
+        @link_manager = setup_link_manager(options)
+        @relative_link = options[:relative_link]
       end
 
-      @options.formatter.format(BlockParser.parse(toc_lines))
-    end
+      def compose_body(tree)
+        super(tree).tap do |html|
+          if @relative_link and @link_manager
+            @link_manager.use_relative_path_for_in_domain_links(html)
+          end
 
-    def create_html_table_of_contents(tree)
-      @options.formatter.format(create_html_toc_tree(tree)).tap do |toc|
-        toc.traverse do |element|
-          if element.kind_of? HtmlElement and element.tagname == "a"
-            element["title"] = "toc_item: " + element.children.join.chomp
+          assign_table_header_scope(html) if @options[:accessibility]
+        end
+      end
+
+      def create_table_of_contents(tree)
+        @options.formatter.format(create_toc_tree(tree)).tap do |toc|
+          toc.traverse do |element|
+            if element.kind_of? HtmlElement and element.tagname == "a"
+              element["title"] = "toc_item: " + element.children.join.chomp
+            end
           end
         end
       end
-    end
 
-    def create_html_toc_tree(tree, newline=nil)
-      toc_lines = collect_nodes_for_table_of_contents(tree).map do |line|
-        format("%s[[%s|#%s]]#{newline}",
-               '*' * line.level,
-               to_plain(line).lstrip,
-               line.node_id.upcase)
+      def create_main(toc, body, h1)
+        return nil unless @options[:toc]
+        main = formatter.create_element("section").tap do |element|
+          element["id"] = "main"
+          element.push h1 unless h1.empty?
+          element.push create_toc_container(toc)
+          element.push create_contents_container(body)
+        end
       end
-      BlockParser.parse(toc_lines)
-    end
 
-    def gfm_id(heading_node)
-      MarkDownFormat.convert_into_gfm_id_format(to_plain(heading_node).strip)
-    end
+      def create_style(path_to_css_file)
+        style = formatter.create_element("style").tap do |element|
+          element["type"] = "text/css"
+          open(File.expand_path(path_to_css_file)) do |css_file|
+            element.push css_file.read
+          end
+        end
+      end
 
-    def create_gfm_table_of_contents(tree)
-      toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
-        format("%s[[%s|#%s]]#{$/}",
-               '*' * toc_node.level,
-               to_plain(toc_node).strip,
-               gfm_id(toc_node))
+      private
+
+      def setup_link_manager(options)
+        if options[:domain_name]
+          domain_name = @options[:domain_name]
+          alternative_names = @options[:alternative_domain_names]
+          HtmlElement::Utils::LinkManager.new(domain_name, alternative_names)
+        end
       end
 
-      @options.formatter.format(BlockParser.parse(toc_lines))
-    end
+      def assign_table_header_scope(html)
+        HtmlElement::Utils.collect_elements_by_name(html, TABLE).each do |table|
+          HtmlElement::Utils::TableManager.assign_scope(table)
+        end
+      end
 
-    def create_table_of_contents(tree)
-      return "" unless @options[:toc]
-      gfm_chosen = @options[:html_version].version == "gfm"
-      return create_gfm_table_of_contents(tree) if gfm_chosen
-      return create_plain_table_of_contents(tree) unless @options.html_template
-      create_html_table_of_contents(tree)
-    end
+      def formatter
+        @formatter ||= @options.html_template.new
+      end
 
-    def split_main_heading(input_lines)
-      return "" unless @options[:split_main_heading]
-      h1_pos = input_lines.find_index {|line| /^![^!]/o =~ line }
-      return "" unless h1_pos
-      tree = BlockParser.parse([input_lines.delete_at(h1_pos)])
-      @options.formatter.format(tree)
-    end
+      def create_toc_tree(tree, newline=nil)
+        toc_lines = collect_nodes_for_table_of_contents(tree).map do |line|
+          format("%s[[%s|#%s]]#{newline}",
+                 '*' * line.level,
+                 to_plain(line).lstrip,
+                 line.node_id.upcase)
+        end
+        BlockParser.parse(toc_lines)
+      end
+
+      def create_toc_container(toc)
+        formatter.create_element("section").tap do |elm|
+          elm["id"] = "toc"
+          title = @options[:toc]
+          elm.push formatter.create_element("h2", title) unless title.empty?
+          elm.push toc
+        end
+      end
 
-    def create_plain_main(toc, body, h1)
-      contents = [body]
-      contents.unshift toc unless toc.empty?
-      if title = @options[:toc]
-        toc_title = @options.formatter.format(BlockParser.parse("!!" + title))
-        contents.unshift toc_title
+      def create_contents_container(body)
+        formatter.create_element("section").tap do |elm|
+          elm["id"] = "contents"
+          elm.push body
+        end
       end
-      contents.unshift h1 unless h1.empty?
-      contents.join($/)
     end
 
-    def create_html_main(toc, body, h1)
-      return nil unless @options[:toc]
-      main = formatter.create_element("section").tap do |element|
-        element["id"] = "main"
-        element.push h1 unless h1.empty?
-        element.push create_html_toc_container(toc)
-        element.push create_html_contents_container(body)
+    class PlainComposer < BaseComposer
+      def create_table_of_contents(tree)
+        toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
+          ('*' * toc_node.level) + to_plain(toc_node)
+        end
+
+        @options.formatter.format(BlockParser.parse(toc_lines))
       end
-    end
 
-    def create_html_toc_container(toc)
-      formatter.create_element("section").tap do |elm|
-        elm["id"] = "toc"
-        title = @options[:toc]
-        elm.push formatter.create_element("h2", title) unless title.empty?
-        elm.push toc
+      def create_main(toc, body, h1)
+        contents = [body]
+        contents.unshift toc unless toc.empty?
+        if title = @options[:toc]
+          toc_title = @options.formatter.format(BlockParser.parse("!!" + title))
+          contents.unshift toc_title
+        end
+        contents.unshift h1 unless h1.empty?
+        contents.join($/)
       end
     end
 
-    def create_html_contents_container(body)
-      formatter.create_element("section").tap do |elm|
-        elm["id"] = "contents"
-        elm.push body
+    class GfmComposer < PlainComposer
+      def create_table_of_contents(tree)
+        toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
+          format("%s[[%s|#%s]]#{$/}",
+                 '*' * toc_node.level,
+                 to_plain(toc_node).strip,
+                 gfm_id(toc_node))
+        end
+
+        @options.formatter.format(BlockParser.parse(toc_lines))
+      end
+
+      private
+
+      def gfm_id(heading_node)
+        MarkDownFormat.convert_into_gfm_id_format(to_plain(heading_node).strip)
       end
     end
 
-    def create_main(toc, body, h1)
-      return create_plain_main(toc, body, h1) unless @options.html_template
-      create_html_main(toc, body, h1)
+    def initialize(options)
+      @options = options
+      @composer = select_composer.new(options)
     end
 
-    def create_style(path_to_css_file)
-      style = formatter.create_element("style").tap do |element|
-        element["type"] = "text/css"
-        open(File.expand_path(path_to_css_file)) do |css_file|
-          element.push css_file.read
-        end
-      end
+    def select_composer
+      return GfmComposer if @options[:html_version].version == "gfm"
+      @options.html_template ? HtmlComposer : PlainComposer
     end
 
-    def compose_body(tree)
+    def create_table_of_contents(tree)
+      return "" unless @options[:toc]
+      @composer.create_table_of_contents(tree)
+    end
+
+    def split_main_heading(input_lines)
+      return "" unless @options[:split_main_heading]
+      h1_pos = input_lines.find_index {|line| /^![^!]/o =~ line }
+      return "" unless h1_pos
+      tree = BlockParser.parse([input_lines.delete_at(h1_pos)])
       @options.formatter.format(tree)
     end
 
@@ -162,9 +211,9 @@ module PseudoHiki
       css = @options[:css]
       tree = BlockParser.parse(input_lines)
       toc = create_table_of_contents(tree)
-      body = compose_body(tree)
+      body = @composer.compose_body(tree)
       title = @options.title
-      main = create_main(toc, body, h1)
+      main = @composer.create_main(toc, body, h1)
       choose_template(main, body, binding)
     end
 
@@ -174,7 +223,7 @@ module PseudoHiki
       else
         html = @options.create_html_template_with_current_options
         embed_css = @options[:embed_css]
-        html.head.push create_style(embed_css) if embed_css
+        html.head.push @composer.create_style(embed_css) if embed_css
         html.push main || body
       end
 
@@ -238,6 +287,7 @@ module PseudoHiki
     attr_reader :input_file_basename
 
     def self.remove_bom(input=ARGF)
+      return if input == ARGF and input.filename == "-"
       bom = input.read(3)
       input.rewind unless BOM == bom
     end
@@ -323,17 +373,33 @@ instead of \"#{given_opt}\"."
       end
     end
 
-    def set_encoding(given_opt)
+    def setup_ruby_encoding(given_opt)
       return nil unless String.new.respond_to? :encoding
       external, internal = given_opt.split(/:/o, 2)
       Encoding.default_external = external if external and not external.empty?
       Encoding.default_internal = internal if internal and not internal.empty?
     end
 
-    def parse_command_line_options
+    def parse_opt_setup_ruby_encoding(opt)
+      opt.on("-E [ex[:in]]", "--encoding [=ex[:in]]",
+             "Specify the default external and internal character encodings \
+(same as the option of MRI)") do |given_opt|
+        setup_ruby_encoding(given_opt)
+      end
+    end
+
+    def assign_opt_value(opt, key, short, long, description)
+      opt.on(short, long, description) {|val| self[key] = val }
+    end
+
+    def setup_command_line_options
       OptionParser.new("USAGE: #{File.basename($0)} [OPTION]... [FILE]...
 Convert texts written in a Hiki-like notation into another format.") do |opt|
-        opt.on("-f [html_version]", "--format-version [=format_version]",
+        opt.version = PseudoHiki::VERSION
+
+        parse_opt_setup_ruby_encoding(opt)
+
+        opt.on("-f [format_version]", "--format-version [=format_version]",
                "Choose a formart for the output. Available options: \
 html4, xhtml1, html5, plain, plain_verbose, markdown or gfm \
 (default: #{self[:html_version].version})") do |version|
@@ -352,12 +418,6 @@ html4, xhtml1, html5, plain, plain_verbose, markdown or gfm \
           set_html_encoding(given_opt)
         end
 
-        opt.on("-E [ex[:in]]", "--encoding [=ex[:in]]",
-               "Specify the default external and internal character encodings \
-(same as the option of MRI") do |given_opt|
-          set_encoding(given_opt)
-        end
-
         # use '-w' to avoid the conflict with the short option for '[-t]emplate'
         opt.on("-w [(window) title]", "--title [=title]",
                "Set the value of the <title> element \
@@ -365,17 +425,15 @@ html4, xhtml1, html5, plain, plain_verbose, markdown or gfm \
           self[:title] = title if value_given?(title)
         end
 
-        opt.on("-c [css]", "--css [=css]",
-               "Set the path to a css file to be used \
-(default: #{self[:css]})") do |css|
-          self[:css] = css
-        end
+        assign_opt_value(opt, :css, "-c [css]",
+                         "--css [=css]",
+                         "Set the path to a css file to be used \
+(default: #{self[:css]})")
 
-        opt.on("-C [path_to_css_file]", "--embed-css [=path_to_css_file]",
-               "Set the path to a css file to embed \
-(default: not to embed)") do |path_to_css_file|
-          self[:embed_css] = path_to_css_file
-        end
+        assign_opt_value(opt, :embed_css, "-C [path_to_css_file]",
+                         "--embed-css [=path_to_css_file]",
+                         "Set the path to a css file to embed \
+(default: not to embed)")
 
         opt.on("-b [base]", "--base [=base]",
                "Specify the value of href attribute of the <base> element \
@@ -396,22 +454,17 @@ inside (default: not specified)") do |template|
           @need_output_file = true
         end
 
-        opt.on("-F", "--force",
-               "Force to apply command line options. \
-(default: false)") do |force|
-          self[:force] = force
-        end
+        assign_opt_value(opt, :force, "-F", "--force",
+                         "Force to apply command line options. \
+(default: false)")
 
-        opt.on("-m [contents-title]", "--table-of-contents [=contents-title]",
-               "Include the list of h2 and/or h3 headings with ids. \
-(default: nil)") do |toc_title|
-          self[:toc] = toc_title
-        end
+        assign_opt_value(opt, :toc, "-m [contents-title]",
+                         "--table-of-contents [=contents-title]",
+                         "Include the list of h2 and/or h3 headings with ids. \
+(default: nil)")
 
-        opt.on("-s", "--split-main-heading",
-               "Split the first h1 element") do |should_be_split|
-          self[:split_main_heading] = should_be_split
-        end
+        assign_opt_value(opt, :split_main_heading, "-s", "--split-main-heading",
+               "Split the first h1 element")
 
         opt.on("-W", "--with-wikiname",
                "Use WikiNames") do |with_wikiname|
@@ -421,7 +474,21 @@ inside (default: not specified)") do |template|
           end
         end
 
-        opt.parse!
+        opt.on("-d [domain_name(s)]", "--domain-name [=domain_name(s)]",
+               "Specify domain name(s)") do |domain_name|
+          names = domain_name.split(/;\s*/)
+          self[:domain_name] = names.shift
+          self[:alternative_domain_names] = names
+        end
+
+        assign_opt_value(opt, :relative_link, "-r", "--relative-links-in-html",
+                         "Replace absolute paths with relative ones. \
+*** THIS OPTION IS EXPERIMENTAL ***")
+
+        assign_opt_value(opt, :accessibility, "-a", "--accessibility",
+                         "A bit improved accessibility")
+
+        opt
       end
     end
 
@@ -436,8 +503,10 @@ inside (default: not specified)") do |template|
       end
     end
 
-    def set_options_from_command_line
-      parse_command_line_options
+    def parse_command_line_options
+      opt = setup_command_line_options
+      yield opt if block_given?
+      opt.parse!
       check_argv
       @default_title = @input_file_basename
     end

data/lib/pseudohiki/htmlformat.rb

@@ -78,6 +78,7 @@ module PseudoHiki
 
     def visit(tree)
       htmlelement = create_element(tree)
+      decorate(htmlelement, tree)
       push_visited_results(htmlelement, tree)
       htmlelement
     end
@@ -96,6 +97,21 @@ 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_element(tree)
         super(tree).tap do |elm|
@@ -121,6 +137,7 @@ module PseudoHiki
      [EnumNode, "ol"],
      [TableLeaf, "tr"],
      [VerbatimNode, "pre"],
+     [SectioningNode, "section"],
      [CommentOutNode, nil],
      [HeadingNode, "section"],
      [DescLeaf, DT],
@@ -189,6 +206,23 @@ module PseudoHiki
 
     # for BlockParser
 
+    class << Formatter[TableNode]
+      def decorate(htmlelement, tree)
+        each_decorator(htmlelement, tree) do |elm, decorator|
+          visited_value(decorator["summary"]) do |summary|
+            htmlelement["summary"] = HtmlElement.escape(summary.join.chomp)
+          end
+          visited_value(decorator["caption"]) do |caption|
+            htmlelement.push @generator.create("caption", caption)
+          end
+        end
+      end
+
+      def visited_value(decorator_item)
+        yield visited_result(decorator_item.value) if decorator_item
+      end
+    end
+
     class << Formatter[VerbatimNode]
       def visit(tree)
         contents = add_link(@generator.escape(tree.join))
@@ -203,6 +237,37 @@ module PseudoHiki
       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
+        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
+
     class << Formatter[CommentOutNode]
       def visit(tree); BLANK; end
     end

data/lib/pseudohiki/markdownformat.rb

@@ -275,13 +275,14 @@ module PseudoHiki
     class VerbatimNodeFormatter < self
       def visit(tree)
         element = super(tree)
+        @language_name = language_name(tree)
         return gfm_verbatim(element) if @options.gfm_style
         md_verbatim(element)
       end
 
       def gfm_verbatim(element)
         element.tap do |lines|
-          lines.unshift "```#{$/}"
+          lines.unshift "```#{@language_name + $/}"
           lines.push "```#{$/ * 2}"
         end
       end
@@ -289,6 +290,12 @@ module PseudoHiki
       def md_verbatim(element)
         element.join.gsub(/^/o, "    ").sub(/    \Z/o, "").concat $/
       end
+
+      def language_name(tree)
+        tree.decorator.tap do |decorator|
+          return decorator ? decorator["code"].id : ""
+        end
+      end
     end
 
     class QuoteNodeFormatter < self

data/lib/pseudohiki/sinatra_helpers.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+begin
+  module Sinatra
+    module PseudoHikiParserHelpers
+      XHTML5_CONTENT_TYPE = 'application/xhtml+xml'
+      def phiki(hiki_data, &block)
+        case content_type
+        when XHTML5_CONTENT_TYPE
+          PseudoHiki::Format.to_html5(hiki_data, &block)
+        else
+          PseudoHiki::Format.to_xhtml(hiki_data, &block)
+        end
+      end
+    end
+
+    class Base
+      helpers PseudoHikiParserHelpers
+    end
+  end
+rescue
+  #Sinatra is not available
+end

data/lib/pseudohiki/utils.rb

@@ -29,5 +29,39 @@ module PseudoHiki
         end
       end
     end
+
+    class TableManager
+      TH, COL, ROW = %w(th col row)
+
+      def guess_header_scope(table)
+        col_scope?(table) or row_scope?(table)
+      end
+
+      private
+
+      def col_scope?(table)
+        table.each_with_index do |row, i|
+          row.each do |cell|
+            return if cell.rowspan > 1 or cell.colspan > 1
+            # The first row sould be consist of <th> elements
+            # and other rows should not include <th> elements
+            return unless (i == 0) == (cell.cell_type == TH)
+          end
+        end
+        COL
+      end
+
+      def row_scope?(table)
+        table.each do |row|
+          row.each_with_index do |cell, j|
+            return if cell.rowspan > 1 or cell.colspan > 1
+            # The first column sould be consist of <th> elements
+            # and other columns should not include <th> elements
+            return unless (j == 0) == (cell.cell_type == TH)
+          end
+        end
+        ROW
+      end
+    end
   end
 end

data/lib/pseudohiki/version.rb

@@ -1,3 +1,3 @@
 module PseudoHiki
-  VERSION = "0.0.4"
+  VERSION = "0.0.5.develop"
 end

data/lib/pseudohikiparser.rb

@@ -150,3 +150,5 @@ module PseudoHiki
     end
   end
 end
+
+require 'pseudohiki/sinatra_helpers' if defined? Sinatra