pseudohikiparser 0.0.0.4.develop

data/bin/pseudohiki2html.rb

@@ -0,0 +1,319 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'optparse'
+require 'erb'
+require 'pseudohiki/blockparser'
+require 'pseudohiki/htmlformat'
+require 'pseudohiki/plaintextformat'
+require 'htmlelement/htmltemplate'
+require 'htmlelement'
+
+include PseudoHiki
+
+OPTIONS = {
+  :html_version => "html4",
+  :lang => 'en',
+  :encoding => 'utf8',
+  :title => nil,
+  :css => "default.css",
+  :embed_css => nil,
+  :base => nil,
+  :template => nil,
+  :output => nil,
+  :force => false,
+  :toc => nil
+}
+
+ENCODING_REGEXP = {
+  /^u/io => 'utf8',
+  /^e/io => 'euc-jp',
+  /^s/io => 'sjis',
+  /^l[a-zA-Z]*1/io => 'latin1'
+}
+
+HTML_VERSIONS = %w(html4 xhtml1 html5)
+
+FILE_HEADER_PAT = /^(\xef\xbb\xbf)?\/\//
+WRITTEN_OPTION_PAT = {}
+OPTIONS.keys.each {|opt| WRITTEN_OPTION_PAT[opt] = /^(\xef\xbb\xbf)?\/\/#{opt}:\s*(.*)$/ }
+HEADING_WITH_ID_PAT = /^(!{2,3})\[([A-Za-z][0-9A-Za-z_\-.:]*)\]/o
+
+PlainFormat = PlainTextFormat.create
+
+class InputManager
+  def formatter
+    @formatter ||= OPTIONS.html_template.new
+  end
+
+  def create_table_of_contents(lines)
+    toc_lines = lines.grep(HEADING_WITH_ID_PAT).map do |line|
+      m = HEADING_WITH_ID_PAT.match(line)
+      heading_depth, id = m[1].length, m[2].upcase
+      "%s[[%s|#%s]]"%['*'*heading_depth, to_plain(line.sub(HEADING_WITH_ID_PAT,'')), id]
+    end
+    OPTIONS.formatter.format(BlockParser.parse(toc_lines))
+  end
+
+  def create_main(toc, body)
+    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 toc_container
+      element.push contents_container
+    end
+  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 compose_body(input_lines)
+    tree = BlockParser.parse(input_lines)
+    OPTIONS.formatter.format(tree)
+  end
+
+  def compose_html(input_lines)
+    css = OPTIONS[:css]
+    toc = create_table_of_contents(input_lines)
+    body = compose_body(input_lines)
+    title = OPTIONS.title
+    main = create_main(toc,body)
+
+    if OPTIONS[:template]
+      erb = ERB.new(OPTIONS.read_template_file)
+      html = erb.result(binding)
+    else
+      html = OPTIONS.create_html_with_current_options
+      html.head.push create_style(OPTIONS[:embed_css]) if OPTIONS[:embed_css]
+      html.push main||body
+    end
+
+    html
+  end
+end
+
+def to_plain(line)
+  PlainFormat.format(BlockParser.parse(line.lines.to_a)).to_s.chomp
+end
+
+def win32? 
+  true if RUBY_PLATFORM =~ /win/i
+end
+
+def value_given?(value)
+  value and not value.empty?
+end
+
+class << OPTIONS
+  include HtmlElement::CHARSET
+  attr_accessor :need_output_file, :default_title
+  attr_reader :input_file_basename
+
+  ENCODING_TO_CHARSET = {
+    'utf8' => UTF8,
+    'euc-jp' => EUC_JP,
+    'sjis' => SJIS,
+    'latin1' => LATIN1
+  }
+
+  HTML_TEMPLATES = Hash[*HTML_VERSIONS.zip([HtmlTemplate, XhtmlTemplate, Xhtml5Template]).flatten]
+  FORMATTERS = Hash[*HTML_VERSIONS.zip([HtmlFormat, XhtmlFormat, Xhtml5Format]).flatten]
+
+  def html_template
+    HTML_TEMPLATES[self[:html_version]]
+  end
+
+  def formatter
+    FORMATTERS[self[:html_version]]
+  end
+
+  def charset
+    ENCODING_TO_CHARSET[self[:encoding]]
+  end
+
+  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?
+    end
+    base_dir
+  end
+
+  def title
+    OPTIONS[:title]||@default_title||"-"
+  end
+
+  def read_template_file
+    File.read(File.expand_path(self[:template]))
+  end
+
+  def set_html_version(version)
+    if HTML_VERSIONS.include? version
+      self[:html_version] = version
+    else
+      case version
+      when /^x/io
+        self[:html_version] = HTML_VERSIONS[1] #xhtml1
+      when /^h5/io
+        self[:html_version] = HTML_VERSIONS[2] #html5
+      end
+      STDERR.puts "\"#{version}\" is an invalid option for --html_version. \"#{self[:html_version]}\" is chosen instead."
+    end
+  end
+
+  def set_encoding(given_opt)
+    if ENCODING_REGEXP.values.include? given_opt
+      self[:encoding] = given_opt
+    else
+      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}\"."
+    end
+  end
+
+  def set_options_from_input_file(input_lines)
+    input_lines.each do |line|
+      break if FILE_HEADER_PAT !~ line
+      line = line.chomp
+      self.keys.each do |opt|
+        if WRITTEN_OPTION_PAT[opt] =~ line and not self[:force]
+          self[opt] = $2
+        end
+      end
+    end
+  end
+
+  def create_html_with_current_options
+    html = self.html_template.new
+    html.charset = self.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
+  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,".*")
+  end
+
+  def output_file_name
+    return nil unless self.need_output_file
+    if self[:output]
+      File.expand_path(self[:output])
+    else
+      File.join(@input_file_dir, @input_file_basename+".html")
+    end
+  end
+end
+
+OptionParser.new("** Convert texts written in a Hiki-like notation into HTML **
+USAGE: #{File.basename(__FILE__)} [options]") do |opt|
+  opt.on("-h [html_version]", "--html_version [=html_version]",
+         "HTML version to be used. Choose html4 or xhtml1 (default: #{OPTIONS[:html_version]})") do |version|
+    OPTIONS.set_html_version(version)
+  end
+
+  opt.on("-l [lang]", "--lang [=lang]", 
+         "Set the value of charset attributes (default: #{OPTIONS[:lang]})") do |lang|
+    OPTIONS[:lang] = lang if value_given?(lang)
+  end
+
+  opt.on("-e [encoding]", "--encoding [=encoding]",
+         "Available options: utf8, euc-jp, sjis, latin1 (default: #{OPTIONS[:encoding]})") do |given_opt|
+    OPTIONS.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 (default: the basename of the input file)") do |title|
+    OPTIONS[:title] = title if value_given?(title)
+  end
+
+  opt.on("-c [css]", "--css [=css]",
+           "Set the path to a css file to be used (default: #{OPTIONS[:css]})") do |css|
+    OPTIONS[:css] = css
+  end
+
+  opt.on("-C [path_to_css_file]", "--embed-css [=path_to_css_file]",
+           "Set the path to a css file to be used (default: not to embed)") do |path_to_css_file|
+    OPTIONS[: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|
+    OPTIONS[: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|
+    OPTIONS[: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|
+    OPTIONS[:output] = File.expand_path(output) if value_given?(output)
+    OPTIONS.need_output_file = true
+  end
+
+  opt.on("-f", "--force",
+         "Force to apply command line options.(default: false)") do |force|
+    OPTIONS[: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|
+    OPTIONS[:toc] = toc_title
+  end
+
+  opt.parse!
+end
+
+if $KCODE
+  ENCODING_REGEXP.each do |pat, encoding|
+    OPTIONS[:encoding] = encoding if pat =~ $KCODE and not OPTIONS[:force]
+  end
+end
+
+input_manager = InputManager.new
+
+case ARGV.length
+when 0
+  if OPTIONS.need_output_file and not OPTIONS[:output]
+    raise "You must specify a file name for output"
+  end
+when 1
+  OPTIONS.read_input_filename(ARGV[0])
+end
+
+input_lines = ARGF.lines.to_a
+
+OPTIONS.set_options_from_input_file(input_lines)
+OPTIONS.default_title = OPTIONS.input_file_basename
+
+html = input_manager.compose_html(input_lines)
+output_file_name = OPTIONS.output_file_name
+
+if output_file_name
+  open(output_file_name, "w") {|f| f.puts html }
+else
+  STDOUT.puts html
+end

data/lib/htmlelement/htmltemplate.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env ruby
+
+require 'htmlelement'
+
+class HtmlTemplate
+
+  META_CHARSET = "text/html; charset=%s"
+  LANGUAGE = Hash.new("en")
+  LANGUAGE[HtmlElement::CHARSET::EUC_JP] = "ja"
+  LANGUAGE[HtmlElement::CHARSET::SJIS] = "ja"
+  ELEMENT = { self => HtmlElement }
+
+  def initialize(charset=ELEMENT[self.class]::CHARSET::UTF8, language="en", css_link="default.css", base_uri=nil)
+    @html = create_element("html", nil, "lang" => language)
+    @head = create_element("head")
+    @charset = charset
+    @content_language = create_meta("Content-Language", language)
+    @base = set_path_to_base(base_uri)
+    @content_type = set_charset_in_meta(charset)
+    @content_style_type = create_meta("Content-Style-Type","text/css")
+    @content_script_type = create_meta("Content-Script-Type","text/javascript")
+    @default_css_link = create_css_link(css_link)
+    @title = nil
+    @title_element = create_element("title")
+    @body = create_element("body")
+    @html.push @head
+    @html.push @body
+    [ @content_language,
+      @content_type,
+      @content_sytle_type,
+      @content_script_type,
+      @title_element,
+      @base,
+      @default_css_link
+    ].each do |element|
+      @head.push element
+    end
+  end
+  attr_reader :title, :head
+
+  def create_element(*params)
+    ELEMENT[self.class].create(*params)
+  end
+
+  def charset=(charset_name)
+    @charset=charset_name
+    @content_language["content"] = LANGUAGE[@charset]
+    @content_type["content"] = META_CHARSET%[charset_name]
+  end
+
+  def language=(language)
+    @content_language["content"] = language
+    @html["lang"] = language
+  end
+
+  def base=(base_uri)
+    if @base.empty?
+      @base = create_element("base", nil, "href" => base_uri)
+      @head.push @base
+    else
+      @base["href"] = base_uri
+    end
+  end
+
+  def add_css_file(file_path)
+    @head.push create_css_link(file_path)
+  end
+
+  def default_css=(file_path)
+    @default_css_link["href"] = file_path
+  end
+
+  def title=(title)
+    @title_element.pop until @title_element.empty?
+    @title = title
+    @title_element.push title
+  end
+
+  def push(element)
+    @body.push element
+  end
+
+  def euc_jp!
+    self.charset = ELEMENT[self.class]::CHARSET::EUC_JP
+    self.language = "ja"
+  end
+
+  def sjis!
+    self.charset = ELEMENT[self.class]::CHARSET::SJIS
+    self.language = "ja"
+  end
+
+  def utf8!
+    self.charset = ELEMENT[self.class]::CHARSET::UTF8
+  end
+
+  def latin1!
+    self.charset = ELEMENT[self.class]::CHARSET::LATIN1
+  end
+
+  def to_s
+    [ELEMENT[self.class].doctype(@charset),
+      @html].join("")
+  end
+
+  private
+
+  def create_meta(type,content)
+    create_element("meta", nil,
+                   "http-equiv" => type,
+                   "content" => content)
+  end
+
+  def create_css_link(file_path)
+    create_element("link", nil,
+                   "rel" => "stylesheet",
+                   "type" => "text/css",
+                   "href" => file_path)
+  end
+
+  def set_charset_in_meta(charset)
+    create_meta("Content-Type",META_CHARSET%[charset])
+  end
+
+  def set_path_to_base(base_uri)
+    return "" unless base_uri
+    create_element("base", nil, "href" => base_uri)
+  end
+end
+
+class XhtmlTemplate < HtmlTemplate
+  ELEMENT[self] = XhtmlElement
+
+  def initialize(*params)
+    super(*params)
+    @html['xmlns'] = 'http://www.w3.org/1999/xhtml'
+    @html["xml:lang"] =  @html["lang"] #language
+  end
+
+  def language=(language)
+    super(language)
+    @html["xml:lang"] = language
+  end
+end
+
+class Xhtml5Template < XhtmlTemplate
+  ELEMENT[self] = Xhtml5Element
+
+  def initialize(*params)
+    super(*params)
+
+    def @content_language.to_str
+      ""
+    end
+
+    def @content_script_type.to_str
+      ""
+    end
+  end
+
+  def set_charset_in_meta(charset)
+    create_element("meta", nil, "charset" => charset)
+  end
+
+  def charset=(charset_name)
+    @charset=charset_name
+    @content_type["charset"] = @charset
+  end
+end

data/lib/htmlelement.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+require 'kconv'
+
+class HtmlElement
+  class Children < Array
+    def to_s
+      self.join
+    end
+  end
+
+  module CHARSET
+    EUC_JP = "EUC-JP"
+    SJIS = "Shift_JIS"
+    UTF8 = "UTF-8"
+    LATIN1 = "ISO-8859-1"
+  end
+
+  DOCTYPE = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">'.split(/\r?\n/o).join($/)+"#{$/}"
+
+  ESC = {
+    '&' => '&amp;',
+    '"' => '&quot;',
+    '<' => '&lt;',
+    '>' => '&gt;'
+  }
+
+  DECODE = ESC.invert
+  CharEntityPat = /#{DECODE.keys.join("|")}/
+  
+  Html5Tags = %w(article section hgroup aside nav menu header footer figure details legend)
+
+  ELEMENT_TYPES = {
+    :BLOCK => %w(html body div table colgroup thead tbody ul ol dl head p pre blockquote style),
+    :HEADING_TYPE_BLOCK => %w(dt dd tr title h1 h2 h3 h4 h5 h6),
+    :LIST_ITEM_TYPE_BLOCK => %w(li col),
+    :EMPTY_BLOCK => %w(img meta link base input hr)
+  }
+  
+  ELEMENTS_FORMAT = {
+    :INLINE => "<%s%s>%s</%s>",
+    :BLOCK => "<%s%s>#{$/}%s</%s>#{$/}",
+    :HEADING_TYPE_BLOCK => "<%s%s>%s</%s>#{$/}",
+    :LIST_ITEM_TYPE_BLOCK => "<%s%s>%s#{$/}",
+    :EMPTY_BLOCK => "<%s%s>#{$/}"
+  }
+
+  attr_reader :tagname
+  attr_accessor :parent, :children
+
+  def self.doctype(encoding="UTF-8")
+    self::DOCTYPE%[encoding]
+  end
+
+  def self.create(tagname, content=nil, attributes={})
+    if self::Html5Tags.include? tagname
+      attributes["class"] = tagname
+      tagname = "div"
+    end
+    self.new(tagname, content, attributes)
+  end
+
+  def HtmlElement.comment(content)
+    "<!-- #{content} -->#{$/}"
+  end
+
+  def HtmlElement.urlencode(str)
+    str.toutf8.gsub(/[^\w\.\-]/n) {|ch| format('%%%02X', ch[0]) }
+  end
+
+  def HtmlElement.urldecode(str)
+    utf = str.gsub(/%\w\w/) {|ch| [ch[-2,2]].pack('H*') }
+    return utf.tosjis if $KCODE =~ /^s/io
+    return utf.toeuc if $KCODE =~ /^e/io
+    utf
+  end
+
+  def self.assign_tagformats
+    tagformats = Hash.new(ELEMENTS_FORMAT[:INLINE])
+    self::ELEMENT_TYPES.each do |type, names|
+      names.each {|name| tagformats[name] = self::ELEMENTS_FORMAT[type] }
+    end
+    tagformats[""] = "%s%s%s"
+    tagformats
+  end
+
+  def HtmlElement.escape(str)
+    str.gsub(/[&"<>]/on) {|pat| ESC[pat] }
+  end
+
+  def HtmlElement.decode(str)
+    str.gsub(CharEntityPat) {|ent| DECODE[ent]}
+  end
+
+  TagFormats = self.assign_tagformats
+
+  def initialize(tagname, content=nil, attributes={})
+    @parent = nil
+    @tagname = tagname
+    @children = Children.new
+    @children.push content if content
+    @attributes = attributes
+    @end_comment_not_added = true
+  end
+
+  def empty?
+    @children.empty?
+  end
+
+  def push(child)
+    @children.push child
+    child.parent = self if child.kind_of? HtmlElement
+    self
+  end
+
+  def pop
+    @children.pop
+  end
+
+  def []=(attribute, value)
+    @attributes[attribute] = value
+  end
+
+  def [](attribute)
+    @attributes[attribute]
+  end
+  
+  def format_attributes
+    @attributes.collect do |attr,value|
+      ' %s="%s"'%[attr,HtmlElement.escape(value.to_s)]
+    end.sort.join
+  end
+  private :format_attributes
+
+  def add_end_comment_for_div_or_section
+    if @tagname == "div" or @tagname == "section" and @end_comment_not_added
+      id_or_class = self["id"]||self["class"]
+      self.push HtmlElement.comment("end of #{id_or_class}") if id_or_class
+      @end_comment_not_added = false
+    end
+  end
+
+  def to_s
+    add_end_comment_for_div_or_section
+    self.class::TagFormats[@tagname]%[@tagname, format_attributes, @children, @tagname]
+  end
+  alias to_str to_s
+end
+  
+class XhtmlElement < HtmlElement
+  DOCTYPE = '<?xml version="1.0" encoding="%s"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'.split(/\r?\n/o).join($/)+"#{$/}"
+
+  ELEMENTS_FORMAT = self.superclass::ELEMENTS_FORMAT.dup
+  ELEMENTS_FORMAT[:LIST_ITEM_TYPE_BLOCK] = "<%s%s>%s</%s>#{$/}"
+  ELEMENTS_FORMAT[:EMPTY_BLOCK] = "<%s%s />#{$/}"
+
+  TagFormats = self.assign_tagformats
+end
+
+class Xhtml5Element < XhtmlElement
+  DOCTYPE = '<?xml version="1.0" encoding="%s"?>
+<!DOCTYPE html>'.split(/\r?\n/o).join($/)+"#{$/}"
+
+  ELEMENT_TYPES = self.superclass::ELEMENT_TYPES.dup
+  ELEMENT_TYPES[:BLOCK] = self.superclass::ELEMENT_TYPES[:BLOCK] + self.superclass::Html5Tags
+  Html5Tags = %w(main)
+
+  TagFormats = self.assign_tagformats
+end