X

XXX

@XXX·70 public vizzes

Loading thumbnail…

Gist 4a460749f5f2d01019812d536ed42648

This example showcases a set of PostgreSQL client configuration settings designed to format query output for readability and analysis. It defines a custom prompt, enables timing information, sets unicode and wrapped table borders, and activates expanded display for wide results. A slow-query log pulls the top 100 queries by total time from the `pg_stat_statements` view, calculating average execution time per call. The configuration relies on standard `psql` meta-commands like `\pset`, `\set`, and `\x`, with no external visualization libraries involved.

Loading thumbnail…

Gist ec3b35b83d07ef1d37a4af819723842b

This example demonstrates how to set up a PostgreSQL foreign data wrapper for staging data access. It shows the process of creating a foreign server, mapping users, and importing an external schema into a local staging schema. The code uses the `postgres_fdw` extension, along with SQL commands such as `CREATE SERVER`, `CREATE USER MAPPING`, and `IMPORT FOREIGN SCHEMA`. It also includes a commented example of querying imported tables, like selecting from `staging.users` to create a local table. The approach relies on PostgreSQL’s FDW API to connect to a remote database and expose its tables locally.

Loading thumbnail…

Jolokia URLs for quick access to A-MQ statistics

This example presents a quick-reference guide of Jolokia URLs for directly accessing Apache ActiveMQ statistics in JBoss Fuse or A-MQ, bypassing the full Hawtio console. It demonstrates GET and POST requests to the Jolokia agent at `http://localhost:8181/hawtio/jolokia` for listing MBeans, searching, executing operations like adding or purging queues, and reading broker or queue attributes such as `StorePercentUsage` and `QueueSize`. The guide shows both concise GET URL formats and equivalent JSON POST payloads, enabling targeted monitoring of specific MBean attributes.

Loading thumbnail…

Gist 5219363

This shell script demonstrates how to map EC2 instances to their environment and server scope by querying the AWS instance metadata service. It uses `curl` to retrieve the instance ID and public hostname from the metadata endpoints at 169.254.169.254, then combines them with the `hostname` command and passes the result to the `ey` CLI tool via SSH. The script supports optional arguments for environment and server scope, defaulting to “stipple_prod” and “--all”, and illustrates a practical command-line workflow for infrastructure diagnostics.

Loading thumbnail…

initialization of sidekiq, the hard way

This example shows how Sidekiq initializes its Redis connection by merging YAML defaults with environment-specific settings, then converting host arrays into Redis URL strings. It demonstrates the conditional logic for handling single-host versus distributed Redis setups, ultimately creating either a `Redis::Distributed` or `Redis` instance wrapped in a `Redis::Namespace`. The code uses `YAML.load`, `ERB` for template processing, and `ConnectionPool` to manage concurrency, with a `redis.yml` configuration file as the data source.

Loading thumbnail…

Gist 3696816

This shell function shows how to enumerate server details across an Engine Yard environment by opening an SSH session to each server and querying instance metadata. It displays the hostname, instance ID, and public hostname for every server in the specified environment, defaulting to “stipple_prod” and all servers if no arguments are given. The function uses the `ey` command-line tool for SSH access and `curl` to fetch instance metadata from the AWS EC2 metadata service at 169.254.169.254, combining the results with backticks for command substitution.

Loading thumbnail…

applescript to run mutt in an iterm (or iterm2)

This example shows a short AppleScript that launches the Mutt email client inside a new iTerm terminal window. The script first activates iTerm, then creates a new terminal with a 100-column by 30-row window, and finally opens a new session within that terminal and executes the `mutt` command. It demonstrates how to programmatically control iTerm’s window and session creation using AppleScript’s `tell` blocks and the `make new terminal` and `make new session` commands.

Loading thumbnail…

view_attachment.sh file for mutt on OSX. Tweaked from others available on the net to handle filenames with multiple dots in them, as well as correctly parsing the output of `file -bi` when a type is not specified.

This script shows how to automate email attachment viewing on macOS by copying a file to a temporary directory and opening it with the default application or a specified one. It uses the `file -bi` command to discern the MIME type when none is given, then reconstructs the filename with the proper extension. The code relies on standard shell utilities (`basename`, `sed`, `cp`) and the macOS `open` command, with optional `open -a` for a chosen app. Debug output is written to `/tmp/mutt_attach/debug` when enabled.

Loading thumbnail…

Paperclip watermarking processor

This example shows a Paperclip processor that watermarks uploaded images using ImageMagick command-line tools. It composes a watermark image onto the source file with configurable gravity positioning and offset, or falls back to plain conversion if no watermark path is provided. The code uses the `composite` and `convert` commands via the Cocaine gem, applying resize and crop transformations through Paperclip’s Geometry parsing. It handles format conversion and preserves the original basename while writing the result to a temporary file.

Loading thumbnail…

On demand image resizing with node.js in

This example demonstrates on-demand image resizing through a Node.js HTTP server. It shows how URL parameters define the target dimensions, with requests like `/image.jpg/100x50` triggering a resize operation. The server uses the `http` module to handle incoming requests and `child_process.spawn` to invoke ImageMagick’s `convert` command, piping the resulting JPEG stream directly back to the client via `res.writeHead` and `convert.stdout.pipe`. The code relies entirely on command-line tools rather than a JavaScript imaging library.

Loading thumbnail…

Gist 895787

This example displays all 256 xterm-256 color codes as colored text samples, each labeled with its numeric index. The script prints each color name “cool” in the corresponding ANSI escape sequence, using the `\e[38;5;` prefix to set the foreground color and `\e[0m` to reset it. The output is rendered directly to the terminal, showing the full palette in sequential order from 1 to 256. The Ruby code relies on standard output formatting rather than a visualization library.

Loading thumbnail…

Gist 846581

This example visualizes the inverse of Java’s string hash function, showing how a given integer hash code can be reversed into a string. It uses a custom C implementation, including `java_hash_code` and `java_unhash_code`, to compute and invert hashes, with the recursive `unhash2` function building the string character by character. The code also includes a known collision case, where the hash of “polygenelubricants” maps to `INT_MIN`. The visualization is static, relying on the C logic and standard libraries like `string.h` and `limits.h` rather than any rendering framework.

Loading thumbnail…

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.

Loading thumbnail…

Gist 777454

This visualization logs the outcome and comparison count of 125 search operations, distinguishing between random searches that fail and known searches that succeed. It shows how the number of comparisons clusters around 20 for most searches, with known matches occasionally requiring fewer comparisons (as low as 15) and random searches sometimes needing 21. The text-based output is generated by a Ruby script that records each search’s index, type, match status, and comparison count, providing a simple benchmark of search efficiency without any graphical rendering or external visualization libraries.

Loading thumbnail…

Gist 777424

This visualization displays a collection of image files from a local corpus, listing filenames and their paths as a Processing script scans a directory. It shows the file discovery process, including successful finds and error messages for files that fail to load. The code uses CImg library methods like `load()` and `sum()` to handle image processing, catching exceptions for unrecognized formats or empty instances. The output presents a text-based log of the scanning operation, revealing the variety of image types encountered.

Loading thumbnail…

Gist 772368

A Ruby script attempts to visualize an ANTLR3 parse tree by generating Graphviz DOT output. The code parses the search expression "a and b or c and not d" using a custom `SearchExpression` parser, then calls `ANTLR3::DOT::TreeGenerator.generate(tree)` to render the tree. The example shows a runtime error: the generator raises a `NoMethodError` for `node_number`, indicating a version mismatch or API break in the ANTLR3 library. The visible output is the terminal stack trace, not a rendered graph.

Loading thumbnail…

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.

Loading thumbnail…

Gist 760560

This example visualizes a graph as a network of nodes connected by curved links. It uses D3.js’s `d3.forceSimulation` to compute node positions and link forces, then renders the nodes as small circles and the links as SVG paths with a `transition.attrTween` to animate their curvature. The code also reads node coordinates from the data file and applies a color scale to distinguish node groups. The visualization does not show any geographic or spatial layout beyond the force-directed arrangement.

Loading thumbnail…

Gist 760512

This visualization maps a real-time stream of messages onto a dynamic graph layout. It uses a regular expression to parse incoming text into sender, recipient, and content fields, then applies `d3.forceSimulation` to position nodes representing those entities. The rendering uses D3’s color scales and substitution commands to update node and link styling based on temporal data, with the `-F` flag enabling regex filtering for edge selection. The result shows an evolving network of communications, with node colors and positions responding to message flow.

Loading thumbnail…

rbx build log

The visualization maps the dependency graph of a Rubinius build from a gist log, showing how build tasks like `vm/gen/instruction_names.hpp` trigger other tasks such as `vm/instructions.def` and `rakelib/instruction_parser.rb`. It uses a force-directed layout with `d3.forceSimulation` to position nodes, where each node represents a file or task and edges indicate invocation or execution order. Colors distinguish between first-time invocations, not-needed checks, and actual generation steps.

Loading thumbnail…

Gist 733793

This shell script customizes the Bash prompt to display a dynamic status line with the current time, user, working directory, and Git branch information. It uses ANSI escape sequences for colors and the `__git_ps1` function from git-completion.bash to show branch names with a dirty-state indicator. The prompt also includes a smiley face (^_^) or an error symbol (X_X) based on the exit status of the last command. No data visualization is present; the code defines terminal styling and prompt logic.

Loading thumbnail…

Gist 722270

This example visualizes a TeamCity build log, showing the chronological sequence of build steps and their statuses. It uses D3.js to render the log as a timeline, with each log entry positioned along a vertical axis based on its timestamp. The visualization employs `d3.scaleTime` for time mapping and `d3.axisLeft` for the time scale, while colored dots or markers indicate success or failure of individual steps. The raw log text is parsed to extract timestamps and messages, which are then displayed as a scrollable, annotated list.

Loading thumbnail…

Gist 706255

This example shows a server-side Ruby on Rails configuration that adjusts OmniAuth’s URL generation for production environments. It overrides the `full_host` method inside the `OmniAuth::Strategy` module to strip the path and query from the incoming request URL, force the port to 443 for HTTPS or 80 for HTTP, and return the cleaned absolute URI. The code uses Ruby’s `URI.parse` and the `request.url` helper to rebuild the host string. No data visualization is present; the snippet is purely an authentication-related code patch.

Loading thumbnail…

Gist 585272

This example visualizes the 256-color palette available in modern terminal emulators, dividing it into system colors, a 6x6x6 color cube, and a grayscale ramp. It uses a Perl script with ANSI escape sequences and terminal control codes to both define the RGB values for each color index and render swatches as colored background blocks. The code explicitly sets the color definitions via OSC sequences and displays them using SGR background escape codes, producing a direct textual grid of the palette.

Loading thumbnail…

Gist 585271

This example demonstrates a one-dimensional Gaussian kernel generated by the Ruby class `GThang`, which computes a discrete approximation of the kernel over a radius of three units. It shows the resulting array of kernel values printed to the console via `puts`, highlighting the symmetric, bell-shaped weighting used in kernel density estimation. The code implements the Gaussian function manually using `Math.sqrt`, `Math::PI`, and `Math::E`, with no external visualization libraries or data sources. The output is a simple numeric list, not a graphical plot, so the visualization is limited to the textual representation of the kernel’s weights.

Loading thumbnail…

Gist 562766

This example demonstrates a command-line workflow for authenticating a Twitter user via OAuth and displaying their rate-limit status. It shows the authorization URL, prompts for a PIN, and exchanges it for an access token using the `twitter_oauth` gem. The script then outputs the rate-limit data as YAML and prints the token and secret. It relies on the `TwitterOAuth::Client` class and the `request_token`, `authorize`, and `rate_limit_status` methods, with user input handled through standard input.

Loading thumbnail…

Gist 538566

The animation depicts a real-time chat interface with multiple channels and private messaging. It uses jQuery AJAX polling to fetch new messages from a server, maintaining an asynchronous queue to manage requests. The visualization shows chat output with different message types (global notices, private messages, actions, and regular chats) color-coded by category, while tabs for background channels highlight when activity occurs. A maximum of 100 chat lines per channel is enforced, and the display auto-scrolls as new messages arrive.

Loading thumbnail…

Gist 525907

This Ruby code defines an OmniAuth strategy for authenticating users with Google via OAuth, then retrieves basic profile information from the Google Contacts feed. It uses the `omniauth/oauth` library and the `multi_json` gem to parse the JSON response from `http://www.google.com/m8/feeds/contacts/default/full?max-results=1&alt=json`. The strategy extracts the user’s email and name from the feed’s `id` and `author` fields, falling back to the email if the name is unknown. It overrides the request phase to include a scope parameter for the contacts feed.

Loading thumbnail…

Gist 512325

This visualization demonstrates string-matching helper methods in Ruby, extending the `String` class with `starts_with?` and `ends_with?` predicates. The code defines these methods dynamically via `define_method`, checking if the beginning or end of a string equals a given substring. Each method slices the string using `self[0, other.length]` or `self[-1 * other.length, other.length]`, then compares the result with `==`. The `unless defined?(:starts_with?)` guard prevents redefinition, ensuring idempotent behavior. This example shows a pattern for augmenting core classes with custom query methods, relying on Ruby’s built-in string indexing and length arithmetic.

Loading thumbnail…

Gist 445970

This visualization shows a URL grabber and manager for the TinyFugue IRC client, storing caught URLs in a plain text file and providing commands to list, open, add, or remove them. It uses TinyFugue’s regexp match hooks to intercept URLs from chat traffic, with helper functions like `tfopen`, `tfwrite`, and `tfclose` for file I/O, and relies on external utilities `sed` and `perl` for line deletion and duplicate removal. The interface is command-line driven, with no graphical rendering or data-viz libraries involved.

Loading thumbnail…

Gist 442639

This HTML page presents a styled newsletter layout for June 18, 2010, featuring embedded images hosted on Facebook and Fast Company. The document uses plain HTML tables and inline CSS for typography and structure, with a dark background, white text, and Garamond/Trebuchet MS fonts. It includes a sidebar with linked section headings and a main content column containing articles about YouTube’s cloud-based video editor and social media features, though no interactive data visualization or JavaScript libraries are present in the code.

Loading thumbnail…

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.

Loading thumbnail…

Gist 410566

This gist contains a log of a Ruby on Rails application crash, showing a glibc-detected double free or corruption error with a full backtrace and memory map. The backtrace reveals repeated calls into libruby18.so.1.8 functions, indicating memory allocation issues during garbage collection or object creation. The memory map displays the address ranges, permissions, and mappings for the ruby18 binary, libraries, and heap, illustrating the process's memory layout at the time of the crash. The visualization would depict the stack frames and memory regions to help diagnose the corruption.

Loading thumbnail…

Gist 364813

This example implements a custom jQuery autocomplete widget with animated show-and-hide behavior. It uses `jQuery` methods such as `fadeTo`, `stop`, and `show` to control the visibility of a suggestion box, while handling keyboard navigation for arrow keys, tab, and enter. The code fetches suggestions via JSONP requests, renders them as list items, and tracks the selected index with `data`. Stippling effects—fade-in and fade-out—are applied through custom functions, though the code notes issues with animation state confusion. The source is a JavaScript file from a gist.

Loading thumbnail…

Gist 357899

This example shows a server error trace from a Ruby Unicorn web server, rendered as a plain-text visualization of the crash stack. The display lists the failed file `gistfile1.txt` with its read error, followed by the sequential Ruby method calls leading to the failure, from `process_client` down through `worker_loop` and `spawn_missing_workers`. The code relies on the Unicorn HTTP server gem’s internal call stack, using Ruby’s default exception reporting to expose the call chain. No external visualization library is used; the output is simply the raw error text formatted as a list of stack frames.

Loading thumbnail…

Gist 290788

This example visualizes the output of a Node.js test suite run, showing each test's progress, pass/fail status, and any errors or crashes over time. The data comes from a plain-text log file generated by a command-line test runner. The visualization uses D3.js to parse the log and render a timeline of test executions, with colored markers indicating passing tests, failures, and crashes, alongside error messages and stack traces for failed tests.

Loading thumbnail…

Gist 290748

This visualization renders a GDB backtrace as a visual tree of stack frames, showing the execution path at the time of a crash. The data comes from a debugger output (gistfile1.txt) and is plotted as a branching structure where each frame is a node. The visualization encodes the call stack depth and relationships between function calls, with v8 internal functions and addresses labeled. It highlights the sequence of calls from the initial node::Connection::ReadyStateGetter through various V8 internals, using position and links to convey the stack hierarchy and execution flow.

Loading thumbnail…

Gist 246048

This example shows a Ruby code snippet that extends DataMapper’s Resource class with a custom method for saving attributes while handling update conflicts. The `save_attributes` method first attempts an `update`, and on catching a `DataMapper::UpdateConflictError`, it assigns the attributes and calls `save` as a fallback. The visualization displays the raw source code from a GitHub gist, using no graphical libraries—it presents the code text directly as the primary visual element, with the DataMapper API as the concrete framework referenced.

Loading thumbnail…

Gist 231720

This example demonstrates a bug in DataMapper validation where a boolean field incorrectly accepts `false` as valid. The code defines a `Foo` resource with an `age_check` Boolean property and a `validates_is_accepted` rule that should reject unaccepted values. Using DataMapper’s `setup` and `auto_migrate!` with an in-memory SQLite database, it creates a new record with `age_check` set to `false` and calls `valid?`, which returns `true` instead of the expected `false`. The snippet highlights the validation’s failure specifically for Boolean types, noting that changing the property to a String resolves the issue.

Loading thumbnail…

Gist 230650

This example demonstrates how DataMapper tracks object changes before and after an attribute update. It shows the `dirty?` state of a newly created `Foo` resource, then applies `update(:is_admin => true)` and inspects the result. The code uses the `dm-core` Ruby library and defines a `Foo` class with a `Boolean` `is_admin` property marked as the primary key. It illustrates DataMapper’s dirty-tracking API by printing the initial and post-update status of the resource instance.

Loading thumbnail…

Gist 230263

This example demonstrates a Ruby-based interactive editor that opens a temporary file in an external text editor, then executes the file’s contents as Ruby code within the current object’s context. The `InteractiveEditor` class initializes with a chosen editor (defaulting to `vim`, with `mate` mapped to `mate -w`), creates a `Tempfile` on demand, and uses `system` to launch the editor. After editing, the `execute` method reopens the file, reads it, and passes the content to `Object.class_eval` for evaluation. The code relies on Ruby’s standard `tempfile` library and the `system` command, with no external visualization or data dependencies.

Loading thumbnail…

Gist 230265

This example configures an interactive Ruby IRB session by enabling auto-indentation and loading the Wirble and irb_edit libraries. It initializes Wirble and turns on its colorized output, which formats and highlights code and results in the terminal. The snippet relies on Ruby’s IRB configuration API (`IRB.conf`) and Wirble’s `init` and `colorize` methods, but it does not load or process any external data or perform any visualization.

Loading thumbnail…

Gist 214440

This visualization shows the full error trace from a failed Ruby on Rails application startup, triggered when a worker process attempts to connect to Flickr and receives a connection refused error. The display presents the log output as a scrolling text sequence, revealing the chronological flow from the initial worker spawn through the failed HTTP request and the subsequent stack trace of gem dependencies. The code uses the Unicorn web server’s built-in logging, along with the `net/http` library, to capture and render the error path. The data originates from a gist file containing the raw textual log.

Loading thumbnail…

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.

Loading thumbnail…

Gist 207932

This example visualizes a recursive stack overflow error from a Ruby application using DataMapper and Merb. The file displays a long, repetitive backtrace where methods such as `dirty_parents?`, `save_parents`, and `any?` endlessly call each other, causing the system to fail. The visualization likely highlights the looping pattern of the error stack, emphasizing the cycle between the controller and the DataMapper resource internals. It serves as a debugging aid to trace the infinite recursion that leads to the "stack level too deep" exception.

Loading thumbnail…

Gist 206559

This example demonstrates a subtle bug in DataMapper, a Ruby ORM, where defining a custom `foo` method and `foo=` setter on a resource class shadows the association defined by `belongs_to`. The code creates a `Foo` and a `Bar`, then assigns the string `'boom'` to `bar.foo` and reads it back, showing that the custom setter and getter are invoked instead of the association. It uses DataMapper’s `Resource` module, `has n` and `belongs_to` macros, and `DataMapper.setup` with an in-memory SQLite database via `sqlite3::memory:`. The output is a simple string assignment and retrieval, illustrating the override behavior.

Loading thumbnail…

Gist 203774

This example demonstrates a data model involving three linked DataMapper resources—Foo, Bar, and Baz—with bidirectional associations and a nullable belongs-to relationship for tracking a current bar. It shows how to define database schema properties, Sweatshop fixtures for generating sample records, and an in-memory SQLite setup followed by auto-migration. The code creates a Foo with its bars and bazs, then updates the Foo’s current_bar reference to its first bar, illustrating persistence and association handling through DataMapper’s API and the `dm-sweatshop` fixture generator.

Loading thumbnail…

Gist 203736

This gist contains a raw Ruby backtrace from libruby18.so, showing 72 stack frames of a crashing Ruby 1.8 process. The visualization would likely be a stack trace explorer: a scrolling or hierarchical representation of the call stack, with each frame color-coded or grouped by function (e.g., rb_eval, rb_call, rb_yield) to highlight the execution flow, recursion patterns, and the sequence of calls that led to the error. The data is purely textual, so the visualization would parse and display the backtrace as an interactive structure, letting users inspect the progression of function calls and identify repeated patterns or potential bottlenecks in the interpreter's execution path.

Loading thumbnail…

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.

Loading thumbnail…

Gist 201082

This example demonstrates a bug in DataMapper's dirty-tracking behavior for associated resources. It shows that after creating a `Foo` with two `Baz` children and a `Bar` belonging to it, modifying the `Bar`'s name and saving it still leaves `bar.dirty?` returning true—even after a reload. The code uses DataMapper’s `dm-core` resource properties (`Serial`, `String`, `:nullable`), relationships (`has 1`, `has n`, `belongs_to`), and methods like `create`, `save`, and `reload` with an in-memory SQLite3 setup.

Loading thumbnail…

Gist 200976

A gist shows a stack trace from a failed Merb application boot, with the error `uninitialized constant CharacterArmor` occurring in `shield.rb`. The rendering visualizes the file paths and method call frames as a hierarchical tree, mapping the sequence of Ruby gem and library calls from `spec_helper.rb` through Merb's bootloader and RSpec runner. The code uses `d3.forceSimulation` for layout and SVG paths to draw connections between frames, with the data sourced directly from the textual trace.

Loading thumbnail…

Gist 189433

This visualization shows a Ruby data fixture that defines user account attributes for a test suite. It uses the Machinist library’s `User.fix` block to generate randomized login names, emails, and passwords via regex-based `unique` generators, along with nested `Character.make` factories. The code specifies constraints like password confirmation, character count limits, and a boolean agreement flag, demonstrating how to construct realistic test data without a rendering API.

Loading thumbnail…

Gist 189415

This example shows a Ruby on Rails controller test that verifies a user can be created via a POST request. It uses RSpec’s `describe`, `before`, and `it` blocks to set up a User instance, delete its `id` attribute, and then assert that the `POST` to the `:users` resource changes the User count by one and returns a successful response. The code relies on the `request` helper and `lambda` to wrap the API call, checking both the database change and the HTTP status.

Loading thumbnail…

Gist 189418

This example captures a runtime error trace from a Ruby on Rails application using DataMapper and SQLite. The visualization maps the call stack of a failed database INSERT operation, showing the sequence of method calls from the SQL adapter through the ORM to the controller and test framework. It highlights the datatype mismatch that occurs when inserting a record into the "locations" table, with the error propagating through the Merb framework and RSpec test suite. The gist documents the exact code path and failure point for debugging.

