pseudohikiparser 0.0.3 → 0.0.4.develop

data/lib/pseudohiki/converter.rb

@@ -4,6 +4,7 @@
 require 'optparse'
 require 'erb'
 require 'pseudohiki/blockparser'
+require 'pseudohiki/autolink'
 require 'pseudohiki/htmlformat'
 require 'pseudohiki/plaintextformat'
 require 'pseudohiki/markdownformat'
@@ -19,9 +20,13 @@ module PseudoHiki
 
     def initialize(options)
       @options = options
-      @is_toc_item_pat = Proc.new do |node|
+      @is_toc_item_pat = proc_for_is_toc_item_pat
+    end
+
+    def proc_for_is_toc_item_pat
+      proc do |node|
         node.kind_of?(PseudoHiki::BlockParser::HeadingLeaf) and
-          (2..3).include? node.nominal_level and
+          (2..3).include? node.level and
           node.node_id
       end
     end
@@ -40,18 +45,14 @@ module PseudoHiki
 
     def create_plain_table_of_contents(tree)
       toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
-        ('*' * toc_node.nominal_level) + to_plain(toc_node)
+        ('*' * toc_node.level) + to_plain(toc_node)
       end
 
       @options.formatter.format(BlockParser.parse(toc_lines))
     end
 
     def create_html_table_of_contents(tree)
-      toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
-        "%s[[%s|#%s]]"%['*'*toc_node.nominal_level, to_plain(toc_node).lstrip, toc_node.node_id.upcase]
-      end
-
-      @options.formatter.format(BlockParser.parse(toc_lines)).tap do |toc|
+      @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
@@ -60,13 +61,26 @@ module PseudoHiki
       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)
+      end
+      BlockParser.parse(toc_lines)
+    end
+
     def gfm_id(heading_node)
-      MarkDownFormat.convert_to_gfm_id_format(to_plain(heading_node).strip)
+      MarkDownFormat.convert_into_gfm_id_format(to_plain(heading_node).strip)
     end
 
     def create_gfm_table_of_contents(tree)
       toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
-        "%s[[%s|#%s]]#{$/}"%['*'*toc_node.nominal_level, to_plain(toc_node).strip, gfm_id(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))
@@ -74,7 +88,8 @@ module PseudoHiki
 
     def create_table_of_contents(tree)
       return "" unless @options[:toc]
-      return create_gfm_table_of_contents(tree) if @options[:html_version].version == "gfm"
+      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
@@ -90,27 +105,37 @@ module PseudoHiki
     def create_plain_main(toc, body, h1)
       contents = [body]
       contents.unshift toc unless toc.empty?
-      contents.unshift @options.formatter.format(BlockParser.parse("!!" + @options[:toc])) if @options[:toc]
+      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
 
     def create_html_main(toc, body, h1)
       return nil unless @options[:toc]
-      toc_container = formatter.create_element("section").tap do |element|
-        element["id"] = "toc"
-        element.push formatter.create_element("h2", @options[:toc]) unless @options[:toc].empty?
-        element.push toc
-      end
-      contents_container = formatter.create_element("section").tap do |element|
-        element["id"] = "contents"
-        element.push body
-      end
       main = formatter.create_element("section").tap do |element|
         element["id"] = "main"
         element.push h1 unless h1.empty?
-        element.push toc_container
-        element.push contents_container
+        element.push create_html_toc_container(toc)
+        element.push create_html_contents_container(body)
+      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
+      end
+    end
+
+    def create_html_contents_container(body)
+      formatter.create_element("section").tap do |elm|
+        elm["id"] = "contents"
+        elm.push body
       end
     end
 
@@ -140,14 +165,17 @@ module PseudoHiki
       body = compose_body(tree)
       title = @options.title
       main = create_main(toc, body, h1)
+      choose_template(main, body, binding)
+    end
 
+    def choose_template(main, body, current_binding)
       if @options[:template]
-        erb = ERB.new(@options.read_template_file)
-        html = erb.result(binding)
+        html = ERB.new(@options.read_template_file).result(current_binding)
       else
         html = @options.create_html_template_with_current_options
-        html.head.push create_style(@options[:embed_css]) if @options[:embed_css]
-        html.push main||body
+        embed_css = @options[:embed_css]
+        html.head.push create_style(embed_css) if embed_css
+        html.push main || body
       end
 
       html
@@ -161,8 +189,7 @@ module PseudoHiki
     MDFormat = MarkDownFormat.create
     GFMFormat = MarkDownFormat.create(:gfm_style => true)
 
-    class Formatter < Struct.new(:version, :formatter, :template, :ext, :opt_pat)
-    end
+    Formatter = Struct.new(:version, :formatter, :template, :ext, :opt_pat)
 
     VERSIONS = [
                 ["html4", HtmlFormat, HtmlTemplate, ".html", /^h/io],
@@ -192,6 +219,21 @@ module PseudoHiki
       'latin1' => LATIN1
     }
 
+    @default_options = {
+      :html_version => VERSIONS[0],
+      :lang => 'en',
+      :encoding => 'utf8',
+      :title => nil,
+      :css => "default.css",
+      :embed_css => nil,
+      :base => nil,
+      :template => nil,
+      :output => nil,
+      :force => false,
+      :toc => nil,
+      :split_main_heading => false
+    }
+
     attr_accessor :need_output_file, :default_title
     attr_reader :input_file_basename
 
@@ -200,23 +242,16 @@ module PseudoHiki
       input.rewind unless BOM == bom
     end
 
+    def self.default_options
+      @default_options.dup
+    end
+
     def initialize(options=nil)
-      @options = options||{
-        :html_version => VERSIONS[0],
-        :lang => 'en',
-        :encoding => 'utf8',
-        :title => nil,
-        :css => "default.css",
-        :embed_css => nil,
-        :base => nil,
-        :template => nil,
-        :output => nil,
-        :force => false,
-        :toc => nil,
-        :split_main_heading => false
-      }
+      @options = options || self.class.default_options
       @written_option_pat = {}
-      @options.keys.each {|opt| @written_option_pat[opt] = /^\/\/#{opt}:\s*(.*)$/ }
+      @options.keys.each do |opt|
+        @written_option_pat[opt] = /^\/\/#{opt}:\s*(.*)$/
+      end
     end
 
     def [](key)
@@ -250,18 +285,18 @@ module PseudoHiki
     def base
       base_dir = self[:base]
       if base_dir and base_dir !~ /[\/\\]\.*$/o
-        base_dir = File.join(base_dir,".")
-        base_dir = "file:///"+base_dir if base_dir !~ /^\./o and win32?
+        base_dir = File.join(base_dir, ".")
+        base_dir = "file:///" + base_dir if base_dir !~ /^\./o and win32?
       end
       base_dir
     end
 
     def title
-      self[:title]||@default_title||"-"
+      self[:title] || @default_title || "-"
     end
 
     def read_template_file
-      File.read(File.expand_path(self[:template]), :encoding => self.charset)
+      File.read(File.expand_path(self[:template]), :encoding => charset)
     end
 
     def set_html_version(version)
@@ -272,7 +307,8 @@ module PseudoHiki
           self[:html_version] = v if v.opt_pat =~ version
         end
       end
-      STDERR.puts "\"#{version}\" is an invalid option for --format-version. \"#{self[:html_version].version}\" is chosen instead."
+      STDERR.puts "\"#{version}\" is an invalid option for --format-version. \
+\"#{self[:html_version].version}\" is chosen instead."
     end
 
     def set_html_encoding(given_opt)
@@ -282,7 +318,8 @@ module PseudoHiki
         ENCODING_REGEXP.each do |pat, encoding|
           self[:encoding] = encoding if pat =~ given_opt
         end
-        STDERR.puts "\"#{self[:encoding]}\" is chosen as an encoding system, instead of \"#{given_opt}\"."
+        STDERR.puts "\"#{self[:encoding]}\" is chosen as an encoding system, \
+instead of \"#{given_opt}\"."
       end
     end
 
@@ -294,67 +331,80 @@ module PseudoHiki
     end
 
     def parse_command_line_options
-      OptionParser.new("** Convert texts written in a Hiki-like notation into HTML **
-USAGE: #{File.basename(__FILE__)} [options]") do |opt|
+      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]",
-               "HTML version to be used. Choose html4, xhtml1, html5, plain, plain_verbose, markdown or gfm (default: #{self[:html_version].version})") do |version|
-          self.set_html_version(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|
+          set_html_version(version)
         end
 
         opt.on("-l [lang]", "--lang [=lang]",
-               "Set the value of charset attributes (default: #{self[:lang]})") do |lang|
+               "Set the value of charset attributes \
+(default: #{self[:lang]})") do |lang|
           self[:lang] = lang if value_given?(lang)
         end
 
         opt.on("-e [encoding]", "--format-encoding [=encoding]",
-               "Available options: utf8, euc-jp, sjis, latin1 (default: #{self[:encoding]})") do |given_opt|
-          self.set_html_encoding(given_opt)
+               "Available options: utf8, euc-jp, sjis, latin1 \
+(default: #{self[:encoding]})") do |given_opt|
+          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|
-          self.set_encoding(given_opt)
+               "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'
+        # 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 (default: the basename of the input file)") do |title|
+               "Set the value of the <title> element \
+(default: the basename of the input file)") do |title|
           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|
