langhelp 0.9.8

data/lib/el4r/emacsruby/test-langhelp.rb

@@ -0,0 +1,300 @@
+
+require 'fileutils'
+
+class Object
+  def writef(filename)
+    open(File.expand_path(filename.to_s), "w"){|f| f.write(self.to_s)}
+  end
+end
+
+
+
+class TestLangHelp < Test::Unit::TestCase
+  load('langhelp.rb')
+
+  # User Setting Area
+  $w3m_el_path = "/usr/local/share/emacs/site-lisp/w3m/"
+  el_load "~/emacs/init.d/00init.el"
+  # /User Setting Area
+
+  add_to_list :load_path, $w3m_el_path
+  el_require :w3m
+
+  include LangHelp
+  def setup
+    @header = "/tmp/langhelpheader"
+    open(@header, "w"){}
+    
+    @langhelp_home = File.expand_path("../../../test", File.dirname(File.expand_path(__FILE__)))
+    @langhelprc = Tempfile.path(<<-EOR)
+    # -*- ruby -*-
+    @LANGHELP_HOME = #{@langhelp_home.dump}
+    @HTML2TXT = "w3m -dump -T text/html"
+    @lang = {}
+    @aliases = {}
+    @lang["ruby"] =        [
+      {:Ri => true},
+    ]
+    @aliases["ruby"] = %w[el4r]
+    @lang["hoge"] =         {:HogeHelp => true, :cmd=>"echo"}
+    @lang["echo"] =         {:Echo => true}
+    @lang["test-test0"] =        {:Test0 => true}
+    @lang["concat"] = [ "hoge", "echo" ]
+
+    @occur_by_grep = true
+    EOR
+
+    # *.e must exist!
+
+    el4r.instance_eval do
+      def ruby_mode(*x) elvar.major_mode = :ruby_mode end
+      def el4r_mode(*x) elvar.major_mode = :el4r_mode end
+      def test_test0_mode(*x) elvar.major_mode = :test_test0_mode end
+      def concat_mode(*x) elvar.major_mode = :concat_mode end
+      def isearch_forward(*x) end
+      def winconf_push(*x) end
+    end
+
+    # *langhelp:x* buffer is empty in this test
+    # So ee-anchor-format must be set!
+    elvar.ee_anchor_format = "<<<%s>>>"
+
+    @x = LangHelp.run(:langhelprc=>@langhelprc)
+  end
+
+  def teardown
+    File.unlink(@header)
+  end
+
+  # TODO 
+#   def test_concat
+#     Dir.chdir(@langhelp_home) do
+#       begin
+#         hoge = "content of hoge.e\n"
+#         echo = "content of echo.e\n"
+#         hoge.writef "hoge.e"
+#         echo.writef "echo.e"
+#         newbuf(:name=>"xxxx", :contents=>"", :display=>:pop) { concat_mode}
+#         langhelp
+#         assert_equal(hoge + echo, buffer_string)
+#       ensure
+#         FileUtils.rm_f %w[hoge.e echo.e]
+#       end
+#     end
+#   end
+
+  def test_newer
+    @x = LangHelpInternal.new(:major_mode=>"ruby", :datadir=>@langhelp_home)
+    @x.create_buffer
+    now = Time.now
+
+    # Header is older.
+    File.utime(now, now-100, @header)
+    assert_equal(false, @x.header_is_newer_than_buffer(@header))
+
+    # Header is newer.
+    File.utime(now, now+100, @header)
+    assert_equal(true, @x.header_is_newer_than_buffer(@header))
+  end
+
+  def assert_search(str)
+    goto_char 1
+    assert( search_forward(str, nil, true) )
+  end
+
+  def test_ruby
+    assert_instance_of(LangHelp, @x)
+
+    newbuf(:name=>"xxxx", :contents=>"", :display=>:pop) { ruby_mode}
+    langhelp
+    assert_equal("*langhelp:ruby*", buffer_name)
+    assert_search "lh-ri"
+
+    assert( fboundp(:lh_ri) )
+    assert( fboundp(:lh_hogehelp) )
+  end
+
+  def test_el4r
+    # alias test
+    assert_instance_of(LangHelp, @x)
+
+    newbuf(:name=>"xxxx", :contents=>"", :display=>:pop) { el4r_mode}
+    langhelp
+    assert_equal("*langhelp:ruby*", buffer_name)
+    assert_search "lh-ri"
+
+    assert( fboundp(:lh_ri) )
+    assert( fboundp(:lh_hogehelp) )
+  end
+
+
+  def test_test_test0
+    begin
+      e_file = File.join(@langhelp_home, "test-test0.e")
+      open(e_file,"w"){}
+      newbuf(:name=>"test0", :contents=>"", :display=>:pop) { test_test0_mode}
+      langhelp
+      assert_equal("*langhelp:test-test0*", buffer_name)
+
+    ensure
+      FileUtils.rm_f e_file
+    end
+    
+  end
+
+  def test_lh_xxx
+    set_buffer lh_hogehelp("x")
+    assert_equal(`echo x`, buffer_string)
+
+    # default CMD == class.to_s.downcase
+    assert( fboundp :lh_echo )
+    set_buffer lh_echo("y")
+    assert_equal(`echo y`, buffer_string)
+
+    set_buffer lh_test0("z")
+    assert_equal("0\n", buffer_string)
+
+  end
+
+  def test_occur
+    newbuf(:name=>"*langhelp:hoge*", :contents=>"abc\ndef\nabc\n", :display=>:only)
+    langhelp_menu_mode
+    langhelp_occur "abc"
+    assert_equal "*langhelp occur /abc/*", buffer_name
+    assert_equal "abc\nabc\n", buffer_string
+  end
+
+  def test_index_buffer
+    langhelp_switch_to_index_buffer
+    assert_equal("*langhelp index*", buffer_name)
+    assert_search "lh-language-index"
+  end
+
+  def test_revert_buffer
+    newbuf(:name=>"xxxx", :contents=>"", :display=>:pop) { ruby_mode}
+    langhelp
+    assert_equal("*langhelp:ruby*", buffer_name)
+    assert_search "lh-ri"
+    let(:buffer_read_only, nil){ erase_buffer }
+    assert_equal 0, buffer_size
+    langhelp_revert_buffer
+    assert_search "lh-ri"
+  end
+
+  def xtest_face
+    # Because font-lock-mode is off at batch mode, this test fails.
+    # (view-efile "font-lock.el" "  (when (or noninteractive")
+    let(:noninteractive, nil) do 
+      newbuf(:name=>"yyyy", :contents=>"# (lh-foo \"\")\n", :display=>:only, :point=>6)
+      langhelp_menu_mode
+      font_lock_mode 1
+      assert_equal :langhelp_sexp_face, get_char_property(5, :face)
+
+    end
+  end
+
+  def test_default
+    assert get_buffer("*langhelp index*")
+    newbuf(:name=>"xxxx", :contents=>"", :display=>:pop) { fundamental_mode }
+    langhelp
+    assert_equal "*langhelp index*", buffer_name
+  end
+  
+  def test_C_u
+    newbuf(:name=>"xxxx", :contents=>"", :display=>:pop) { ruby_mode }
+    langhelp 4
+    assert_equal "*langhelp index*", buffer_name
+  end
+
+  def test_info
+    lh_info "Distribution", "(emacs)Distrib"
+    with(:with_current_buffer, "*info*<langhelp>") do
+      assert_equal "Distrib", elvar.Info_current_node
+      assert_match /emacs$/, elvar.Info_current_file
+    end
+  end
+
+  # (lh-w3m nil "file:///home/rubikitch/src/langhelp/langhelp.en.html#Title:")
+  # (lh-w3m nil "file:///home/rubikitch/src/langhelp/langhelp.en.html#1")
+  def test_w3m_label
+    begin
+      html = File.expand_path "../../../langhelp.en.html", Dir.scriptdir
+      url = "file://#{html}#Title:"
+      lh_w3m nil, url
+      with(:with_current_buffer, "*w3m*") do
+        assert_match /Title:/, thing_at_point(:line)
+      end
+
+      # reuse the *w3m* buffer when URL is same
+      url = "file://#{html}#1"
+      lh_w3m nil, url
+      with(:with_current_buffer, "*w3m*") do
+        assert_match /1 /, thing_at_point(:line)
+      end
+
+      assert_equal 1, length(w3m_list_buffers)
+
+    ensure
+      kill_buffer "*w3m*"
+    end
+    
+  end
+
+  def test_lh_to
+    contents = <<XXX
+
+== Foo ==
+foo
+== Bar ==
+bar
+XXX
+    newbuf(:name=>"xxxx", :contents=>contents) do
+      make_local_variable :ee_anchor_format
+      elvar.ee_anchor_format = "== %s =="
+      lh_to "Bar"
+      beginning_of_line
+      assert looking_at("^== Bar ==")
+    end
+      
+  end
+
+  def _test_langhelp_narrow_to_section(line, result, contents)
+    newbuf(:name=>"xxxx", :contents=>contents) do
+      goto_line line
+      langhelp_narrow_to_section
+      assert_equal result, buffer_string
+    end
+  end
+
+  def test_langhelp_narrow_to_section
+    contents = <<XXX
+<<< zero >>>
+<<< one >>>
+ONE
+<<< two >>>
+TWO
+XXX
+
+    zero = <<XXX
+<<< zero >>>
+XXX
+
+    one = <<XXX
+<<< one >>>
+ONE
+XXX
+
+    two = <<XXX
+<<< two >>>
+TWO
+XXX
+
+    _test_langhelp_narrow_to_section 1, zero,  contents
+    _test_langhelp_narrow_to_section 2, one, contents
+    _test_langhelp_narrow_to_section 3, one, contents
+    _test_langhelp_narrow_to_section 4, two, contents
+    _test_langhelp_narrow_to_section 5, two, contents
+
+  end
+
+end