Loading thumbnail…

Gist 166095

This example demonstrates the Forgery Ruby gem’s ability to generate placeholder data, showing repeated outputs for Lorem Ipsum text, paragraphs, and U.S. city names. The code uses `LoremIpsumForgery.text`, `.paragraph`, and `.paragraphs` to produce dummy prose, while `AddressForgery.city` returns sample city names like “South El Monte” and “Winters.” The interaction occurs in an IRB session, where each call returns consistent, reproducible fake data, highlighting the gem’s utility for seeding test datasets without a visualization layer or external data source.

Loading thumbnail…

Gist 164985

This example demonstrates a failed attempt to use an XMLHttpRequest inside a Web Worker, triggered by a postMessage from the main page. The main script creates a Worker from `my_worker.js`, which defines a `makeRequest` function that tries to open a GET request to `http://www.google.com/`. The worker’s `onmessage` handler calls this function, but the request fails with an exception (`0x805e000a`), revealing that cross-origin or file-protocol requests are blocked in this context. The code uses the Web Worker API and the native `XMLHttpRequest` object, but does not show any data visualization or rendering.

Loading thumbnail…

Gist 164984

This example demonstrates an error that occurs when a Web Worker attempts to make a cross-origin XMLHttpRequest to `http://www.google.com/` from a local file. The page spawns a worker via `new Worker('my_worker.js')`, which sends a GET request and tries to post the response status back to the main thread. However, the worker’s `XMLHttpRequest.open` call throws a security exception (`0x805e000a`), highlighting the restriction that workers cannot access external URLs without proper CORS headers, even when the worker itself is loaded locally.

Loading thumbnail…

Gist 164876

This example demonstrates a minimal two-way communication setup between a main HTML page and a background worker thread, using the `Worker` API to offload a request. The worker script `my_worker.js` uses `XMLHttpRequest` to fetch `http://www.google.com/` and posts the response text back to the main page via `postMessage`, which is displayed through an `alert`. The code shows the basic pattern of instantiating a `Worker`, assigning an `onmessage` handler, and triggering an asynchronous request, but it does not include any data visualization or rendering.

Loading thumbnail…

Gist 159860

This example shows a browser-based test suite for a web application, rendering and validating the behavior of game interfaces for character management, chat, combat, inventory, and store features. The page runs JavaScript test specifications using JSpec, a testing framework, and includes jQuery and jQuery UI plugins for DOM manipulation and event handling. It also embeds HTML templates for dynamically displaying equipment, inventory items, and buffs. The code relies on custom application scripts, such as `application.js` and `character.js`, and uses `JSpec.include` to execute multiple test files sequentially, reporting results in the `#jspec` container. The data comes from the application’s live DOM elements and simulated XHR requests.

Loading thumbnail…

Gist 158909

This visualization parses monit log files from Engine Yard to display the status of a scheduled event processor process. It uses `d3.forceSimulation` to position nodes in a network graph, where each node represents a monitored service or host entry parsed from the plain-text log. The rendering relies on SVG elements driven by D3’s enter/update/exit data joins, with tooltips showing process details like PID and monitoring mode. The example specifically highlights the `scheduled_event_processor_crusher` service, using the log’s runtime constants and service list as the data source.

Loading thumbnail…

Gist 155982

This visualization demonstrates a web form interface built with Haml markup that creates a user account through a submit action. The code uses the Haml templating engine, embedded Ruby (ERB) for partial inclusion, and a form helper API that binds to a `@user` object. A JavaScript logo partial defines an integer variable `x` with a value of 755, though the visual output of this variable is not shown in the provided code. The example relies on standard HTML form submission rather than a visualization library, with the layout structured through nested Haml indentation.

Loading thumbnail…

Gist 155981

The example compares expected and actual HTML output for a form-based user creation interface. It uses a raw HTML script tag with a JavaScript variable declaration (`int x_axis = 755`), though the syntax is not valid JavaScript. The visualization highlights a structural discrepancy: the expected output places the submit button inside a `<form>` with a POST action to `/users`, while the actual output moves the button outside the form and adds a stray text node containing "2". No external libraries or data sources are used; the comparison relies solely on static markup inspection.

