bitclust-core 0.6.0 → 0.7.0

data/lib/bitclust/subcommands/setup_command.rb

@@ -8,116 +8,112 @@ require 'yaml'
 require 'bitclust'
 require 'bitclust/subcommand'
 
-module BitClust::Subcommands
-  class SetupCommand < BitClust::Subcommand
+module BitClust
+  module Subcommands
+    class SetupCommand < Subcommand
 
-    REPOSITORY_PATH = "http://jp.rubyist.net/svn/rurema/doctree/trunk"
+      REPOSITORY_PATH = "http://jp.rubyist.net/svn/rurema/doctree/trunk"
 
-    def initialize
-      @prepare = nil
-      @cleanup = nil
-      @versions = ["1.8.7", "1.9.3", "2.0.0"]
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} setup [options]"
-        opt.on('--prepare', 'Prepare config file and checkout repository. Do not create database.') {
+      def initialize
+        super
+        @prepare = nil
+        @cleanup = nil
+        @versions = ["1.8.7", "1.9.3", "2.0.0"]
+        @parser.banner = "Usage: #{File.basename($0, '.*')} setup [options]"
+        @parser.on('--prepare', 'Prepare config file and checkout repository. Do not create database.') {
           @prepare = true
         }
-        opt.on('--cleanup', 'Cleanup datebase before create database.') {
+        @parser.on('--cleanup', 'Cleanup datebase before create database.') {
           @cleanup = true
         }
-        opt.on('--versions=V1,V2,...', "Specify versions. [#{@versions.join(',')}]") {|versions|
+        @parser.on('--versions=V1,V2,...', "Specify versions. [#{@versions.join(',')}]") {|versions|
           @versions = versions.split(",")
         }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
+      end
 
-    def exec(db, argv)
-      prepare
-      return if @prepare
-      @config[:versions].each do |version|
-        puts "Generating database for Ruby#{version}..."
-        prefix = "#{@config[:database_prefix]}-#{version}"
-        FileUtils.rm_rf(prefix) if @cleanup
-        init_argv = ["version=#{version}", "encoding=#{@config[:encoding]}"]
-        db = BitClust::MethodDatabase.new(prefix)
-        InitCommand.new.exec(db, init_argv)
-        update_method_database(prefix, ["--stdlibtree=#{@config[:stdlibtree]}"])
-        argv = Pathname(@config[:capi_src]).children.select(&:file?).map{|v| v.realpath.to_s }
-        update_function_database(prefix, argv)
+      def exec(argv, options)
+        prepare
+        return if @prepare
+        @config[:versions].each do |version|
+          puts "Generating database for Ruby#{version}..."
+          prefix = "#{@config[:database_prefix]}-#{version}"
+          FileUtils.rm_rf(prefix) if @cleanup
+          init_argv = ["version=#{version}", "encoding=#{@config[:encoding]}"]
+          init_options = { :prefix => prefix }
+          InitCommand.new.exec(init_argv, init_options)
+          update_method_database(prefix, ["--stdlibtree=#{@config[:stdlibtree]}"])
+          update_argv = Pathname(@config[:capi_src]).children.select(&:file?).map{|v| v.realpath.to_s }
+          update_function_database(prefix, update_argv)
+        end
       end
-    end
 
-    private
+      private
 
-    def prepare
-      home_directory = Pathname(ENV["HOME"])
-      config_dir = home_directory + ".bitclust"
-      config_dir.mkpath
-      config_path = config_dir + "config"
-      rubydoc_dir = config_dir + "rubydoc"
-      @config = {
-        :database_prefix => (config_dir + "db").to_s,
-        :encoding => "utf-8",
-        :versions => @versions,
-        :default_version => @versions.max,
-        :stdlibtree => (rubydoc_dir + "refm/api/src").to_s,
-        :capi_src => (rubydoc_dir + "refm/capi/src/").to_s,
-        :baseurl => "http://localhost:10080",
-        :port => "10080",
-        :pid_file => "/tmp/bitclust.pid",
-      }
-      if config_path.exist?
-        @config = YAML.load_file(config_path)
-        unless @config[:versions].sort == @versions.sort
-          print("overwrite config file? > [y/N]")
-          if /\Ay\z/i =~ $stdin.gets.chomp
-            @config[:versions] = @versions
-            @config[:default_version] = @versions.max
-            generate_config(config_path, @config)
+      def prepare
+        home_directory = Pathname(ENV["HOME"])
+        config_dir = home_directory + ".bitclust"
+        config_dir.mkpath
+        config_path = config_dir + "config"
+        rubydoc_dir = config_dir + "rubydoc"
+        @config = {
+          :database_prefix => (config_dir + "db").to_s,
+          :encoding        => "utf-8",
+          :versions        => @versions,
+          :default_version => @versions.max,
+          :stdlibtree      => (rubydoc_dir + "refm/api/src").to_s,
+          :capi_src        => (rubydoc_dir + "refm/capi/src/").to_s,
+          :baseurl         => "http://localhost:10080",
+          :port            => "10080",
+          :pid_file        => "/tmp/bitclust.pid",
+        }
+        if config_path.exist?
+          @config = YAML.load_file(config_path)
+          unless @config[:versions].sort == @versions.sort
+            print("overwrite config file? > [y/N]")
+            if /\Ay\z/i =~ $stdin.gets.chomp
+              @config[:versions] = @versions
+              @config[:default_version] = @versions.max
+              generate_config(config_path, @config)
+            end
           end
+        else
+          generate_config(config_path, @config)
         end
-      else
-        generate_config(config_path, @config)
+        checkout(rubydoc_dir)
       end
-      checkout(rubydoc_dir)
-    end
 
-    def generate_config(path, config)
-      path.open("w+", 0644) do |file|
-        file.puts config.to_yaml
+      def generate_config(path, config)
+        path.open("w+", 0644) do |file|
+          file.puts config.to_yaml
+        end
       end
-    end
 
-    def checkout(rubydoc_dir)
-      case RUBY_PLATFORM
-      when /mswin(?!ce)|mingw|cygwin|bccwin/
-        cmd = "svn help > NUL 2> NUL"
-      else
-        cmd = "svn help > /dev/null 2> /dev/null"
-      end
-      unless system(cmd)
-        warn "svn command is not found. Please install Subversion."
-        exit 1
+      def checkout(rubydoc_dir)
+        unless system("svn", "co", REPOSITORY_PATH, rubydoc_dir.to_s)
+          warn "svn command failed. Please install Subversion or check your PATH."
+          exit 1
+        end
       end
-      system("svn", "co", REPOSITORY_PATH, rubydoc_dir.to_s)
-    end
 
-    def update_method_database(prefix, argv)
-      db = BitClust::MethodDatabase.new(prefix)
-      cmd = UpdateCommand.new
-      cmd.parse(argv)
-      cmd.exec(db, argv)
-    end
+      def update_method_database(prefix, argv)
+        options = {
+          :prefix => prefix,
+          :capi => false,
+        }
+        cmd = UpdateCommand.new
+        cmd.parse(argv)
+        cmd.exec(argv, options)
+      end
 
-    def update_function_database(prefix, argv)
-      db = BitClust::FunctionDatabase.new(prefix)
-      cmd = UpdateCommand.new
-      cmd.parse(argv)
-      cmd.exec(db, argv)
+      def update_function_database(prefix, argv)
+        options = {
+          :prefix => prefix,
+          :capi => true,
+        }
+        cmd = UpdateCommand.new
+        cmd.parse(argv)
+        cmd.exec(argv, options)
+      end
     end
   end
 end

data/lib/bitclust/subcommands/statichtml_command.rb

@@ -0,0 +1,276 @@
+# Copyright (c) 2006-2007 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'fileutils'
+
+require 'bitclust'
+require 'bitclust/subcommand'
+require 'bitclust/progress_bar'
+require 'bitclust/silent_progress_bar'
+
+module BitClust
+  module Subcommands
+    class StatichtmlCommand < Subcommand
+      class URLMapperEx < URLMapper
+        def library_url(name)
+          if name == '/'
+            $bitclust_html_base + "/library/index.html"
+          else
+            $bitclust_html_base + "/library/#{encodename_package(name)}.html"
+          end
+        end
+
+        def class_url(name)
+          $bitclust_html_base + "/class/#{encodename_package(name)}.html"
+        end
+
+        def method_url(spec)
+          cname, tmark, mname = *split_method_spec(spec)
+          $bitclust_html_base +
+            "/method/#{encodename_package(cname)}/#{typemark2char(tmark)}/#{encodename_package(mname)}.html"
+        end
+
+        def function_url(name)
+          $bitclust_html_base + "/function/#{name.empty? ? 'index' : name}.html"
+        end
+
+        def document_url(name)
+          $bitclust_html_base + "/doc/#{encodename_package(name)}.html"
+        end
+
+        def css_url
+          $bitclust_html_base + "/" + @css_url
+        end
+
+        def favicon_url
+          $bitclust_html_base + "/" + @favicon_url
+        end
+
+        def library_index_url
+          $bitclust_html_base + "/library/index.html"
+        end
+
+        def function_index_url
+          $bitclust_html_base + "/function/index.html"
+        end
+
+        def encodename_package(str)
+          if $fs_casesensitive
+            NameUtils.encodename_url(str)
+          else
+            NameUtils.encodename_fs(str)
+          end
+        end
+      end
+
+      def initialize
+        if Object.const_defined?(:Encoding)
+          Encoding.default_external = 'utf-8'
+        end
+        super
+        @verbose = true
+        @catalogdir = nil
+        @templatedir = srcdir_root + "data/bitclust/template.offline"
+        @themedir = srcdir_root + "theme/default"
+        @parser.banner = "Usage: #{File.basename($0, '.*')} statichtml [options]"
+        @parser.on('-o', '--outputdir=PATH', 'Output directory') do |path|
+          begin
+            @outputdir = Pathname.new(path).realpath
+          rescue Errno::ENOENT
+            FileUtils.mkdir_p(path, :verbose => @verbose)
+            retry
+          end
+        end
+        @parser.on('--catalog=PATH', 'Catalog directory') do |path|
+          @catalogdir = Pathname.new(path).realpath
+        end
+        @parser.on('--templatedir=PATH', 'Template directory') do |path|
+          @templatedir = Pathname.new(path).realpath
+        end
+        @parser.on('--themedir=PATH', 'Theme directory') do |path|
+          @themedir = Pathname.new(path).realpath
+        end
+        @parser.on('--fs-casesensitive', 'Filesystem is case-sensitive') do
+          $fs_casesensitive = true
+        end
+        @parser.on('--[no-]quiet', 'Be quiet') do |quiet|
+          @verbose = !quiet
+        end
+      end
+
+      def exec(argv, options)
+        create_manager_config
+
+        prefix = options[:prefix]
+        db = MethodDatabase.new(prefix.to_s)
+        fdb = FunctionDatabase.new(prefix.to_s)
+        manager = ScreenManager.new(@manager_config)
+
+        db.transaction do
+          methods = {}
+          db.methods.each_with_index do |entry, i|
+            entry.names.each do |name|
+              method_name = entry.klass.name + entry.typemark + name
+              (methods[method_name] ||= []) << entry
+            end
+          end
+
+          entries = db.docs + db.libraries.sort + db.classes.sort
+          create_html_entries("entries", entries, manager, db)
+          create_html_methods("methods", methods, manager, db)
+        end
+
+        fdb.transaction do
+          functions = {}
+          create_html_entries("capi", fdb.functions, manager, fdb)
+        end
+
+        $bitclust_html_base = '..'
+        create_file(@outputdir + 'library/index.html',
+                    manager.library_index_screen(db.libraries.sort, {:database => db}).body,
+                    :verbose => @verbose)
+        create_file(@outputdir + 'class/index.html',
+                    manager.class_index_screen(db.classes.sort, {:database => db}).body,
+                    :verbose => @verbose)
+        create_file(@outputdir + 'function/index.html',
+                    manager.function_index_screen(fdb.functions.sort, { :database => fdb }).body,
+                    :verbose => @verbose)
+        create_index_html(@outputdir)
+        FileUtils.cp(@manager_config[:themedir] + @manager_config[:css_url],
+                     @outputdir.to_s, {:verbose => @verbose, :preserve => true})
+        FileUtils.cp(@manager_config[:themedir] + @manager_config[:favicon_url],
+                     @outputdir.to_s, {:verbose => @verbose, :preserve => true})
+        Dir.mktmpdir do |tmpdir|
+          FileUtils.cp_r(@manager_config[:themedir] + 'images', tmpdir,
+                         {:verbose => @verbose, :preserve => true})
+          Dir.glob(File.join(tmpdir, 'images', '/**/.svn')).each do |d|
+            FileUtils.rm_r(d, {:verbose => @verbose})
+          end
+          FileUtils.cp_r(File.join(tmpdir, 'images'), @outputdir.to_s,
+                         {:verbose => @verbose, :preserve => true})
+        end
+      end
+
+      private
+
+      def create_manager_config
+        @manager_config = {
+          :catalogdir  => @catalogdir,
+          :suffix      => '.html',
+          :templatedir => @templatedir,
+          :themedir    => @themedir,
+          :css_url     => 'style.css',
+          :favicon_url => 'rurema.png',
+          :cgi_url     => '',
+          :tochm_mode  => true
+        }
+        @manager_config[:urlmapper] = URLMapperEx.new(@manager_config)
+      end
+
+      def create_html_entries(title, entries, manager, db)
+        original_title = title.dup
+        if @verbose
+          progressbar = ProgressBar.new(title, entries.size)
+        else
+          progressbar = SilentProgressBar.new(title, entries.size)
+        end
+        entries.each do |entry|
+          create_html_file(entry, manager, @outputdir, db)
+          progressbar.title.replace([entry].flatten.first.name)
+          progressbar.inc
+        end
+        progressbar.title.replace(original_title)
+        progressbar.finish
+      end
+
+      def create_html_methods(title, methods, manager, db)
+        original_title = title.dup
+        if @verbose
+          progressbar = ProgressBar.new(title, methods.size)
+        else
+          progressbar = SilentProgressBar.new(title, methods.size)
+        end
+        methods.each do |method_name, method_entries|
+          create_html_method_file(method_name, method_entries, manager, @outputdir, db)
+          progressbar.title.replace(method_name)
+          progressbar.inc
+        end
+        progressbar.title.replace(original_title)
+        progressbar.finish
+      end
+
+      def create_index_html(outputdir)
+        path = outputdir + 'index.html'
+        File.open(path, 'w'){|io|
+          io.write <<HERE
+<meta http-equiv="refresh" content="0; URL=doc/index.html">
+<a href="doc/index.html">Go</a>
+HERE
+        }
+      end
+
+      def create_html_file(entry, manager, outputdir, db)
+        e = entry.is_a?(Array) ? entry.sort.first : entry
+        case e.type_id
+        when :library, :class, :doc
+          $bitclust_html_base = '..'
+          path = outputdir + e.type_id.to_s + (encodename_package(e.name) + '.html')
+          create_html_file_p(entry, manager, path, db)
+          path.relative_path_from(outputdir).to_s
+        when :function
+          create_html_function_file(entry, manager, outputdir, db)
+        else
+          raise
+        end
+        e.unload
+      end
+
+      def create_html_method_file(method_name, entries, manager, outputdir, db)
+        path = nil
+        $bitclust_html_base = '../../..'
+        e = entries.sort.first
+        name = method_name.sub(e.klass.name + e.typemark, "")
+        path = outputdir + e.type_id.to_s + encodename_package(e.klass.name) +
+          e.typechar + (encodename_package(name) + '.html')
+        create_html_file_p(entries, manager, path, db)
+        path.relative_path_from(outputdir).to_s
+      end
+
+      def create_html_function_file(entry, manager, outputdir, db)
+        path = nil
+        $bitclust_html_base = '..'
+        path = outputdir + entry.type_id.to_s + (entry.name + '.html')
+        create_html_file_p(entry, manager, path, db)
+        path.relative_path_from(outputdir).to_s
+      end
+
+      def create_html_file_p(entry, manager, path, db)
+        FileUtils.mkdir_p(path.dirname) unless path.dirname.directory?
+        html = manager.entry_screen(entry, {:database => db}).body
+        path.open('w') do |f|
+          f.write(html)
+        end
+      end
+
+      def create_file(path, str, options = {})
+        verbose = options[:verbose]
+        $stderr.print("creating #{path} ...") if verbose
+        path.open('w') do |f|
+          f.write(str)
+        end
+        $stderr.puts(" done.") if verbose
+      end
+
+      def encodename_package(str)
+        if $fs_casesensitive
+          NameUtils.encodename_url(str)
+        else
+          NameUtils.encodename_fs(str)
+        end
+      end
+    end
+  end
+end