rdoc 6.16.1 → 7.0.0

data/lib/rdoc/generator/template/aliki/js/search_navigation.js

@@ -0,0 +1,105 @@
+/*
+ * SearchNavigation allows movement using the arrow keys through the search results.
+ *
+ * When using this library you will need to set scrollIntoView to the
+ * appropriate function for your layout.  Use scrollInWindow if the container
+ * is not scrollable and scrollInElement if the container is a separate
+ * scrolling region.
+ */
+SearchNavigation = new function() {
+  this.initNavigation = function() {
+    var _this = this;
+
+    document.addEventListener('keydown', function(e) {
+      _this.onkeydown(e);
+    });
+
+    this.navigationActive = true;
+  }
+
+  this.setNavigationActive = function(state) {
+    this.navigationActive = state;
+  }
+
+  this.onkeydown = function(e) {
+    if (!this.navigationActive) return;
+    switch(e.key) {
+      case 'ArrowLeft':
+        if (this.moveLeft()) e.preventDefault();
+        break;
+      case 'ArrowUp':
+        if (e.key == 'ArrowUp' || e.ctrlKey) {
+          if (this.moveUp()) e.preventDefault();
+        }
+        break;
+      case 'ArrowRight':
+        if (this.moveRight()) e.preventDefault();
+        break;
+      case 'ArrowDown':
+        if (e.key == 'ArrowDown' || e.ctrlKey) {
+          if (this.moveDown()) e.preventDefault();
+        }
+        break;
+      case 'Enter':
+        if (this.current) e.preventDefault();
+        this.select(this.current);
+        break;
+    }
+    if (e.ctrlKey && e.shiftKey) this.select(this.current);
+  }
+
+  this.moveRight = function() {
+  }
+
+  this.moveLeft = function() {
+  }
+
+  this.move = function(isDown) {
+  }
+
+  this.moveUp = function() {
+    return this.move(false);
+  }
+
+  this.moveDown = function() {
+    return this.move(true);
+  }
+
+  /*
+   * Scrolls to the given element in the scrollable element view.
+   */
+  this.scrollInElement = function(element, view) {
+    var offset, viewHeight, viewScroll, height;
+    offset = element.offsetTop;
+    height = element.offsetHeight;
+    viewHeight = view.offsetHeight;
+    viewScroll = view.scrollTop;
+
+    if (offset - viewScroll + height > viewHeight) {
+      view.scrollTop = offset - viewHeight + height;
+    }
+    if (offset < viewScroll) {
+      view.scrollTop = offset;
+    }
+  }
+
+  /*
+   * Scrolls to the given element in the window.  The second argument is
+   * ignored
+   */
+  this.scrollInWindow = function(element, ignored) {
+    var offset, viewHeight, viewScroll, height;
+    offset = element.offsetTop;
+    height = element.offsetHeight;
+    viewHeight = window.innerHeight;
+    viewScroll = window.scrollY;
+
+    if (offset - viewScroll + height > viewHeight) {
+      window.scrollTo(window.scrollX, offset - viewHeight + height);
+    }
+    if (offset < viewScroll) {
+      window.scrollTo(window.scrollX, offset);
+    }
+  }
+}
+

data/lib/rdoc/generator/template/aliki/js/search_ranker.js