data/lib/langhelp/langhelp-base.rb

@@ -0,0 +1,649 @@
+#  
+#  langhelp-base.rb - Create langhelp index of various languages
+#  Copyright (C) 2005 rubikitch <rubikitch@ruby-lang.org>
+#  Version: $Id: langhelp-base.rb 1383 2006-09-21 07:24:26Z rubikitch $
+
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#    This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#    You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require 'fileutils'
+require 'tempfile'
+require 'uri'
+require 'cgi'
+require 'kconv'
+require 'zlib'
+
+# begin require 'rubygems'; rescue LoadError; 0 end
+# require 'hpricot'
+
+module LocalVariables
+  ANCHOR_BEGIN = "<<<"
+  ANCHOR_END   = ">>>"
+  
+  def insert_local_variables(out)
+    out << "Local" << " Variables:\n"
+    out << "mode: langhelp-menu\n"
+    out << "truncate-lines: t\n"
+    out << "tab-width: 75\n"
+    out << "ee-anchor-format: \"#{ANCHOR_BEGIN}%s#{ANCHOR_END}\"\n"
+    out << "End:\n"
+  end
+end
+
+Zlib::GZIP_MAGIC = "\037\213"
+def File.zread(file)
+  Object.module_eval do
+    open(file) do |f|
+      magic = f.read(2)
+      if magic == Zlib::GZIP_MAGIC
+        f.rewind
+        gz = Zlib::GzipReader.new(f)
+        begin
+          gz.read
+        ensure
+          gz.close
+        end
+      else
+        magic + f.read
+      end
+    end
+  end    
+end
+
+module FilenameString
+  # Expand filenames
+  def normalize_filename!(*filenames)
+    if $langhelp_home
+      filenames.each do |filename|
+        filename.replace File.expand_path(filename, $langhelp_home)
+      end
+    end
+  end
+
+  def abbreviate_filename!(filename)
+    if $langhelp_home
+      re = Regexp.new("^"+Regexp.quote($langhelp_home)+"/?")
+      filename.sub!(re, '')
+    end
+    filename
+  end
+
+  def abbreviate_filename(filename)
+    abbreviate_filename!(filename.dup)
+  end
+
+end
+
+module EmacsLispString
+  def lisp_dump_string(string)
+    dumped = string.dup
+    # \ -> \\
+    dumped.gsub! %r"\\" do '\\\\' end
+    # " -> \"
+    dumped.gsub! %r'"' do '\\"' end
+    # (zero byte) -> \0
+    dumped.gsub! %r'\0' do "\\\0" end
+    %Q'"#{dumped}"'
+  end
+end
+
+module GeneratedMessage
+  include FilenameString
+
+  def processing(lang)
+    $stderr.puts "Processing #{lang} ..."
+  end
+
+  def generated(filename)
+    $stderr.puts "Generated #{abbreviate_filename(filename)} (size=#{File.size(filename)})"
+  end
+end
+
+module KanjiConverter
+  KCONVERTERS = {
+    :none   => lambda{|s| s},
+    :euc_jp => lambda{|s| $KCODE='e'; s.toeuc },
+    :sjis   => lambda{|s| $KCODE='s'; s.tosjis },
+    :utf8   => lambda{|s| $KCODE='u'; s.toutf8 },
+  }
+
+
+  def encoding
+    conf ? conf[:ENCODING] : :none
+  end
+
+  # Convert kanji code according to encoding()
+  def kconv(&block)
+    KCONVERTERS[encoding()][yield]
+  end
+end
+
+module MkArray
+  # Make an Array
+  def mkarray(obj)
+    if Array === obj
+      obj
+    else
+      [obj]
+    end
+  end
+end
+
+# Abstract class of information index
+class AbstractIndex
+  SPACES = "\t"
+
+  include EmacsLispString
+
+  def initialize(x={})
+    @title = x[:title]
+    @arg1 = x[self.class.to_s.intern]
+    @conf = x[:conf]
+    init x
+  end
+
+  # Initialize for subclass.
+  # Do not process files! only do initialization.
+  def init(x={})
+  end
+
+  # 1st parameter ie. the key is a symbol of class name
+  attr :arg1
+
+  # Hash specified by configuration file.
+  attr_accessor :conf
+
+  # The title of the index.
+  attr_accessor :title
+
+  include MkArray
+  include KanjiConverter
+  include FilenameString
+  include LocalVariables
+  def output_title(io)
+    if title
+      io.puts "#### #{ANCHOR_BEGIN}#{title}#{ANCHOR_END} ####"
+    end
+  end
+
+  # Dump into e-script
+  def to_e(io)
+  end
+end
+
+# Abstract class of a hyperlink to a file.
+class AbstractLink < AbstractIndex
+  def init(x={})
+    @src = arg1
+    @label = x[:label]
+  end
+
+  # Hyperlink EmacsLisp function. ie. lh-xxx
+  def func
+  end
+
+  # Dump into e-script
+  def to_e(io)
+    label = @label ? (@label + SPACES) : ""
+    io << %Q!# #{label}(#{func} nil #{lisp_dump_string(@src)})\n!
+  end
+end
+
+# A lh-view hyperlink to a file
+class ViewLink < AbstractLink
+  def func() "lh-view" end
+end
+
+# A lh-w3m hyperlink to an HTML file.
+class W3MLink  < AbstractLink
+  def func() "lh-w3m" end
+end
+
+module StripTags
+  Q =  /[\"\']?/
+  NQ = /[^\"\'> ]+/
+  ALT = /[^\"\'>]+/
+
+  def html2txt!(s)
+    s.gsub!(/<img .*?alt=#{Q}(#{ALT})#{Q}.*?>/imo, '\1')
+    s.gsub!(/<[^>]+>/,'')
+    s.gsub!(/&nbsp;/, ' ')
+    s.replace CGI.unescapeHTML(s)
+    s.gsub!(/\r?\n/,' ')
+    s.gsub!(/\s+/, ' ')
+    s
+  end
+
+end
+
+# Extract links from an HTML file, and create lh-w3m hyperlinks.
+class W3MExtractLinks < AbstractIndex
+  def init(x={})
+    @html = arg1
+    normalize_filename! @html
+    @base = URI.parse("file://#{x[:base] || @html}")
+    @exclude_label = mkarray(x[:exclude_label])
+    @exclude_url   = mkarray(x[:exclude_url])
+  end
+
+  Link = Struct.new :href, :label
+
+  include StripTags
+
+  def links
+    src = kconv{ File.read @html }
+    src.scan(%r!<a .*?href=#{Q}(#{NQ})#{Q}.*?>(.+?)</a>!imo).map {|href,label|
+      uri = @base.merge href
+      url = uri.to_s
+      path = uri.path
+      html2txt! label
+      next if @exclude_label.any?{|exclude| exclude === label}
+      next if @exclude_url.any?{|exclude| exclude === href}
+      abbreviate_filename! path
+      url = path if uri.scheme == 'file'
+      Link.new(url,label)
+    }.compact
+  end
+
+  def to_e(out)
+    links.each{|link|
+      out << %Q!# #{link.label}#{SPACES}(lh-w3m nil #{lisp_dump_string(link.href)})\n!
+    }
+    
+  end
+end
+
+# Information index class by man
+class Manpage < AbstractIndex
+  def init(x={})
+    if x[:manpath]
+      @manpath = x[:manpath]
+      @sections = arg1
+      @glob = x[:glob] || '*'
+      normalize_filename! *@manpath
+      extend Manpages
+    else
+      @section = x[:section].to_s
+      @name = arg1
+      @default_regexp =  /^\S|^\s+\-/
+      @additional_regexp = x[:regexp]
+      extend ManpageIndex
+    end
+  end
+
+  # manipulate single manpage
+  module ManpageIndex
+    def man_contents
+      ENV['PAGER'] = 'cat'
+      kconv{ `man #{@section} #{@name} 2> /dev/null`.strip }
+    end
+
+    LINK = Struct.new :line
+    def links
+      man_contents()[1..-2].find_all{|line|
+        line =~ @default_regexp or (@additional_regexp and line =~ @additional_regexp)
+      }.map{|line|
+        LINK.new(line.chomp)
+      }
+    end
+
+    def to_e(io)
+      links.each{|link|
+        io << %Q!# (lh-man* #{lisp_dump_string(link.line)}\t"#{@section} #{@name}")\n!
+      }
+    end
+  end
+
+  # manipulate multiple manpages (It does not read manpage contents.) 
+  module Manpages
+    Man = Struct.new :section, :man
+
+    def manpages
+      @sections.map {|section|
+        sectdir = "man#{section}"
+        @manpath.map {|dir|
+          if File.directory? dir
+            Dir[File.join(dir,sectdir,@glob)].map {|file|
+              man = File.basename(file).sub(/\.\d\w*(\.gz)?$/,'')
+              Man.new section, man
+            }
+          end
+        }
+      }.flatten.compact
+    end
+
+
+    def to_e(io)
+      manpages.each do |man|
+        io << %Q!# (lh-man "#{man.section} #{man.man}")\n!
+      end
+    end
+
+  end
+
+end
+
+# Common initialization of Grep/W3MGrep class.
+module GrepInit
+  def init(x={})
+    if x[:regexp]               # new version
+      @regexp = x[:regexp]
+      @src = arg1
+    else                        # deprecated
+      @regexp = arg1
+      @src = x[:src]
+    end
+    @exclude = mkarray(x[:exclude])
+    normalize_filename! @src
+  end
+end
+
+# Information index class by grep
+class Grep < AbstractIndex
+  include GrepInit
+
+  # Dump into e-script
+  def to_e(io)
+    src = abbreviate_filename(@src)
+    kconv{ File.zread(@src) }.grep(@regexp).map{|line|
+      line.chomp!
+      next if @exclude.any?{|exclude| exclude === line }
+      io << %Q!# (lh-view #{lisp_dump_string(line)}#{SPACES}#{lisp_dump_string(src)})\n!
+    }
+  end
+end
+  
+# Information index class by grep with w3m
+class W3MGrep < AbstractIndex
+  include GrepInit
+
+  # Dump into e-script
+  def to_e(io)
+#    `#{conf[:HTML2TXT]} #{f.path}`.grep(@regexp).map{|line|
+    src = abbreviate_filename(@src)
+    kconv{ `w3m -dump #{@src.dump}` }.grep(@regexp).map{|line|
+      io << %Q!# (lh-w3m #{lisp_dump_string(line.chomp)}#{SPACES}#{lisp_dump_string(src)})\n!
+    }
+  end
+end
+  
+
+# Information index class by HTML source
+class HTMLIndex < AbstractIndex
+  def init(x={})
+    @spaces = x[:spaces] || 20
+    init_filename x
+  end
+
+  def init_filename(x)
+    if arg1 =~ /\.html$/
+      @index_page = arg1
+      @dir = File.dirname(@index_page)
+    else
+      @dir = x[:dir]
+      @index_page = x[:index_page]
+    end
+
+    normalize_filename! @dir, @index_page
+  end
+
+  def find_index
+  end
+  private :find_index
+
+  # number of spaces between label and sexp
+  def space
+    "&nbsp;"*@spaces
+  end
+
+  # overridden by subclass
+  def pre_process(html_src)
+    html_src
+  end
+
+  # overridden by subclass
+  def post_process(es_src)
+    es_src
+  end
+
+  # Dump into e-script
+  # pre_process -> HTML2TXT -> post_process
+  def to_e(out)
+    find_index unless @index_page
+    f = Tempfile.new("lh")
+    
+    f.puts(pre_process(kconv{ File.read(@index_page) }))
+    f.close
+    out << post_process(kconv{ `#{conf[:HTML2TXT]} #{f.path}` })
+  end
+end
+
+class HTML < AbstractIndex
+
+  class Tag < Struct.new(:filename, :no, :content, :element)
+    def url
+      url = "file://" + File.expand_path(filename)
+      url << "##{no}" if no
+      url
+    end
+
+    include StripTags
+
+    def label
+      self.content = content.dup
+      html2txt! content
+      content.gsub! /\r?\n/, ' '
+      if element =~ /^<h([1-6])/i
+        header = "  " + "="*$1.to_i + " "
+      elsif element =~  /^<dt/i
+        header = "  : "
+      elsif element =~ /^<title/i
+        header = "Title: "
+      else
+        raise "cannot happen"
+      end
+      header + content
+    end
+  end
+  
+  class Converter
+    include KanjiConverter
+    def initialize(x={})
+      @filename = x[:tagify_html]
+      @noconv = x[:noconv]
+      @recursive = x[:recursive]
+
+      @html_obj = x[:html_obj]
+      @conf = x[:conf]
+    end
+    attr :tags
+    attr :conf
+
+    # Chop meta-charset tag to avoid mojibake
+    def chop_meta_charset!(html)
+      html.sub!(/<meta[^>]*charset[^>]+>/mi,'')
+    end
+
+    include StripTags
+    def treat_recursive(html)
+      if @recursive == :next
+        if html =~ /<link[^>]*rel=#{Q}next#{Q}[^>]*href=#{Q}(#{NQ})#{Q}/o
+          uri = URI.parse("file://"+@original_filename)
+          return if $1 == ''
+          href = uri.merge($1)
+          @html_obj.add_html href.path
+        end
+      end
+    end
+
+    def _tagify(html)
+      no = "0001"
+      @tags = []
+
+      if @noconv
+        after = html.dup
+      else
+        after = html.toeuc
+        chop_meta_charset! after
+      end
+
+      treat_recursive after
+
+      if after =~ /(<title[^>]*>)(.+)<\/title>/
+        @tags << Tag.new(@filename, nil, $2, $1)
+      end
+
+      after.gsub!(%r!(<h[1-6][^>]*>)(.+?)(</h[1-6]>)|(<dt[^>]*>)(.+?)(</dt>|<dd)!im) {
+        hn, content_hn, hn_close, dt, content_dt, dt_close = Regexp.last_match.captures
+        begin
+          no_tag = %Q!<a name="#{no}"></a>!
+          if hn
+            @tags << Tag.new(@filename, no, content_hn, hn)
+            hn + no_tag + content_hn + hn_close
+          elsif dt
+            @tags << Tag.new(@filename, no, content_dt, dt)
+            dt + no_tag + content_dt + dt_close
+          else
+            raise "cannot happen!"
+          end
+        ensure
+          no = no.succ
+        end
+      }
+
+      if html =~ /\A<!-- Tagified by langhelp -->/
+        html
+      else
+        "<!-- Tagified by langhelp -->\n" + after
+      end
+    end
+    private :_tagify
+
+    def copy_and_set_filename_unless_writable
+      @original_filename = @filename
+      unless File.writable? @filename
+        newfile = "#{$langhelp_home}#{@filename}"
+        FileUtils.mkdir_p File.dirname(newfile)
+        FileUtils.rm_f newfile
+        FileUtils.cp @filename, newfile
+        FileUtils.chmod 0644, newfile
+        @filename = newfile
+      end
+    end
+
+
+    def tagify
+#      $stderr.puts "Tagifying #{@filename}..."
+      copy_and_set_filename_unless_writable
+      open(@filename, "rb+") do |f|
+        after = _tagify(kconv{ f.read })
+        f.rewind
+        f.write(after)
+      end
+    end
+  end
+
+  class SingleHTML < AbstractIndex
+    def init(x={})
+      @tagify_html = x[:tagify_html]
+      normalize_filename! @tagify_html
+      @converter = Converter.new x
+    end
+    attr :tagify_html
+
+    def tagify
+      @converter.tagify
+    end
+
+    def to_e(out)
+      tagify
+      @converter.tags.each do |tag|
+        out << %Q!# #{tag.label}#{SPACES}(lh-w3m nil "#{tag.url}")\n!
+      end
+    end
+
+    def ==(other)
+      return false if self.class != other.class
+      @tagify_html == other.tagify_html
+    end
+  end
+
+  def init(x={})
+    @x = x
+    @basedir = x[:basedir]
+    @recursive = x[:recursive]
+    @single_htmls = mkarray(x[:HTML]).flatten.map{|html|
+      html = File.join(@basedir, html) if @basedir
+      normalize_filename! html
+      Dir[html]
+    }.flatten.map{|html|
+      single_html_factory html
+    }
+    @additional_htmls = []
+  end
+
+  def single_html_factory(tagify_html)
+    SingleHTML.new @x.update(:tagify_html=>tagify_html, :html_obj=>self, :conf=>conf)
+  end
+  private :single_html_factory
+
+  def add_html(html)
+    obj = single_html_factory(html)
+    @additional_htmls << obj unless @additional_htmls.include? obj
+  end
+
+  def each_html(&block)
+    @single_htmls.each &block
+    @additional_htmls.each &block
+  end
+
+  def tagify
+    each_html {|single| single.tagify }
+  end
+
+  def to_e(out)
+    each_html {|single| single.to_e out }
+  end
+
+end
+
+# Composite: collects information indexes.
+class Suite
+
+  def initialize(x={})
+    @debug_mode = x[:debug_mode]
+    @indexes = []
+  end    
+
+  # Add a index to suite.
+  def <<(index)
+    @indexes << index
+  end
+
+  # Dump into e-script
+  def to_e(io)
+    @indexes.each do |index|
+      begin
+        index.output_title(io)
+        index.to_e(io)
+      rescue
+        $stderr.puts $!
+        $stderr.puts $@ if @debug_mode
+        $stderr.puts "Failed to write `#{index.title}'."
+      end
+    end
+  end
+end
+
+# Local Variables:
+# test-script: "../../test/test-base.rb"
+# End: