gonzui 1.2

data/lib/gonzui/vcs.rb

@@ -0,0 +1,128 @@
+#
+# vcs.rb - simple interface to version control systems
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module Gonzui
+  class VCSError < GonzuiError; end
+
+  class AbstractVCS
+    include Util
+
+    def initialize(config, root, mozule)
+      @config = config
+      @root = root
+      @mozule = mozule
+    end
+
+    private
+    def run_command(command_line, message)
+      printf("running %s...\n", message) unless @config.quiet
+      dn = "/dev/null"
+      dn = "nul" if (/mswin|mingw|bccwin/ =~ RUBY_PLATFORM)
+      command_line += ">#{dn} 2>&1" unless @config.verbose
+      status = system(command_line)
+      raise VCSError.new("command execution failed") if status == false
+    end
+
+    public
+    def extract
+      File.mkpath(@config.cache_directory)
+      output_directory = File.join(@config.cache_directory, @mozule)
+      if not File.exist?(output_directory)
+        do_checkout(output_directory)
+      elsif File.directory?(output_directory)
+        do_update(output_directory)
+      else
+        raise VCSError.new("#{output_directory}: obstacle found")
+      end
+      return output_directory
+    end
+
+    def clean
+    end
+  end
+
+  class CVS < AbstractVCS
+    def initialize(config, root, mozule)
+      require_command("cvs")
+      super(config, root, mozule)
+    end
+
+    def do_checkout(output_directory)
+      Dir.chdir(@config.cache_directory) {
+        command_line = sprintf("cvs -z3 -d %s co -P %s", 
+                               shell_escape(@root),
+                               shell_escape(@mozule))
+        run_command(command_line, "cvs checkout")
+      }
+    end
+
+    def do_update(output_directory)
+      Dir.chdir(output_directory) {
+        run_command("cvs -z3 update -dP", "cvs update")
+      }
+    end
+
+    def do_extract
+      File.mkpath(@config.cache_directory)
+      output_directory = File.join(@config.cache_directory, @mozule)
+      if File.exist?(output_directory)
+        run_cvs_update(output_directory)
+      else
+        run_cvs_checkout
+      end
+      return output_directory
+    end
+  end
+
+  class Subversion < AbstractVCS
+    def initialize(config, root, mozule)
+      require_command("svn")
+      super(config, root, mozule)
+    end
+
+    def do_checkout(output_directory)
+      Dir.chdir(@config.cache_directory) {
+        command_line = sprintf("svn co %s %s", 
+                               shell_escape(@root),
+                               shell_escape(@mozule))
+        run_command(command_line, "svn checkout")
+      }
+    end
+
+    def do_update(output_directory)
+      Dir.chdir(output_directory) {
+        run_command("svn update","svn update")
+      }
+    end
+  end
+
+  class Git < AbstractVCS
+    def initialize(config, root, mozule = nil)
+      require_command("git")
+      mozule = File.basename(URI.parse(root).path, ".git") unless mozule
+      super(config, root, mozule)
+    end
+
+    def do_checkout(output_directory)
+      Dir.chdir(@config.cache_directory) {
+        command_line = sprintf("git clone %s",
+                               shell_escape(@root))
+        run_command(command_line, "git clone")
+      }
+    end
+
+    def do_update(output_directory)
+      Dir.chdir(output_directory) {
+        run_command("git pull","git pull")
+      }
+    end
+  end
+end

data/lib/gonzui/webapp.rb

@@ -0,0 +1,25 @@
+#
+# webapp.rb - a library for web-based applications
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'gonzui/webapp/xmlformatter'
+require 'gonzui/webapp/webrick'
+require 'gonzui/webapp/uri'
+require 'gonzui/webapp/servlet'
+require 'gonzui/webapp/snippet'
+
+require 'gonzui/webapp/advsearch'
+require 'gonzui/webapp/filehandler'
+require 'gonzui/webapp/jsfeed'
+require 'gonzui/webapp/markup'
+require 'gonzui/webapp/search'
+require 'gonzui/webapp/source'
+require 'gonzui/webapp/stat'
+require 'gonzui/webapp/top'

data/lib/gonzui/webapp/advsearch.rb