+               "Set the path to a css file to be used \
+(default: #{self[:css]})") do |css|
           self[:css] = css
         end
 
         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|
+               "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
 
         opt.on("-b [base]", "--base [=base]",
-               "Specify the value of href attribute of the <base> element (default: not specified)") do |base_dir|
+               "Specify the value of href attribute of the <base> element \
+(default: not specified)") do |base_dir|
           self[:base] = base_dir if value_given?(base_dir)
         end
 
         opt.on("-t [template]", "--template [=template]",
-               "Specify a template file written in eruby format with \"<%= body %>\" inside (default: not specified)") do |template|
+               "Specify a template file in eruby format with \"<%= body %>\" \
+inside (default: not specified)") do |template|
           self[:template] = template if value_given?(template)
         end
 
         opt.on("-o [output]", "--output [=output]",
-               "Output to the specified file. If no file is given, \"[input_file_basename].html\" will be used.(default: STDOUT)") do |output|
+               "Output to the specified file. If no file is given, \
+\"[input_file_basename].html\" will be used.(default: STDOUT)") do |output|
           self[:output] = File.expand_path(output) if value_given?(output)
-          self.need_output_file = true
+          @need_output_file = true
         end
 
         opt.on("-F", "--force",
-               "Force to apply command line options.(default: false)") do |force|
+               "Force to apply command line options. \
+(default: false)") do |force|
           self[:force] = force
         end
 
         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|
+               "Include the list of h2 and/or h3 headings with ids. \
+(default: nil)") do |toc_title|
           self[:toc] = toc_title
         end
 
@@ -363,6 +413,14 @@ USAGE: #{File.basename(__FILE__)} [options]") do |opt|
           self[:split_main_heading] = should_be_split
         end
 
+        opt.on("-W", "--with-wikiname",
+               "Use WikiNames") do |with_wikiname|
+          if with_wikiname
+            auto_linker = PseudoHiki::AutoLink::WikiName.new
+            PseudoHiki::BlockParser.auto_linker = auto_linker
+          end
+        end
+
         opt.parse!
       end
     end
@@ -370,11 +428,11 @@ USAGE: #{File.basename(__FILE__)} [options]") do |opt|
     def check_argv
       case ARGV.length
       when 0
-        if self.need_output_file and not self[:output]
+        if @need_output_file and not self[:output]
           raise "You must specify a file name for output"
         end
       when 1
-        self.read_input_filename(ARGV[0])
+        read_input_filename(ARGV[0])
       end
     end
 
@@ -396,33 +454,34 @@ USAGE: #{File.basename(__FILE__)} [options]") do |opt|
     end
 
     def create_html_template_with_current_options
-      return [] unless self.html_template
-      html = self.html_template.new
-      html.charset = self.charset
+      return [] unless html_template
+      html = html_template.new
+      html.charset = charset
       html.language = self[:lang]
       html.default_css = self[:css] if self[:css]
-      html.base = self.base if self[:base]
-      html.title = self.title
+      html.base = base if self[:base]
+      html.title = title
       html
     end
 
     def read_input_filename(filename)
       @input_file_dir, @input_file_name = File.split(File.expand_path(filename))
-      @input_file_basename = File.basename(@input_file_name,".*")
+      @input_file_basename = File.basename(@input_file_name, ".*")
     end
 
     def output_filename
-      return nil unless self.need_output_file
+      return nil unless @need_output_file
       if self[:output]
         File.expand_path(self[:output])
       else
-        File.join(@input_file_dir, @input_file_basename + self[:html_version].ext)
+        ext = self[:html_version].ext
+        File.join(@input_file_dir, @input_file_basename + ext)
       end
     end
 
     def open_output
-      if self.output_filename
-        open(self.output_filename, "w") {|f| yield f }
+      if output_filename
+        open(output_filename, "w") {|f| yield f }
       else
         yield STDOUT
       end