bitclust-core 1.3.0 → 1.6.0

data/theme/default/js/search_ranker.js

@@ -0,0 +1,244 @@
+/*
+ * Vendored from RDoc's Aliki theme (lib/rdoc/generator/template/aliki/js/), RDoc v7.2.0.
+ * Copyright (c) 2025 Stan Lo. Released under the MIT License.
+ * See https://github.com/ruby/rdoc/blob/v7.2.0/LEGAL.rdoc
+ */
+/**
+ * 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/theme/default/script.js

@@ -1,6 +1,92 @@
 (function() {
+  // クリップボードへのコピー。Clipboard API が使えない環境
+  // (非セキュアコンテキストや古いブラウザ)では従来の
+  // textarea + execCommand にフォールバックする
+  function writeClipboard(text) {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      return navigator.clipboard.writeText(text)
+    }
+    return new Promise(function(resolve, reject) {
+      const textarea = document.createElement('textarea')
+      textarea.setAttribute('class', 'highlight__copy-text')
+      textarea.value = text
+      document.body.appendChild(textarea)
+      textarea.select()
+      const ok = document.execCommand('copy')
+      document.body.removeChild(textarea)
+      if (ok) {
+        resolve()
+      } else {
+        reject(new Error('copy command failed'))
+      }
+    })
+  }
+
+  function hasClass(elem, name) {
+    return Boolean(elem && elem.className &&
+      String(elem.className).split(' ').indexOf(name) >= 0)
+  }
+
+  function findChildByClass(elem, name) {
+    const children = elem.children
+    for (let i = 0; i < children.length; i++) {
+      if (hasClass(children[i], name)) return children[i]
+    }
+    return null
+  }
+
+  // elem(pre)の直前にツールバー行 <div class="highlight__toolbar"> を
+  // 用意し、その右端のボタン置き場(highlight__button-group)を返す。
+  // ボタンを pre の中に float させる方式は、カーソル形状のちらつき・
+  // 編集時のレイアウト崩れ・pre の上 padding を 0 にする必要など無理が
+  // 多かったため、pre の外に出している。コンパイラが pre の直前に置く
+  // caption(タブ)があればツールバー左端に取り込み、pre への密着を保つ。
+  // js/run.js も同じボタン置き場に RUN ボタンを入れる
+  function buttonGroup(elem) {
+    const prev = elem.previousElementSibling
+    if (hasClass(prev, 'highlight__toolbar')) {
+      return findChildByClass(prev, 'highlight__button-group')
+    }
+    const toolbar = document.createElement('div')
+    toolbar.setAttribute('class', 'highlight__toolbar')
+    const group = document.createElement('span')
+    group.setAttribute('class', 'highlight__button-group')
+    if (hasClass(prev, 'caption')) {
+      elem.parentNode.insertBefore(toolbar, prev)
+      toolbar.appendChild(prev) // caption をタブとして左端へ移動
+    } else {
+      elem.parentNode.insertBefore(toolbar, elem)
+    }
+    toolbar.appendChild(group)
+    return group
+  }
+
+  // elem の直前のツールバーに COPY ボタンを付ける。getText はクリック時に
+  // 評価されるので、RUN の実行結果のように内容が変わる要素にも使える。
+  // elem は DOM ツリーに挿入済みであること(直前にツールバーを差し込む)
+  function addCopyButton(elem, getText) {
+    const btn = document.createElement('span')
+    btn.setAttribute('class', 'highlight__copy-button')
+    btn.onclick = function(){
+      writeClipboard(getText()).then(function() {
+        btn.classList.add("copied")
+        window.setTimeout(function() { btn.classList.remove("copied") }, 1000)
+      }).catch(function() {
+        // コピー失敗時は従来どおり何も表示しない
+      })
+    }
+    // COPY は常にグループ右端(RUN は run.js が先頭に prepend する)
+    buttonGroup(elem).appendChild(btn)
+    return btn
+  }
+
+  // RUN 出力(js/run.js)など、後から動的に生成される pre 用の公開フック
+  window.ruremaAddCopyButton = addCopyButton
+
   window.onload = function() {
-    const elems = document.getElementsByClassName('highlight')
+    // 言語指定なしのコードブロックは class を持たない素の <pre> になるため、
+    // highlight クラスではなく pre 要素全体に COPY ボタンを付ける
+    const elems = document.querySelectorAll('pre')
 
     let tempDiv = document.createElement('div')
 
@@ -11,23 +97,10 @@
         const caption = tempDiv.getElementsByClassName("caption")[0]
         if (caption) tempDiv.removeChild(caption)
 
-        // textarea for preserving the copy text
-        const copyText = document.createElement('textarea')
-        copyText.setAttribute('class', 'highlight__copy-text')
-        copyText.innerHTML = tempDiv.textContent.replace(/^\n+/, "").replace(/\n{2,}$/, "\n")
-        elem.appendChild(copyText)
-
-        // COPY button
-        const btn = document.createElement('span')
-        btn.setAttribute('class', 'highlight__copy-button')
-        elem.insertBefore(btn, elem.firstChild)
-
-        btn.onclick = function(){
-          copyText.select()
-          document.execCommand("copy")
-          btn.classList.add("copied")
-          window.setTimeout(function() { btn.classList.remove("copied") }, 1000)
-        }
+        // RUN ボタンでサンプルを編集しても COPY は元のテキストを保持する
+        const text = tempDiv.textContent.replace(/^\n+/, "").replace(/\n{2,}$/, "\n")
+
+        addCopyButton(elem, function() { return text })
       }
     )
   }

data/theme/default/search.css

@@ -0,0 +1,149 @@
+/* Client-side search box (statichtml output).
+   Styled to match rurema's theme (accent color #33a). */
+
+/* Full-width sticky top bar: manual-home link on the left, search on the right.
+   Negative margins break out of the body's 20px top / 2% side margins so the
+   bar spans the viewport; the matching padding keeps its content aligned with
+   the page body. */
+#rurema-topbar {
+  position: sticky;
+  top: 0;
+  z-index: 1000;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1em;
+  margin: -20px -2% 1em;
+  padding: 6px 2%;
+  background: #f7f7fb;
+  border-bottom: 2px solid #33a;
+}
+
+#rurema-brand {
+  font-size: 0.95em;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+#search-section {
+  position: relative;
+  flex: 0 0 auto;
+  width: 26em;
+  max-width: 50%;
+}
+
+#search-field {
+  width: 100%;
+  box-sizing: border-box;
+  padding: 0.35em 0.6em;
+  font-size: 0.95em;
+  border: 1px solid #99a;
+  border-radius: 4px;
+  background: #fff;
+}
+
+#search-field:focus {
+  outline: none;
+  border-color: #33a;
+  box-shadow: 0 0 0 2px rgba(51, 51, 170, 0.25);
+}
+
+.search-results {
+  list-style: none;
+  margin: 0.25em 0 0;
+  padding: 0;
+  position: absolute;
+  top: 100%;
+  left: 0;
+  right: 0;
+  background: #fff;
+  border: 1px solid #33a;
+  border-radius: 4px;
+  box-shadow: 0 6px 20px rgba(0, 0, 0, 0.18);
+  max-height: 75vh;
+  overflow-y: auto;
+  z-index: 1001;
+}
+
+.search-results[aria-expanded="false"] {
+  display: none;
+}
+
+.search-results li {
+  padding: 0.35em 0.6em;
+  border-bottom: 1px solid #eee;
+  cursor: pointer;
+  line-height: 1.25;
+}
+
+.search-results li:last-child {
+  border-bottom: none;
+}
+
+.search-results li.search-selected {
+  background: #e8eaf6; /* light tint of #33a */
+}
+
+.search-results .search-match {
+  margin: 0;
+  font-weight: normal;
+}
+
+.search-results em {
+  font-style: normal;
+  background: #ff9;
+  border-radius: 2px;
+}
+
+/* On hover the global `a:hover` rule paints the whole anchor with the #33a
+   accent and white text. Round the anchor (and pad it slightly) so its
+   background follows the rounded highlight instead of poking square corners
+   out behind it, and recolor the highlighted match so the yellow background
+   stays legible against the white-on-blue hover text. */
+.search-results .search-match > a {
+  padding: 1px;
+  border-radius: 3px;
+}
+
+.search-results .search-match > a:hover > em {
+  color: #33a;
+}
+
+.search-type {
+  display: inline-block;
+  margin-left: 0.5em;
+  padding: 0 0.4em;
+  font-size: 0.75em;
+  color: #fff;
+  background: #33a;
+  border-radius: 3px;
+  vertical-align: middle;
+}
+
+.search-snippet {
+  color: #555;
+  font-size: 0.85em;
+  margin-top: 0.15em;
+}
+
+@media only screen and (max-width: 768px) {
+  #rurema-topbar {
+    flex-wrap: wrap;
+    gap: 0.4em;
+  }
+  #search-section {
+    width: 100%;
+    max-width: none;
+  }
+}
+
+html {
+  scroll-padding-top: 3.5rem;
+}
+
+@media only screen and (max-width: 768px) {
+  html {
+    scroll-padding-top: 6rem;
+  }
+}