@@ -0,0 +1,239 @@
+/**
+ * Aliki Search Implementation
+ *
+ * Search algorithm with the following priorities:
+ * 1. Exact full_name match always wins (for namespace/method queries)
+ * 2. Exact name match gets high priority
+ * 3. Match types:
+ *    - Namespace queries (::) and method queries (# or .) match against full_name
+ *    - Regular queries match against unqualified name
+ *    - Prefix (10000) > substring (5000) > fuzzy (1000)
+ * 4. First character determines type priority:
+ *    - Starts with lowercase: methods first
+ *    - Starts with uppercase: classes/modules/constants first
+ * 5. Within same type priority:
+ *    - Unqualified match > qualified match
+ *    - Shorter name > longer name
+ * 6. Class methods > instance methods
+ * 7. Result limit: 30
+ * 8. Minimum query length: 1 character
+ */
+
+var MAX_RESULTS = 30;
+var MIN_QUERY_LENGTH = 1;
+
+/*
+ * Scoring constants - organized in tiers where each tier dominates lower tiers.
+ * This ensures match type always beats type priority, etc.
+ *
+ * Tier 0: Exact matches (immediate return)
+ * Tier 1: Match type (prefix > substring > fuzzy)
+ * Tier 2: Exact name bonus
+ * Tier 3: Type priority (method vs class based on query case)
+ * Tier 4: Minor bonuses (top-level, class method, name length)
+ */
+var SCORE_EXACT_FULL_NAME = 1000000;  // Tier 0: Query exactly matches full_name
+var SCORE_MATCH_PREFIX    = 10000;    // Tier 1: Query is prefix of name
+var SCORE_MATCH_SUBSTRING = 5000;     // Tier 1: Query is substring of name
+var SCORE_MATCH_FUZZY     = 1000;     // Tier 1: Query chars appear in order
+var SCORE_EXACT_NAME      = 500;      // Tier 2: Name exactly equals query
+var SCORE_TYPE_PRIORITY   = 100;      // Tier 3: Preferred type (method/class)
+var SCORE_TOP_LEVEL       = 50;       // Tier 4: Top-level over namespaced
+var SCORE_CLASS_METHOD    = 10;       // Tier 4: Class method over instance method
+
+/**
+ * Check if all characters in query appear in order in target
+ * e.g., "addalias" fuzzy matches "add_foo_alias"
+ */
+function fuzzyMatch(target, query) {
+  var ti = 0;
+  for (var qi = 0; qi < query.length; qi++) {
+    ti = target.indexOf(query[qi], ti);
+    if (ti === -1) return false;
+    ti++;
+  }
+  return true;
+}
+
+/**
+ * Parse and normalize a search query
+ * @param {string} query - The raw search query
+ * @returns {Object} Parsed query with normalized form and flags
+ */
+function parseQuery(query) {
+  // Lowercase for case-insensitive matching (so "hash" finds both Hash class and #hash methods)
+  var normalized = query.toLowerCase();
+  var isNamespaceQuery = query.includes('::');
+  var isMethodQuery = query.includes('#') || query.includes('.');
+
+  // Normalize . to :: (RDoc uses :: for class methods in full_name)
+  if (query.includes('.')) {
+    normalized = normalized.replace(/\./g, '::');
+  }
+
+  return {
+    original: query,
+    normalized: normalized,
+    isNamespaceQuery: isNamespaceQuery,
+    isMethodQuery: isMethodQuery,
+    // Namespace and method queries match against full_name instead of name
+    matchesFullName: isNamespaceQuery || isMethodQuery,
+    // If query starts with lowercase, prioritize methods; otherwise prioritize classes/modules/constants
+    prioritizeMethod: !/^[A-Z]/.test(query)
+  };
+}
+
+/**
+ * Main search function
+ * @param {string} query - The search query
+ * @param {Array} index - The search index to search in
+ * @returns {Array} Array of matching entries, sorted by relevance
+ */
+function search(query, index) {
+  if (!query || query.length < MIN_QUERY_LENGTH) {
+    return [];
+  }
+
+  var q = parseQuery(query);
+  var results = [];
+
+  for (var i = 0; i < index.length; i++) {
+    var entry = index[i];
+    var score = computeScore(entry, q);
+
+    if (score !== null) {
+      results.push({ entry: entry, score: score });
+    }
+  }
+
+  results.sort(function(a, b) {
+    return b.score - a.score;
+  });
+
+  return results.slice(0, MAX_RESULTS).map(function(r) {
+    return r.entry;
+  });
+}
+
+/**
+ * Compute the relevance score for an entry
+ * @param {Object} entry - The search index entry
+ * @param {Object} q - Parsed query from parseQuery()
+ * @returns {number|null} Score or null if no match
+ */
+function computeScore(entry, q) {
+  var name = entry.name;
+  var fullName = entry.full_name;
+  var type = entry.type;
+
+  var nameLower = name.toLowerCase();
+  var fullNameLower = fullName.toLowerCase();
+
+  // Exact full_name match (e.g., "Array#filter" matches Array#filter)
+  if (q.matchesFullName && fullNameLower === q.normalized) {
+    return SCORE_EXACT_FULL_NAME;
+  }
+
+  var matchScore = 0;
+  var target = q.matchesFullName ? fullNameLower : nameLower;
+
+  if (target.startsWith(q.normalized)) {
+    matchScore = SCORE_MATCH_PREFIX;     // Prefix (e.g., "Arr" matches "Array")
+  } else if (target.includes(q.normalized)) {
+    matchScore = SCORE_MATCH_SUBSTRING;  // Substring (e.g., "ray" matches "Array")
+  } else if (fuzzyMatch(target, q.normalized)) {
+    matchScore = SCORE_MATCH_FUZZY;      // Fuzzy (e.g., "addalias" matches "add_foo_alias")
+  } else {
+    return null;
+  }
+
+  var score = matchScore;
+  var isMethod = (type === 'instance_method' || type === 'class_method');
+
+  if (q.prioritizeMethod ? isMethod : !isMethod) {
+    score += SCORE_TYPE_PRIORITY;
+  }
+
+  if (type === 'class_method') score += SCORE_CLASS_METHOD;
+  if (name === fullName) score += SCORE_TOP_LEVEL;  // Top-level (Hash) > namespaced (Foo::Hash)
+  if (nameLower === q.normalized) score += SCORE_EXACT_NAME;  // Exact name match
+  score -= name.length;
+
+  return score;
+}
+
+/**
+ * SearchRanker class for compatibility with the Search UI
+ * Provides ready() and find() interface
+ */
+function SearchRanker(index) {
+  this.index = index;
+  this.handlers = [];
+}
+
+SearchRanker.prototype.ready = function(fn) {
+  this.handlers.push(fn);
+};
+
+SearchRanker.prototype.find = function(query) {
+  var q = parseQuery(query);
+  var rawResults = search(query, this.index);
+  var results = rawResults.map(function(entry) {
+    return formatResult(entry, q);
+  });
+
+  var _this = this;
+  this.handlers.forEach(function(fn) {
+    fn.call(_this, results, true);
+  });
+};
+
+/**
+ * Format a search result entry for display
+ */
+function formatResult(entry, q) {
+  var result = {
+    title: highlightMatch(entry.full_name, q),
+    path: entry.path,
+    type: entry.type
+  };
+
+  if (entry.snippet) {
+    result.snippet = entry.snippet;
+  }
+
+  return result;
+}
+
+/**
+ * Add highlight markers (\u0001 and \u0002) to matching portions of text
+ * @param {string} text - The text to highlight
+ * @param {Object} q - Parsed query from parseQuery()
+ */
+function highlightMatch(text, q) {
+  if (!text || !q) return text;
+
+  var textLower = text.toLowerCase();
+  var query = q.normalized;
+
+  // Try contiguous match first (prefix or substring)
+  var matchIndex = textLower.indexOf(query);
+  if (matchIndex !== -1) {
+    return text.substring(0, matchIndex) +
+      '\u0001' + text.substring(matchIndex, matchIndex + query.length) + '\u0002' +
+      text.substring(matchIndex + query.length);
+  }
+
+  // Fall back to fuzzy highlight (highlight each matched character)
+  var result = '';
+  var ti = 0;
+  for (var qi = 0; qi < query.length; qi++) {
+    var charIndex = textLower.indexOf(query[qi], ti);
+    if (charIndex === -1) return text;
+    result += text.substring(ti, charIndex);
+    result += '\u0001' + text[charIndex] + '\u0002';
+    ti = charIndex + 1;
+  }
+  result += text.substring(ti);
+  return result;
+}

data/lib/rdoc/generator/template/aliki/page.rhtml

@@ -1,4 +1,5 @@
 <body role="document" class="file has-toc">
+<%= render '_icons.rhtml' %>
 <%= render '_header.rhtml' %>
 <%= render '_sidebar_toggle.rhtml' %>
 

data/lib/rdoc/generator/template/darkfish/class.rhtml

@@ -163,15 +163,13 @@
               <summary>Source</summary>
             </details>
           </div>
+          <div class="method-source-code" id="<%= method.html_name %>-source">
+            <pre><%= method.markup_code %></pre>
+          </div>
         <%- end %>
 
         <%- unless method.skip_description? then %>
         <div class="method-description">
-          <%- if method.token_stream then %>
-          <div class="method-source-code" id="<%= method.html_name %>-source">
-            <pre><%= method.markup_code %></pre>
-          </div>
-          <%- end %>
           <%- if method.mixin_from then %>
             <div class="mixin-from">
               <%= method.singleton ? "Extended" : "Included" %> from <a href="<%= klass.aref_to(method.mixin_from.path) %>"><%= method.mixin_from.full_name %></a>

data/lib/rdoc/markup/to_ansi.rb

@@ -81,6 +81,10 @@ class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
     end
   end
 
+  def calculate_text_width(text)
+    text.gsub(/\e\[[\d;]*m/, '').size
+  end
+
   ##
   # Starts accepting with a reset screen
 

data/lib/rdoc/markup/to_bs.rb

@@ -65,6 +65,10 @@ class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
     end
   end
 
+  def calculate_text_width(text)
+    text.gsub(/_\x08/, '').gsub(/\x08./, '').size
+  end
+
   ##
   # Turns on or off regexp handling for +convert_string+
 

data/lib/rdoc/markup/to_rdoc.rb

@@ -250,8 +250,10 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
   # Adds +table+ to the output
 
   def accept_table(header, body, aligns)
+    header = header.map { |h| attributes h }
+    body = body.map { |row| row.map { |t| attributes t } }
     widths = header.zip(*body).map do |cols|
-      cols.map(&:size).max
+      cols.map { |col| calculate_text_width(col) }.max
     end
     aligns = aligns.map do |a|
       case a
@@ -264,16 +266,22 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
       end
     end
     @res << header.zip(widths, aligns).map do |h, w, a|
-      h.__send__(a, w)
+      extra_width = h.size - calculate_text_width(h)
+      h.__send__(a, w + extra_width)
     end.join("|").rstrip << "\n"
     @res << widths.map {|w| "-" * w }.join("|") << "\n"
     body.each do |row|
       @res << row.zip(widths, aligns).map do |t, w, a|
-        t.__send__(a, w)
+        extra_width = t.size - calculate_text_width(t)
+        t.__send__(a, w + extra_width)
       end.join("|").rstrip << "\n"
     end
   end
 
+  def calculate_text_width(text)
+    text.size
+  end
+
   ##
   # Applies attribute-specific markup to +text+ using RDoc::AttributeManager
 

data/lib/rdoc/options.rb

@@ -411,7 +411,7 @@ class RDoc::Options
     @files = nil
     @force_output = false
     @force_update = true
-    @generator_name = "darkfish"
+    @generator_name = "aliki"
     @generators = RDoc::RDoc::GENERATORS
     @generator_options = []
     @hyperlink_all = false

data/lib/rdoc/rubygems_hook.rb

@@ -118,7 +118,7 @@ class RDoc::RubyGemsHook
   end
 
   ##
-  # Generates documentation using the named +generator+ ("darkfish" or "ri")
+  # Generates documentation using the named +generator+ ("aliki" or "ri")
   # and following the given +options+.
   #
   # Documentation will be generated into +destination+
@@ -190,7 +190,7 @@ class RDoc::RubyGemsHook
 
     Dir.chdir @spec.full_gem_path do
       # RDoc::Options#finish must be called before parse_files.
-      # RDoc::Options#finish is also called after ri/darkfish generator setup.
+      # RDoc::Options#finish is also called after ri/aliki generator setup.
       # We need to dup the options to avoid modifying it after finish is called.
       parse_options = options.dup
       parse_options.finish
@@ -202,7 +202,7 @@ class RDoc::RubyGemsHook
     document 'ri',       options, @ri_dir if
       @generate_ri   and (@force or not File.exist? @ri_dir)
 
-    document 'darkfish', options, @rdoc_dir if
+    document 'aliki', options, @rdoc_dir if
       @generate_rdoc and (@force or not File.exist? @rdoc_dir)
   end
 

data/lib/rdoc/version.rb

@@ -5,6 +5,6 @@ module RDoc
   ##
   # RDoc version you are using
 
-  VERSION = '6.16.1'
+  VERSION = '7.0.0'
 
 end

data/rdoc.gemspec

@@ -38,7 +38,7 @@ RDoc includes the +rdoc+ and +ri+ tools for generating and displaying documentat
   # for ruby core repository. It was generated by
   # `git ls-files -z`.split("\x0").each {|f| puts "    #{f.dump}," unless f.start_with?(*%W[test/ spec/ features/ .]) }
   non_lib_files = [
-    "CONTRIBUTING.rdoc",
+    "CONTRIBUTING.md",
     "CVE-2013-0256.rdoc",
     "ExampleMarkdown.md",
     "ExampleRDoc.rdoc",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdoc
 version: !ruby/object:Gem::Version
-  version: 6.16.1
+  version: 7.0.0
 platform: ruby
 authors:
 - Eric Hodel
@@ -13,7 +13,7 @@ authors:
 - ITOYANAGI Sakura
 bindir: exe
 cert_chain: []
-date: 2025-11-28 00:00:00.000000000 Z
+date: 2025-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: psych
@@ -73,7 +73,7 @@ executables:
 - ri
 extensions: []
 extra_rdoc_files:
-- CONTRIBUTING.rdoc
+- CONTRIBUTING.md
 - CVE-2013-0256.rdoc
 - ExampleMarkdown.md
 - ExampleRDoc.rdoc
@@ -84,7 +84,7 @@ extra_rdoc_files:
 - RI.md
 - TODO.rdoc
 files:
-- CONTRIBUTING.rdoc
+- CONTRIBUTING.md
 - CVE-2013-0256.rdoc
 - ExampleMarkdown.md
 - ExampleRDoc.rdoc
@@ -137,6 +137,7 @@ files:
 - lib/rdoc/generator/template/aliki/_footer.rhtml
 - lib/rdoc/generator/template/aliki/_head.rhtml
 - lib/rdoc/generator/template/aliki/_header.rhtml
+- lib/rdoc/generator/template/aliki/_icons.rhtml
 - lib/rdoc/generator/template/aliki/_sidebar_ancestors.rhtml
 - lib/rdoc/generator/template/aliki/_sidebar_classes.rhtml
 - lib/rdoc/generator/template/aliki/_sidebar_extends.rhtml
@@ -152,7 +153,9 @@ files:
 - lib/rdoc/generator/template/aliki/index.rhtml
 - lib/rdoc/generator/template/aliki/js/aliki.js
 - lib/rdoc/generator/template/aliki/js/c_highlighter.js
-- lib/rdoc/generator/template/aliki/js/search.js
+- lib/rdoc/generator/template/aliki/js/search_controller.js
+- lib/rdoc/generator/template/aliki/js/search_navigation.js
+- lib/rdoc/generator/template/aliki/js/search_ranker.js
 - lib/rdoc/generator/template/aliki/js/theme-toggle.js
 - lib/rdoc/generator/template/aliki/page.rhtml
 - lib/rdoc/generator/template/aliki/servlet_not_found.rhtml
@@ -321,7 +324,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '2.2'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: RDoc produces HTML and command-line documentation for Ruby projects
 test_files: []