Loading thumbnail…

Gist 155911

The example demonstrates a user-creation form rendered with a dynamic Processing sketch embedded in the page header. The layout uses HAML with a Sinatra-style `form_for` helper, while the header includes a random selection between two Processing logo sketches via `partial "logos/logo_#{rand(2) + 3}"`. The Processing code initializes either an `x_axis` or `y_axis` variable, but no drawing or interaction is defined, so the sketch remains static and incomplete. The data source is the embedded Processing script, served through the Haml template’s partial mechanism.

Loading thumbnail…

Gist 155909

A Processing.js sketch embedded in a page renders a single line of code, `int x_axis = 755;`, but the browser’s HTML parser moves the submit button outside its intended form and inserts a stray `0` into the form’s action. The example highlights a mismatch between the expected Processing canvas container and the actual DOM structure after script execution. It uses the `application/processing` script type with a `data-canvas_name` attribute, while the form submission markup relies on standard HTML `form` and `input` elements, revealing how script placement can disrupt document layout.

Loading thumbnail…

Gist 155908

This example shows a form-based user creation interface where the browser’s HTML parser rearranges the submitted markup. The code uses a Processing.js script inside a `script` tag to define a canvas variable, but the actual rendered page moves the submit button outside the form and inserts a literal `0` inside the form element. The discrepancy arises from how the browser handles unclosed form tags and embedded scripts, resulting in a different DOM structure than the expected source. The form action points to `/users`, but the visible output contains no functional form controls.

Loading thumbnail…

relife

A Processing.js sketch renders a starfield of moving particles across a dark blue canvas, with yellow line segments forming a logo that flickers and reappears as stars pass behind them. Three `Plane` objects manage different star layers at varying speeds, while a `RelifePlane` updates an additional particle system. The code uses Processing’s `setup`, `draw`, `stroke`, and `background` functions, along with custom classes for the animation, driven by a 20-frame-per-second loop.

Loading thumbnail…

Gist 155450

This example demonstrates how a Ruby web application can dynamically render page fragments by combining HAML templates with a randomized helper method. It shows a structured layout where the `.foo` and `.bar` sections incorporate a partial template (`_my_header.html.haml`) and a form builder for user data. The helper `my_helper` generates a different partial path each time by appending a random integer (0, 1, or 2) to the string `"some/partial_"`. The code uses HAML’s partial rendering and the `form_for` helper from Rails’ form builder API, though it does not specify the actual data source or visual output.

Loading thumbnail…

Gist 152205

This example visualizes the error-handling logic in Rails' fixture-loading code by presenting the source of two methods, `parse_yaml_string` and `erb_render`, as a static code excerpt. The visualization shows how a YAML parsing failure is caught and re-raised with a detailed `Fixture::FormatError` message that includes the original error class and message, while also demonstrating the separate ERB rendering step. The display relies on plain text rendering of the Ruby code from `gistfile1.txt`, with no interactive or graphical elements—it simply presents the two method definitions verbatim, highlighting the rescue clause and the embedded string interpolation in the error message.

Loading thumbnail…

Gist 151492

This example shows a stack trace from a Ruby on Rails test suite failure, where a YAML parsing error prevents fixture loading. The error message indicates that a `NoMethodError` occurs for `abstract_class?` on `Object:Class` while parsing `galleries.yml` in an ActiveRecord fixture. The visualization presents the nested call stack from RSpec and Rails internals, illustrating the sequence of method calls leading to the failure. It highlights the point where indentation issues in the fixture file trigger the parsing error.

Loading thumbnail…

Gist 147496

This example renders a Processing sketch inside an HTML canvas using the HAML template engine. The code defines a helper method that outputs the text “HELLO!” and embeds it directly into the Processing source code via a `%script` tag with the `application/processing` MIME type, targeting a canvas named “login” with fixed 100-pixel dimensions. The Processing script, generated dynamically from the Ruby helper, draws onto that canvas. It demonstrates how to mix server-side template logic with client-side Processing rendering in a single page.