@@ -0,0 +1,123 @@
+#
+# advsearch.rb - advanced search servlet
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module Gonzui
+  class AdvancedSearchServlet < GonzuiAbstractServlet
+    def self.mount_point
+      "advsearch"
+    end
+
+    def do_make_status_line
+      []
+    end
+
+    def make_target_select
+      tt = get_short_name(:target_type)
+      select = [:select, {:name => tt}]
+      oall = [:option, {:type => "radio", :name => tt, 
+              :value => ""}, _("All")]
+      select.push(oall)
+      LangScan::Type.each_group {|group|
+        og = [:optgroup, {:label => _(group.name)}]
+        added_p = false
+        group.each {|type_info|
+          if @dbm.has_type?(type_info.type)
+            o = [:option, {:type => "radio", :name => tt, 
+                :value => type_info.type}, _(type_info.name)]
+            og.push(o)
+            added_p = true
+          end
+        }
+        select.push(og) if added_p
+      }
+      return select
+    end
+
+    def make_nresults_select
+      nr = get_short_name(:nresults_per_page)
+      select = [:select, {:name => nr}]
+      @config.nresults_candidates.each {|n|
+        o = [:option, {:type => "radio", :name => nr, 
+            :value => n}, sprintf(_("%d results"), n)]
+        select.push(o)
+      }
+      return select
+    end
+
+    def make_target_specific_search_form
+      form = [:form, { :method => "get", 
+                       :action => make_uri_general(SearchServlet)}]
+
+      ikeyword = [:input, {:type => "text", :size => 30, 
+          :name => get_short_name(:basic_query),
+          :value => @search_query.keywords.join(" ")}]
+      iphrase = [:input, {:type => "text", :size => 30, 
+          :name => get_short_name(:phrase_query),
+          :value => (@search_query.phrases.first or []).join(" ")}]
+
+      nresults_select = make_nresults_select
+
+      isubmit = [:input, {:type => "submit", :value => _("Search")}]
+
+      table = [:table]
+      table.push([:tr, [:td, {:width => "20%"}, _("Keyword")], 
+                   [:td, {:width => "30%"}, ikeyword], 
+                   [:td, {:width => "15%"}, nresults_select],
+                   [:td, {:width => "15%"}, isubmit]])
+      table.push([:tr, [:td, {:width => "20%"}, _("Phrase")], 
+                   [:td, {:width => "30%"}, iphrase]])
+
+      table.push([:tr])
+
+      target_select = make_target_select
+      table.push([:tr, [:td, _("Target")], 
+                   [:td, target_select], [:td]])
+
+      format_select = make_format_select
+      table.push([:tr, [:td, _("Format")], [:td, format_select], [:td]])
+
+      license_select = make_license_select
+      table.push([:tr, [:td, _("License")], [:td, license_select], [:td]])
+
+      form.push(table)
+      return form
+    end
+
+    def make_advanced_search_form
+      form = make_target_specific_search_form
+      return [:div, {:class =>"advanced-search"}, form]
+    end
+
+    def do_GET(request, response)
+      init_servlet(request, response)
+      log()
+
+      html = make_html
+      title = make_title(_("Advanced Search"))
+      head = [:head, title, *make_meta_and_css]
+      body = [:body]
+
+      h1 = make_h1
+      status_line = make_status_line(_("Advanced Search"))
+      content = make_advanced_search_form
+      footer = make_footer
+      body.push(h1, status_line, content, footer)
+
+      html.push(head)
+      html.push(body)
+      set_content_type_text_html
+      response.body = format_html(html)
+    end
+
+    GonzuiServlet.register(self)
+  end
+end
+

data/lib/gonzui/webapp/filehandler.rb

@@ -0,0 +1,24 @@
+#
+# filehandler.rb - file handler servlet
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module Gonzui
+  class FileHandler < WEBrick::HTTPServlet::FileHandler
+    def self.mount_point
+      "doc"
+    end
+
+    def initialize(server, config, logger, dbm, catalogs)
+      super(server, config.doc_directory)
+    end
+
+    GonzuiServlet.register(self)
+  end
+end

data/lib/gonzui/webapp/jsfeed.rb

@@ -0,0 +1,61 @@
+#
+# jsfeed - javascript-feed servlet
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module Gonzui
+  class JSFeedServlet < GonzuiAbstractServlet
+    def self.mount_point
+      "jsfeed"
+    end
+
+    def do_GET(request, response)
+      init_servlet(request, response)
+      path = make_path
+      log(path)
+
+      from = to = nil
+      if m = /^(\d+)-(\d+)$/.match(request.query_string)
+        from = m[1].to_i
+        to   = m[2].to_i
+      end
+
+      if from and to
+        path_id = @dbm.get_path_id(path)
+        if path_id
+          content = @dbm.get_content(path_id)
+          lineno = 0
+          lines = []
+          range = Range.new(from, to)
+          content.each_line {|line|
+            lineno += 1
+            if range.include?(lineno)
+              line_with_lineno = sprintf("%5d: %s", lineno, line)
+              line_with_lineno.chop!
+              lines.push(HTMLUtils.escape(line_with_lineno))
+            end
+          }
+          snippet = lines.join("<br />")
+          response.body = sprintf("document.writeln('<pre>%s</pre>');", 
+                                  snippet)
+          response['Content-Type'] = "application/x-javascript"
+        else 
+          response.body = sprintf("%s: not found", path)
+          response.status = 404
+          response['Content-Type'] = "text/html"
+        end
+      else
+        response.body = "invalid query"
+        response['Content-Type'] = "text/html"
+      end
+    end
+
+    GonzuiServlet.register(self)
+  end
+end

data/lib/gonzui/webapp/markup.rb

@@ -0,0 +1,445 @@
+#
+# markup.rb - markup servlet
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'stringio'
+require 'zlib'
+require 'strscan'
+
+module Gonzui
+  class TextBeautifier
+    def initialize(content, digest, occurrences, search_uri)
+      @content = content
+      @digest = digest # to be destroyed
+      @occurrences = occurrences # to be destroyed
+      @search_uri = search_uri
+
+      @break_points = [0, @content.length]
+      @lines = {}
+      pos = lineno = 0
+      @content.each_line {|line|
+        lineno += 1
+        @break_points.push(pos)
+        @lines[pos] = [lineno, line]
+        pos += line.length
+      }
+      @digest.each {|info|
+        @break_points.push(info.byteno)
+        @break_points.push(info.end_byteno)
+      }
+      @occurrences.each {|occ|
+        @break_points.push(occ.byteno)
+        @break_points.push(occ.end_byteno)
+      }
+      @break_points.uniq!
+      @break_points.sort!
+
+      @info = @digest.shift
+      @occ = @occurrences.shift
+      @seen_ids = {}
+      @latest_id = "0"
+    end
+
+    def make_line_mark(lineno)
+      anchor = "l" + lineno.to_s
+      [:span, {:class => "lineno", :onclick => "olnc(this);"},
+        [:a, {:id => anchor, :name => anchor, :href => "#" + anchor}, 
+          sprintf("%5d: ", lineno)]]
+    end
+
+    def choose_target_type
+      case @info.type
+      when :fundef 
+        :funcall
+      when :funcall
+        :fundef
+      when :fundecl
+        :fundef
+      else 
+        assert_not_reached
+      end
+    end
+
+    def decorate(text)
+      unless @seen_ids.include?(text)
+        @seen_ids[text] = @latest_id
+        @latest_id = @latest_id.next
+      end
+      id = @seen_ids[text]
+      inner = [:span, {:class => id, :onmouseover => "hl('#{id}');"}, text]
+      part = [:span, {:class => @info.type.to_s}, inner]
+        
+      if LangScan::Type.function?(@info.type)
+        tt = choose_target_type
+        query_string =  sprintf("%s:%s", tt, HTTPUtils.escape_form(text))
+        uri = @search_uri + query_string
+        part = [:a, {:href => uri}, part]
+      end
+      return part
+    end
+
+    def markup_part(bp, ep)
+      part =  @content[bp...ep]
+      if @info and (bp == @info.byteno or @info.range.include?(bp))
+        part = decorate(part)
+        @info = @digest.shift if @info.end_byteno <= ep
+      end
+      if @occ and (bp == @occ.byteno or @occ.range.include?(bp))
+        part = [:strong, {:class => "highlight"}, part]
+        @occ = @occurrences.shift if @occ.end_byteno <= ep
+      end
+      return part
+    end
+
+    def make_lineno_part(bp)
+      lineno, line = @lines[bp]
+      [:span, {:class => "line", :title => line}, make_line_mark(lineno)]
+    end
+
+    def beautify
+      code = []
+      bp = @break_points.shift
+      line = nil
+      while not @break_points.empty?
+        ep = @break_points.shift
+        if @lines.include?(bp)
+          code.push(line) if line
+          line = make_lineno_part(bp)
+        end
+        part = markup_part(bp, ep)
+        line.push(part)
+        bp = ep
+      end
+      code.push(line) if line
+      return code
+    end
+  end
+
+  class MarkupServlet < GonzuiAbstractServlet
+    def self.mount_point
+      "markup"
+    end
+
+    def make_breadcrumbs(path)
+      parts = path.split("/")
+      breadcrumbs = (1 .. parts.length).map {|i| 
+        [ parts[i - 1], parts[0, i]]
+      }.map {|part, parts|
+        path = parts.join("/")
+        uri = make_markup_uri(parts.join("/"), @search_query)
+        [:a, {:href => uri}, part]
+      }
+      (breadcrumbs.length - 1).times {|i|
+        breadcrumbs.insert(i * 2 + 1, "/")
+      }
+      return [:span, *breadcrumbs]
+    end
+
+    def do_make_status_line(method)
+      items = []
+
+      case method
+      when :markup_file
+        if @path_id
+          bare = [:a, {:href => make_source_uri(@path)}, 
+            _("bare source")]
+          permlink = [:a, {:href => make_markup_uri(@path)}, 
+            _("permlink")]
+          items.push(bare)
+          items.push(permlink)
+        end
+      when :list_files
+        if @total
+          items.push([:span, [:strong, @total], _(" contents.")])
+        end
+      when :list_packages
+        if @to and @total
+          packages = [:span, _("Packages "), 
+            [:strong, commify(@from + 1)], " - ",
+            [:strong, commify(@to)], _(" of "),
+            [:strong, commify(@total)], _(".")]
+          items.push(packages)
+        end
+      end
+      return items
+    end
+
+    def calc_ncolumns(items)
+      sum = items.inject(0) {|a, b| 
+        name = b.first
+        a + name.length 
+      }
+      average = sum / items.length
+      ncolumns = [40 / average, items.length].min
+      ncolumns = 1 if ncolumns == 0
+      return ncolumns
+    end
+
+    def make_table(items)
+      table = [:table, {:class => "fullwidth"}]
+      return table if items.empty?
+      ncolumns = calc_ncolumns(items)
+      width = sprintf("%d%%", 100/ncolumns)
+
+      nrows = (items.length - 1) / ncolumns + 1
+      nrows.times {|i|
+        k = if (i + 1) % 2 == 0 then "even" else "odd" end
+        row = [:tr, {:class => k}]
+        ncolumns.times {|j|
+          # item = items[j * nrows + i] # for vertical arrange
+          item = items[i * ncolumns + j]
+          value = if item
+                    name, klass, image, uri, title = item
+                    tr = [:tr]
+                    if image
+                      img = [:img, {:src => image, :alt => ""}]
+                      tr << [:td, [:a, {:href => uri}, img]]
+                    end
+                    a = [:a, {:class => klass, :href =>uri,:title =>title}, name]
+                    tr << [:td, a]
+                    [:table, {:class => "item"}, tr]
+                  else
+                    make_spacer
+                  end
+          k = if j == 0 then "first" else "nonfirst" end
+          td = [:td, {:width => width, :class => k}, value]
+          row.push(td)
+        }
+        table.push(row)
+      }
+      return table
+    end
+
+    def make_title_for_path(path, file_p)
+      title = if file_p 
+                path_id = @dbm.get_path_id(path)
+                info = @dbm.get_content_info(path_id)
+                sprintf(_("Size: %s (%s lines)"),
+                        format_bytes(info.size),
+                        commify(info.nlines))
+              else 
+                ""
+              end
+      return title
+    end
+
+    def make_table_of_files(paths)
+      items = paths.map {|path, file_p|
+        basename = File.basename(path)
+        klass = if file_p then "file" else "directory" end
+        image = if file_p 
+                  make_doc_uri("text.png")
+                else 
+                  make_doc_uri("folder.png")
+                end
+        uri = make_markup_uri(path, @search_query)
+        title = make_title_for_path(path, file_p)
+        [basename, klass, image, uri, title]
+      }
+      return make_table(items)
+    end
+
+    def make_table_of_packages(package_names)
+      items = package_names.map {|package_name|
+        package_id = @dbm.get_package_id(package_name)
+        uri = make_markup_uri(package_name)
+        title = ""
+        [package_name, "directory", nil, uri, title]
+      }
+      return make_table(items)
+    end
+
+    def list_files
+      path_parts = @path.split("/")
+      depth = path_parts.length
+      
+      package_id = @dbm.get_package_id(@package_name)
+      path_ids = @dbm.get_path_ids(package_id)
+      paths = path_ids.map {|path_id|
+        @dbm.get_path(path_id)
+      }.map {|path| 
+        path.split("/")
+      }.find_all {|parts|
+        parts.length > depth and parts[0, depth] == path_parts
+      }.map {|parts|
+        file_p = parts.length == depth + 1
+        [parts[0, depth + 1].join("/"), file_p]
+      }.uniq
+      if paths.empty?
+        return ""
+      else
+        @total = paths.length
+        return make_table_of_files(paths)
+      end
+    end
+
+    def do_make_navi(from)
+      make_markup_uri("", nil, :from => from)
+    end
+
+    def list_packages 
+      # FIXME: sorting every time is not efficient.
+      all = []
+      @dbm.each_package_name {|package_name|
+        all.push(package_name)
+      }
+      all.sort!
+
+      package_names = all[@from, @config.max_packages_per_page]
+      if package_names
+        @to = @from + package_names.length
+        @total = all.length
+        table = make_table_of_packages(package_names)
+        navi = make_navi(all.length, @from, @config.max_packages_per_page)
+        return [:div, table, navi]
+      else
+        return ""
+      end
+    end
+
+    def markup_source
+      content = @dbm.get_content(@path_id)
+      digest  = @dbm.get_digest(@path_id)
+      occurrences = if @search_query.string.empty?
+                      []
+                    else
+                      search_query = @search_query.clone
+                      search_query.path ||= @path
+                      searcher = Searcher.new(@dbm, search_query, 
+                                              @config.max_results_overall)
+                      result = searcher.search
+                      item = result.first
+                      if item and not item.list.empty? 
+                        item.list 
+                      else
+                        [] 
+                      end
+                    end
+      search_uri = make_search_uri_partial("")
+      beautifier = TextBeautifier.new(content, digest, occurrences, search_uri)
+      return beautifier.beautify
+    end
+
+    def make_isearch_form
+      isearch = [:div, {:class => "isearch"}]
+      form = [:form, {:method => "get", :action => "",
+        :onsubmit => "return false;"}]
+      p = [:p]
+      p.push(_("Search this content: "))
+      p.push([:input, {:type => "text", :name => "g", :size => "20",
+                 :onkeyup => "isearch(this.value);",
+                 :value => ""
+               }])
+      p.push(" ")
+      form.push(p)
+      isearch.push(form)
+      return isearch
+    end
+
+    def markup_file
+      path = @dbm.get_path(@path_id)
+
+      mime_type = get_mime_type(path)
+      media_type = get_media_type(path)
+      if media_type == "image"
+        img = [:img, {:src => make_source_uri(path),
+            :alt => path }]
+        content = [:div, {:class => "image"}, img]
+      elsif mime_type == "text/html"
+        iframe = [:iframe, {:src => make_source_uri(path),
+          :width => "100%", :height => "400"},
+          [:a, {:href => make_source_uri(path)}, path]
+        ]
+        content = iframe
+      else
+        content = [:div]
+        isearch = make_isearch_form
+        content.push(isearch)
+        code = markup_source
+        content.push([:pre, *code])
+      end
+      return content
+    end
+
+    def make_not_found
+      sprintf(_("No contents were found matching %s"), 
+              @path)
+    end
+
+    def gzip(string)
+      strio = StringIO.new
+      writer = Zlib::GzipWriter.new(strio)
+      writer.print(string)
+      writer.finish
+      return strio.string
+    end
+
+    def set_response(html)
+      set_content_type_text_html
+      body = format_html(html)
+      if @request.gzip_encoding_supported?
+        @response["Content-Encoding"] = "gzip"
+        @response.body = gzip(body)
+      else
+        @response.body = body
+      end
+    end
+
+    def choose_method
+      method = :make_not_found
+      if @path.empty?
+        method = :list_packages
+        title = make_title(_("List of Packages"))
+        status_title = _("List of Packages")
+      else
+        @path_id = @dbm.get_path_id(@path)
+        @package_name = @path.split("/").first
+        if @path_id 
+          method = :markup_file 
+        elsif @dbm.has_package?(@package_name)
+          method = :list_files 
+        end
+        title = make_title(@path)
+        status_title = make_breadcrumbs(@path)
+      end
+      return method, title, status_title
+    end
+
+    def do_GET(request, response)
+      init_servlet(request, response)
+      log(@path)
+
+      @path = make_path
+      @to = nil
+      @total = nil
+
+      method, title, status_title = choose_method
+
+      html = make_html
+      head = [:head, title, make_script, *make_meta_and_css]
+      body = [:body, {:onload => "initCache();",
+                      :onclick => "clearHighlight();" }]
+      body.push(make_h1)
+      body.push(make_search_form)
+      content = self.send(method)
+
+      status_line = make_status_line(status_title, method)
+      body.push(status_line)
+      body.push(content)
+      body.push(make_footer)
+
+      html.push(head)
+      html.push(body)
+      set_response(html)
+    end
+
+    GonzuiServlet.register(self)
+  end
+end