RubyGems - ruby-test-ide - Versions diffs - 0.1.0 - Mend

ruby-test-ide 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (118) hide show

data/lib/ruby_test_ide/public/index.html ADDED Viewed

@@ -0,0 +1,611 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Ruby IDE — runtime reflection PoC</title>
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<style>
+  :root {
+    --bg: #1e1e1e; --panel: #252526; --border: #333; --fg: #d4d4d4;
+    --dim: #858585; --accent: #4ec9b0; --err: #f48771;
+  }
+  * { box-sizing: border-box; }
+  html, body { height: 100%; margin: 0; }
+  body {
+    display: flex; flex-direction: column; background: var(--bg); color: var(--fg);
+    font: 13px/1.5 -apple-system, "Segoe UI", sans-serif;
+  }
+  header {
+    display: flex; align-items: center; gap: 12px; padding: 8px 14px;
+    background: var(--panel); border-bottom: 1px solid var(--border);
+  }
+  header h1 { font-size: 14px; margin: 0; font-weight: 600; }
+  header h1 span { color: var(--accent); }
+  #current-file { font: 12px ui-monospace, Menlo, monospace; color: var(--dim); }
+  #current-file.dirty::after { content: ' ●'; color: #e2c08d; }
+  header .spacer { flex: 1; }
+  button, label.toggle {
+    background: #0e639c; border: none; color: #fff; padding: 5px 14px;
+    border-radius: 3px; font-size: 12px; cursor: pointer;
+  }
+  button:hover { background: #1177bb; }
+  button.ghost { background: #3a3d41; }
+  button.ghost:hover { background: #45484d; }
+  label.toggle { background: transparent; color: var(--fg); display: flex; align-items: center; gap: 6px; }
+  #status { font-size: 12px; color: var(--dim); min-width: 150px; text-align: right; }
+  main { display: flex; flex: 1; min-height: 0; }
+  nav {
+    width: 200px; min-width: 120px; max-width: 70vw; flex: none;
+    background: var(--panel); display: flex; flex-direction: column; overflow: hidden;
+  }
+  #nav-resizer {
+    width: 4px; flex: none; cursor: col-resize; background: var(--border);
+  }
+  #nav-resizer:hover, #nav-resizer.dragging { background: #007acc; }
+  nav .nav-head {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 10px 12px 4px;
+  }
+  nav h2 {
+    font-size: 11px; text-transform: uppercase; letter-spacing: .08em;
+    color: var(--dim); margin: 0;
+  }
+  #new-file {
+    background: transparent; color: var(--dim); padding: 0 4px; font-size: 16px; line-height: 1;
+  }
+  #new-file:hover { color: var(--fg); background: transparent; }
+  #files { overflow: auto; flex: 1; padding: 4px 0; }
+  #files .file, #files .dir {
+    padding: 3px 10px; cursor: pointer; font: 12px ui-monospace, Menlo, monospace;
+    white-space: nowrap; overflow: hidden; text-overflow: ellipsis; color: var(--fg);
+  }
+  #files .file:hover, #files .dir:hover { background: #2a2d2e; }
+  #files .file.active { background: #37373d; color: #fff; }
+  #files .file.dirty::after { content: ' ●'; color: #e2c08d; }
+  #files .dir { color: var(--dim); user-select: none; }
+  #files .dir .chevron { display: inline-block; width: 1em; }
+  #editor { flex: 1; min-width: 0; }
+  aside {
+    width: 330px; background: var(--panel); border-left: 1px solid var(--border);
+    display: flex; flex-direction: column; overflow-y: auto;
+  }
+  aside h2 {
+    font-size: 11px; text-transform: uppercase; letter-spacing: .08em;
+    color: var(--dim); margin: 0; padding: 10px 12px 4px;
+  }
+  aside section { border-bottom: 1px solid var(--border); padding-bottom: 8px; }
+  table { width: 100%; border-collapse: collapse; font: 12px ui-monospace, Menlo, monospace; }
+  td { padding: 2px 12px; vertical-align: top; }
+  td.var { color: #9cdcfe; white-space: nowrap; }
+  td.klass { color: var(--accent); white-space: nowrap; }
+  td.val { color: #ce9178; word-break: break-all; }
+  pre {
+    margin: 4px 12px; padding: 8px; background: #1a1a1a; border-radius: 4px;
+    font: 12px ui-monospace, Menlo, monospace; white-space: pre-wrap; word-break: break-word;
+  }
+  #run-error { color: var(--err); }
+  .empty { color: var(--dim); padding: 2px 12px; font-style: italic; }
+  .inline-state { color: #6a7a6a !important; font-style: italic; opacity: .9; }
+</style>
+</head>
+<body>
+<header>
+  <h1>Ruby<span>IDE</span></h1>
+  <div id="current-file"></div>
+  <div class="spacer"></div>
+  <label class="toggle"><input type="checkbox" id="live" checked> Live eval</label>
+  <button id="save" class="ghost" title="Cmd/Ctrl+S">Save</button>
+  <button id="learn" class="ghost" title="Run the workspace tests and learn argument/return types from what they execute">Learn from tests</button>
+  <button id="run">Run &#9654;</button>
+  <div id="status">starting&hellip;</div>
+</header>
+<main>
+  <nav>
+    <div class="nav-head">
+      <h2>Workspace</h2>
+      <button id="new-file" title="New file">＋</button>
+    </div>
+    <div id="files"></div>
+  </nav>
+  <div id="nav-resizer" title="Drag to resize"></div>
+  <div id="editor"></div>
+  <aside>
+    <section>
+      <h2>Runtime state</h2>
+      <table id="state"></table>
+      <div class="empty" id="state-empty">run the buffer to inspect live objects</div>
+    </section>
+    <section>
+      <h2>Output</h2>
+      <pre id="stdout"></pre>
+    </section>
+    <section>
+      <h2>Runtime error</h2>
+      <pre id="run-error"></pre>
+    </section>
+    <section>
+      <h2>Tests</h2>
+      <div class="empty" id="tests-empty">"Learn from tests" runs the suite and records real argument/return types</div>
+      <pre id="tests-out" style="display:none"></pre>
+    </section>
+  </aside>
+</main>
+<!-- Monaco is vendored (lib/ruby_test_ide/public/vendor/monaco) so the IDE
+     works with no internet access beyond the initial `gem install`. The
+     ?v= query cache-busts across gem upgrades (server.rb templates it in;
+     serve_static caches these files for a year since the URL is versioned). -->
+<script src="/vendor/monaco/vs/loader.js?v=__RTI_VERSION__"></script>
+<script>
+// Absolute (not root-relative): a worker built from a blob: URL resolves
+// importScripts() against the blob's own opaque origin, not the page's.
+const MONACO_BASE = new URL('/vendor/monaco', window.location.origin).href;
+const MONACO_QS = '?v=__RTI_VERSION__';
+require.config({ paths: { vs: MONACO_BASE + '/vs' }, urlArgs: 'v=__RTI_VERSION__' });
+window.MonacoEnvironment = {
+  getWorkerUrl: () => URL.createObjectURL(new Blob([
+    `self.MonacoEnvironment={baseUrl:'${MONACO_BASE}/'};` +
+    `importScripts('${MONACO_BASE}/vs/base/worker/workerMain.js${MONACO_QS}');`
+  ], { type: 'text/javascript' }))
+};
+// The server verified this page's ?token=... before serving it, and
+// embedded that same token here so every subsequent API call can carry it
+// as a header — the browser never needs to re-read it from the URL.
+const RTI_TOKEN = '__RTI_TOKEN__';
+const AUTH_HEADERS = RTI_TOKEN ? { 'X-Ruby-Test-Ide-Token': RTI_TOKEN } : {};
+const $ = id => document.getElementById(id);
+const post = async (path, body) => {
+  const res = await fetch(path, { method: 'POST', headers: AUTH_HEADERS, body: JSON.stringify(body) });
+  return res.json();
+};
+const get = async (path) => (await fetch(path, { headers: AUTH_HEADERS })).json();
+const debounce = (fn, ms) => { let t; return (...a) => { clearTimeout(t); t = setTimeout(() => fn(...a), ms); }; };
+const esc = s => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;');
+require(['vs/editor/editor.main'], () => {
+  const editor = monaco.editor.create($('editor'), {
+    language: 'ruby',
+    theme: 'vs-dark',
+    ariaLabel: 'Document',
+    fontSize: 13,
+    minimap: { enabled: false },
+    automaticLayout: true,
+    suggest: { showWords: false },   // only OUR runtime results, no text-buffer noise
+    quickSuggestions: { other: true, comments: false, strings: false },
+    fixedOverflowWidgets: true,
+  });
+  window.__editor = editor; // handy for tests / console poking
+  // Ruby words may end in ? or ! (start_with?, save!) and start with @/$ —
+  // Monaco's default pattern would hand the server "start_with" and the
+  // lookup would miss. (Replaces the stock language config; comments and
+  // brackets are re-declared so nothing is lost.)
+  monaco.languages.setLanguageConfiguration('ruby', {
+    comments: { lineComment: '#', blockComment: ['=begin', '=end'] },
+    brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+    autoClosingPairs: [
+      { open: '{', close: '}' }, { open: '[', close: ']' }, { open: '(', close: ')' },
+      { open: '"', close: '"' }, { open: "'", close: "'" },
+    ],
+    wordPattern: /(@@?|\$)?[A-Za-z_][A-Za-z0-9_]*[?!]?/g,
+  });
+  // Explicit user actions (save, create) set a sticky status that background
+  // updates (live eval chatter) may not overwrite for a few seconds.
+  let statusLockedUntil = 0;
+  const setStatus = (t, { sticky = false } = {}) => {
+    const now = Date.now();
+    if (!sticky && now < statusLockedUntil) return;
+    if (sticky) statusLockedUntil = now + 3000;
+    $('status').textContent = t;
+  };
+  // -------------------------------------------------------------- workspace
+  // One Monaco model per file; unsaved edits survive switching files.
+  const buffers = new Map();  // path -> { model, savedVersion }
+  let currentPath = null;
+  let fileList = [];
+  const isDirty = path => {
+    const b = buffers.get(path);
+    return b && b.model.getAlternativeVersionId() !== b.savedVersion;
+  };
+  // Directory collapse state persists across reloads; a dir is expanded
+  // unless its full path (e.g. "lib/models") is in this set.
+  const collapsedDirs = new Set(JSON.parse(localStorage.getItem('rti:collapsedDirs') || '[]'));
+  const persistCollapsedDirs = () =>
+    localStorage.setItem('rti:collapsedDirs', JSON.stringify([...collapsedDirs]));
+  // fileList (flat, "lib/greeter.rb") -> { dirs: Map<name, node>, files: [...] }
+  const buildFileTree = (files) => {
+    const root = { dirs: new Map(), files: [] };
+    for (const f of files) {
+      const parts = f.path.split('/');
+      let node = root;
+      let prefix = '';
+      for (let i = 0; i < parts.length - 1; i++) {
+        prefix = prefix ? `${prefix}/${parts[i]}` : parts[i];
+        if (!node.dirs.has(parts[i])) node.dirs.set(parts[i], { dirs: new Map(), files: [], fullPath: prefix });
+        node = node.dirs.get(parts[i]);
+      }
+      node.files.push(f);
+    }
+    return root;
+  };
+  const renderTreeNode = (node, depth, container) => {
+    const indent = 10 + depth * 14;
+    for (const name of [...node.dirs.keys()].sort((a, b) => a.localeCompare(b))) {
+      const child = node.dirs.get(name);
+      const collapsed = collapsedDirs.has(child.fullPath);
+      const row = document.createElement('div');
+      row.className = 'dir';
+      row.style.paddingLeft = indent + 'px';
+      row.innerHTML = `<span class="chevron">${collapsed ? '▸' : '▾'}</span>${esc(name)}`;
+      row.title = child.fullPath;
+      row.addEventListener('click', () => {
+        collapsedDirs.has(child.fullPath) ? collapsedDirs.delete(child.fullPath) : collapsedDirs.add(child.fullPath);
+        persistCollapsedDirs();
+        renderFileList();
+      });
+      container.appendChild(row);
+      if (!collapsed) renderTreeNode(child, depth + 1, container);
+    }
+    for (const f of [...node.files].sort((a, b) => a.path.localeCompare(b.path))) {
+      const el = document.createElement('div');
+      el.className = 'file' + (f.path === currentPath ? ' active' : '') +
+                     (isDirty(f.path) ? ' dirty' : '');
+      el.style.paddingLeft = (indent + 14) + 'px';
+      el.textContent = f.path.split('/').pop();
+      el.title = f.path;
+      el.addEventListener('click', () => openFile(f.path));
+      container.appendChild(el);
+    }
+  };
+  const renderFileList = () => {
+    $('files').innerHTML = '';
+    renderTreeNode(buildFileTree(fileList), 0, $('files'));
+    const cf = $('current-file');
+    cf.textContent = currentPath || '';
+    cf.classList.toggle('dirty', !!(currentPath && isDirty(currentPath)));
+  };
+  // ------------------------------------------------------ resizable sidebar
+  (() => {
+    const nav = document.querySelector('nav');
+    const resizer = $('nav-resizer');
+    const saved = parseInt(localStorage.getItem('rti:navWidth'), 10);
+    if (saved) nav.style.width = saved + 'px';
+    let startX = 0, startWidth = 0;
+    const onMove = (e) => {
+      const dx = e.clientX - startX;
+      const min = parseInt(getComputedStyle(nav).minWidth, 10);
+      const max = window.innerWidth * 0.7;
+      nav.style.width = Math.max(min, Math.min(max, startWidth + dx)) + 'px';
+    };
+    const onUp = () => {
+      resizer.classList.remove('dragging');
+      document.removeEventListener('mousemove', onMove);
+      document.removeEventListener('mouseup', onUp);
+      localStorage.setItem('rti:navWidth', parseInt(nav.style.width, 10));
+      if (window.__editor) window.__editor.layout();
+    };
+    resizer.addEventListener('mousedown', (e) => {
+      startX = e.clientX;
+      startWidth = nav.getBoundingClientRect().width;
+      resizer.classList.add('dragging');
+      document.addEventListener('mousemove', onMove);
+      document.addEventListener('mouseup', onUp);
+      e.preventDefault();
+    });
+  })();
+  const refreshFiles = async () => {
+    fileList = (await get('/api/files')).files || [];
+    renderFileList();
+  };
+  const ensureBuffer = async (path) => {
+    if (!buffers.has(path)) {
+      const data = await get('/api/file?path=' + encodeURIComponent(path));
+      const model = monaco.editor.createModel(data.content, 'ruby',
+        monaco.Uri.from({ scheme: 'ruby-ide', path: '/' + path }));
+      buffers.set(path, { model, savedVersion: model.getAlternativeVersionId() });
+    }
+    return buffers.get(path);
+  };
+  const openFile = async (path) => {
+    await ensureBuffer(path);
+    currentPath = path;
+    editor.setModel(buffers.get(path).model);
+    decorations = [];               // decoration ids belong to the old model
+    runtimeMarker = [];
+    renderFileList();
+    editor.focus();
+    refreshDiagnostics();
+    if ($('live').checked) runBuffer();
+  };
+  const saveFile = async () => {
+    if (!currentPath) return;
+    const b = buffers.get(currentPath);
+    const res = await post('/api/file', { path: currentPath, content: b.model.getValue() });
+    if (res.ok) {
+      b.savedVersion = b.model.getAlternativeVersionId();
+      setStatus('saved ' + res.path, { sticky: true });
+      await refreshFiles();
+    } else {
+      setStatus('save failed: ' + (res.error || 'unknown'), { sticky: true });
+    }
+  };
+  const newFile = async () => {
+    const name = prompt('New file path (relative to workspace):', 'untitled.rb');
+    if (!name) return;
+    const res = await post('/api/file', { path: name, content: '' });
+    if (res.error) { setStatus('create failed: ' + res.error); return; }
+    await refreshFiles();
+    openFile(name);
+  };
+  $('save').addEventListener('click', saveFile);
+  $('new-file').addEventListener('click', newFile);
+  editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS, saveFile);
+  window.addEventListener('keydown', e => {
+    if ((e.metaKey || e.ctrlKey) && e.key === 's') { e.preventDefault(); saveFile(); }
+  });
+  const KINDS = {
+    method:   monaco.languages.CompletionItemKind.Method,
+    variable: monaco.languages.CompletionItemKind.Variable,
+    constant: monaco.languages.CompletionItemKind.Class,
+    keyword:  monaco.languages.CompletionItemKind.Keyword,
+  };
+  // ---------------------------------------------------------- autocomplete
+  monaco.languages.registerCompletionItemProvider('ruby', {
+    triggerCharacters: ['.'],
+    provideCompletionItems: async (mdl, position) => {
+      const res = await post('/api/complete', {
+        code: mdl.getValue(), line: position.lineNumber, column: position.column,
+        path: currentPath,
+      });
+      setStatus(res.receiver
+        ? `${res.receiver} : ${res.receiver_class || '?'}${res.oracle ? ' (from tests)' : ''}`
+        : 'context evaluated');
+      const word = mdl.getWordUntilPosition(position);
+      const range = new monaco.Range(
+        position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+      return {
+        suggestions: (res.items || []).map(it => ({
+          label: it.name,
+          kind: KINDS[it.kind] || KINDS.method,
+          detail: it.kind === 'variable'
+            ? `${it.class || ''} ${it.value !== undefined ? '= ' + it.value : ''}`
+            : [it.signature, it.owner && `— ${it.owner}`].filter(Boolean).join('  '),
+          documentation: it.arity !== undefined
+            ? { value: `arity: \`${it.arity}\`` } : undefined,
+          insertText: it.name,
+          sortText: String(it.sort ?? 50).padStart(3, '0') + it.name,
+          range,
+        })),
+      };
+    },
+  });
+  // ----------------------------------------------------------------- hover
+  monaco.languages.registerHoverProvider('ruby', {
+    provideHover: async (mdl, position) => {
+      const word = mdl.getWordAtPosition(position);
+      if (!word) return null;
+      const res = await post('/api/hover', {
+        code: mdl.getValue(), line: position.lineNumber, column: position.column,
+        word: word.word, wordStartColumn: word.startColumn,
+        path: currentPath,
+      });
+      if (!res || !res.kind) return null;
+      const md = [];
+      if (res.kind === 'method') {
+        md.push({ value: '```ruby\n' + `${res.receiver_class}#${res.signature}` + '\n```' });
+        md.push({ value: `defined in **${res.owner}**` +
+          (res.arity !== undefined ? ` · arity \`${res.arity}\`` : '') +
+          (res.source ? `\n\nsource: \`${res.source}\`` : '') });
+      } else {
+        md.push({ value: '```ruby\n' + `${res.name} : ${res.class}` +
+          (res.value !== undefined ? ` = ${res.value}` : '') + '\n```' });
+        if (res.ancestors) md.push({ value: 'ancestors: ' + res.ancestors.join(' → ') });
+      }
+      if (res.via) md.push({ value: `_receiver type via ${res.via}_` });
+      if (res.observed && res.observed.length) {
+        const lines = res.observed.map(o => {
+          const args = Object.entries(o.args || {})
+            .map(([n, classes]) => `${n}: ${Object.keys(classes).join(' | ')}`).join(', ');
+          const rets = Object.entries(o.returns || {})
+            .map(([cls, sample]) => `${cls} (e.g. ${sample})`).join(' | ') || '?';
+          return `\`${o.method}(${args}) → \` ${rets} — ${o.calls} call${o.calls === 1 ? '' : 's'}`;
+        });
+        md.push({ value: '**Observed in unit tests:**\n\n' + lines.join('\n\n') });
+      }
+      if (res.doc) md.push({ value: res.doc.slice(0, 1500) });
+      return {
+        range: new monaco.Range(position.lineNumber, word.startColumn,
+                                position.lineNumber, word.endColumn),
+        contents: md,
+      };
+    },
+  });
+  // ------------------------------------------------------ go to definition
+  // The runner already knows Method#source_location — Cmd/Ctrl+click or F12
+  // jumps to it when it's a workspace file.
+  monaco.languages.registerDefinitionProvider('ruby', {
+    provideDefinition: async (mdl, position) => {
+      const word = mdl.getWordAtPosition(position);
+      if (!word) return null;
+      const res = await post('/api/hover', {
+        code: mdl.getValue(), line: position.lineNumber, column: position.column,
+        word: word.word, wordStartColumn: word.startColumn,
+        path: currentPath,
+      });
+      if (!res || !res.source) return null;
+      const m = String(res.source).match(/^(.+):(\d+)$/);
+      if (!m) return null;
+      const line = parseInt(m[2], 10);
+      if (res.source_rel) {
+        const rel = res.source_rel.replace(/:\d+$/, '');
+        await ensureBuffer(rel); // peek/jump needs the target model to exist
+        return {
+          uri: monaco.Uri.from({ scheme: 'ruby-ide', path: '/' + rel }),
+          range: new monaco.Range(line, 1, line, 1),
+        };
+      }
+      setStatus(`defined at ${m[1]}:${line} (outside workspace)`, { sticky: true });
+      return null;
+    },
+  });
+  monaco.editor.registerEditorOpener({
+    openCodeEditor: (_source, resource, selectionOrPosition) => {
+      const path = resource.path.replace(/^\//, '');
+      if (!buffers.has(path) && !fileList.find(f => f.path === path)) return false;
+      openFile(path).then(() => {
+        let pos = selectionOrPosition;
+        if (pos && pos.startLineNumber) pos = { lineNumber: pos.startLineNumber, column: pos.startColumn };
+        if (pos) { editor.setPosition(pos); editor.revealLineInCenter(pos.lineNumber); }
+      });
+      return true;
+    },
+  });
+  // ---------------------------------------------------- diagnostics + live run
+  let runtimeMarker = [];
+  const refreshDiagnostics = async () => {
+    const model = editor.getModel();
+    if (!model) return;
+    const res = await post('/api/diagnostics', { code: model.getValue() });
+    const markers = (res.diagnostics || []).map(d => ({
+      severity: monaco.MarkerSeverity.Error,
+      message: `syntax: ${d.message}`,
+      startLineNumber: d.line, startColumn: 1,
+      endLineNumber: d.line, endColumn: model.getLineMaxColumn(Math.min(d.line, model.getLineCount())),
+    }));
+    monaco.editor.setModelMarkers(model, 'ruby-ide', markers.concat(runtimeMarker));
+  };
+  let decorations = [];
+  const renderRun = (res) => {
+    const model = editor.getModel();
+    if (!model) return;
+    // ---- side panel
+    const finals = res.final_locals || {};
+    const rows = Object.entries(finals).map(([v, info]) =>
+      `<tr><td class="var">${esc(v)}</td><td class="klass">${esc(info.class)}</td><td class="val">${esc(info.value)}</td></tr>`);
+    $('state').innerHTML = rows.join('');
+    $('state-empty').style.display = rows.length ? 'none' : 'block';
+    $('stdout').textContent = res.stdout || '';
+    const errParts = [];
+    if (res.bundler_error) errParts.push(`bundler: ${res.bundler_error.message}`);
+    if (res.error) errParts.push(`${res.error.class || ''} ${res.error.message || res.error}`.trim());
+    $('run-error').textContent = errParts.join('\n\n');
+    // ---- runtime error squiggle
+    runtimeMarker = (res.error && res.error.line) ? [{
+      severity: monaco.MarkerSeverity.Error,
+      message: `runtime: ${res.error.class}: ${res.error.message}`,
+      startLineNumber: res.error.line, startColumn: 1,
+      endLineNumber: res.error.line,
+      endColumn: model.getLineMaxColumn(Math.min(res.error.line, model.getLineCount())),
+    }] : [];
+    // ---- per-line "debugger" annotations: show what CHANGED on each line
+    const states = res.line_states || {};
+    const lines = Object.keys(states).map(Number).sort((a, b) => a - b);
+    let prev = {};
+    const newDecos = [];
+    for (const ln of lines) {
+      if (ln > model.getLineCount()) continue;
+      const cur = states[ln];
+      const changed = Object.entries(cur).filter(([v, info]) =>
+        !prev[v] || prev[v].value !== info.value);
+      const shown = changed.filter(([, info]) => info.class !== 'NilClass');
+      if (shown.length) {
+        const txt = shown.map(([v, info]) => `${v}: ${info.class} = ${info.value}`).join('   ');
+        const col = model.getLineMaxColumn(ln);
+        newDecos.push({
+          range: new monaco.Range(ln, col, ln, col),
+          options: {
+            showIfCollapsed: true, // collapsed range: without this, injected text is dropped
+            after: { content: '    # ' + txt.slice(0, 120), inlineClassName: 'inline-state' },
+          },
+        });
+      }
+      prev = cur;
+    }
+    decorations = editor.deltaDecorations(decorations, newDecos);
+    refreshDiagnostics();
+  };
+  // Responses can arrive out of order (a buffer with a slow network call
+  // takes seconds; the next keystroke's run returns first) — only the
+  // newest request may render, and only onto the model it was sent for.
+  let runSeq = 0;
+  const runBuffer = async () => {
+    const model = editor.getModel();
+    if (!model) return;
+    const seq = ++runSeq;
+    setStatus('evaluating…');
+    try {
+      const res = await post('/api/run', { code: model.getValue(), path: currentPath });
+      if (seq !== runSeq || editor.getModel() !== model) return; // superseded
+      renderRun(res);
+      setStatus(res.error ? 'evaluated with error' : 'evaluated ✓');
+    } catch (e) { setStatus('server unreachable'); }
+  };
+  const debouncedDiag = debounce(refreshDiagnostics, 300);
+  const liveRun = debounce(() => { if ($('live').checked) runBuffer(); }, 700);
+  editor.onDidChangeModelContent(() => { debouncedDiag(); liveRun(); renderFileList(); });
+  $('run').addEventListener('click', runBuffer);
+  $('learn').addEventListener('click', async () => {
+    setStatus('running learn commands…', { sticky: true });
+    const res = await post('/api/learn', {});
+    const out = [];
+    if (res.error) out.push(typeof res.error === 'string' ? res.error : `${res.error.class}: ${res.error.message}`);
+    (res.commands || []).forEach(c => {
+      out.push(`$ ${c.command}${c.timeout ? '   [TIMED OUT]' : c.ok ? '' : `   [exit ${c.exit}]`}\n${(c.output || '').trim()}`);
+    });
+    if (res.methods_observed !== undefined) out.push(`→ learned types for ${res.methods_observed} methods`);
+    $('tests-out').textContent = out.join('\n\n');
+    $('tests-out').style.display = 'block';
+    $('tests-empty').style.display = 'none';
+    setStatus(res.error
+      ? 'learn failed'
+      : `learn ${res.passed ? 'passed' : 'FAILED'} — ${res.methods_observed} methods observed`,
+      { sticky: true });
+  });
+  // ------------------------------------------------------------------ boot
+  (async () => {
+    await refreshFiles();
+    const first = fileList.find(f => f.path === 'main.rb') || fileList[0];
+    if (first) {
+      await openFile(first.path);
+    } else {
+      editor.setModel(monaco.editor.createModel(
+        "# empty workspace — create a file with the + button\n", 'ruby'));
+    }
+    setStatus('ready');
+  })();
+});
+</script>
+</body>
+</html>

data/lib/ruby_test_ide/public/vendor/monaco/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+Copyright (c) 2016 - present Microsoft Corporation
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.