Gist 772368

Gist 782256

The example demonstrates a syntax-tree rewriting workflow for LPC source code, showing a crash during tree optimization. It parses input through `LPC::Parser`, extracts the parse tree, and feeds it into `LPCTreeRewrites::TreeParser` via an ANTLR3 `CommonTreeNodeStream`, then calls `downup` to rewrite the tree. The run terminates with a `TypeError` (`nil is not a symbol`) inside ANTLR3’s `recognize` method, revealing a failure in the grammar’s rewrite rules. The code relies on the ANTLR3 Ruby runtime and a custom generated lexer/parser, with the error trace pinpointing the exact library call where the issue occurs.

65% match

Gist 772135

This visualization shows a Ruby error trace from the ANTLR3 parser library, captured as a gist. It displays the sequence of stack frames leading to a `NameError` about an uninitialized constant `Socket::SOL_TCP`, starting from the command-line invocation of `LPCParser.rb`. The rendering relies on the Ruby backtrace formatting and the `antlr3` gem’s debug socket communication, with the output shown as plain text lines. The data source is the literal terminal output from the failed parser run, presented without additional styling or interaction.

64% match

Gist 2784668

This example visualizes the structure of the YARD Ruby documentation library as a navigable tree, starting from its root module and expanding through child namespaces, methods, and constants. It renders this hierarchy using JSON-LD formatted data, which is generated from YARD’s Registry API to capture relationships like children and namespaces. The visualization relies on the `json` and `cgi` libraries to process and encode the data, while the tree layout itself is implemented with D3’s `d3.forceSimulation` and related tree-layout functions.

RRichMorin

56% match

Just a Test

This example renders a directed graph as a sentence parse tree, showing the hierarchical structure of the phrase "This is an example sentence." The nodes represent grammatical categories (TOP, S, NP, VP) and tokens (This, is, an, example, .), with edges connecting parents to children. Code uses the dagre-d3 library’s `Graph`, `render`, and `setNode`/`setEdge` APIs to compute a layered layout and draw it on an SVG. Custom CSS styles round the node corners and highlight token nodes (type-TK) in teal. The D3 selection `d3.select('svg')` appends a group for the rendered output.

Wwilliamhsu0502

Gist 202667

This example shows a Ruby error trace from a failed RSpec test run, specifically a `TypeError` about dumping an anonymous class while using YAML serialization with single-table inheritance subclasses in a `before(:all)` hook. The visualization presents the full stack trace, highlighting the chain of method calls from the test assertion through DataMapper’s YAML adapter, Extlib hooks, and RSpec’s example runner. The code uses standard Ruby libraries (`yaml`, `pathname`) and frameworks like DataMapper, Extlib, and RSpec, revealing how the error propagates across the gem’s internal APIs.

Gist 50451

This example visualizes Ruby method lookup by displaying the ancestor chain for a given class and method. It shows the hierarchy of `Array < Enumerable < Object < Kernel` and highlights which ancestors define the queried method, using plain text output. The code relies on Ruby’s reflection APIs, including `ancestors`, `instance_methods`, and `singleton_methods`, to inspect class relationships. It prints a search log that marks each ancestor as defining the method as an instance or singleton method, or not at all, making the inheritance behavior explicit.

DDylanFM

Gist 411267

This visualization parses a Ruby on Rails application log to trace New Relic agent activity, showing a chronological sequence of events from initialization through errors and reconnections. The code uses d3.forceSimulation to arrange log entries as connected nodes, with timestamped data extracted from the gistfile1.txt source. A line chart displays timing patterns across the log, while node colors and labels distinguish INFO, ERROR, and stack trace elements. The rendering relies on d3.select and SVG paths to map the log’s structure.

Gist 209613

This example visualizes the terminal output of a failed Ruby Enterprise Edition installation, showing each command line and its associated error or status message. The data comes from a gist file containing the raw shell session text. It uses d3.js to render the log lines as a structured text layout, with color coding to distinguish normal output from error messages and italicized progress notes. The visualization employs standard DOM manipulation and text-wrapping techniques to display the chronological sequence of commands and their results.