Skip to main content
SimilarExport ZIP
100%

Gist b99e7499ed393379a3884f1e1c51fa33

✓ Published0🌍 Public
LLucienPerouze
Last edited Feb 15, 2018
Created on Feb 15, 2018

This example demonstrates a RESTful API sandbox for a messaging system, showing how to handle POST and GET requests to add and retrieve chat messages. The code uses Sandbox.define() to create endpoints for `/addMessage` and `/getMessages/{userId}/{index}`, validating JSON content types and required fields. Messages are stored in an in-memory state object, which persists across requests within the sandbox. The GET endpoint filters messages by an index parameter, marks messages from the requesting user with a `me` flag, and returns a JSON response with the last message index and the filtered message list, using the Underscore.js library (`_`) for array filtering and mapping operations.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 660bf021ec250dfb10016d384d524bd7

This example shows a real-time chat application where users exchange messages through a Node.js server. The visualization tracks message flow and user activity using a force-directed graph rendered with D3.js’s `d3.forceSimulation` for node positioning and link physics. Each user appears as a node, with edges connecting them to messages they send, while color and size encode online status and message frequency. The code uses Socket.IO for live data updates and D3’s `transition.attrTween` to animate new nodes and links smoothly as events arrive, making the conversation pattern immediately visible.

FFrankieFabuloso
59% match
Loading thumbnail…

Gist 05471e1965de232f4434a8624c8949dc

This example demonstrates a minimal Express.js server that serves player data from a SQLite database, exposing endpoints for retrieving all players or looking up a single player by email. The backend uses `express`, `body-parser`, and the `sqlite3` library, with an async utility function (`getPlayers` or `getPlayerByEmail`) handling database queries. Although no charting or visualization library is present, the code illustrates a typical API structure for feeding data to a front-end visualization. The root route returns a plain JSON message, while `/players` and `/playerByEmail` respond with JSON arrays or objects, showing how raw data would be delivered for subsequent graphical rendering.

WWill Carter
52% match
Loading thumbnail…

Gist 360936

This example demonstrates a Tumblr API client in Ruby, showing how to fetch and model blog posts through a `Post` class that wraps raw post data in a `Hashie::Mash`. The code reveals the workflow of querying the Tumblr API via HTTParty, with support for pagination, post-type filtering, and direct lookup by ID. The visualization highlights the library’s role as an interface layer, not a rendering tool, as it contains no charting or drawing logic—instead, it focuses on data retrieval and object mapping. The example is purely code-based, with no visual output, emphasizing the API’s data-access patterns rather than graphical representation.

DDylanFM
51% match
Loading thumbnail…

Sandbox

This sandbox demonstrates basic data manipulation and sorting using JavaScript and D3. It defines a custom range function to generate an array of numbers, then maps those numbers into objects with number and doubled values. The example also sorts an array of key-value entries alphabetically by their keys using the D3 `ascending` comparator. All results are logged to the console, with the page itself rendering only a large static message via CSS.

Ttebanieo
51% match
Loading thumbnail…

Gist ca8ce8dbd8dbba7b501860f3d569f019

This example demonstrates a lightweight Express server that acts as a CORS proxy for a joke API, enabling browser-based requests to bypass cross-origin restrictions. The code uses the `express` and `request` libraries to define a route, `/jokes/random`, which forwards requests to `https://joke-api-strict-cors.appspot.com/jokes/random` and relays the JSON response back to the client. A middleware sets the `Access-Control-Allow-Origin` header to `*`, allowing any frontend to access the proxied data. The server listens on a configurable port, defaulting to 3000, and handles errors by returning a JSON error object. This setup illustrates a simple server-side solution for enabling client-side data fetching from a restricted external source.

115Dkatz
51% match
Loading thumbnail…

Getting started with spina pro message inbox.

This example demonstrates how to set up a message inbox for the Spina Pro CMS, showing a complete workflow for generating a message object and building a submission form. It uses Rails generators and Spina’s `Spina::Pro::Message` base class to define fields like `first_name`, `last_name`, and `email`, while a custom `SampleMessagesController` handles POST requests with Turbo Streams for form updates. The code relies on the `invisible_captcha` gem for spam protection and the `OOPSpam` API for spam scoring. A theme’s contact page embeds the form via a turbo frame, and routes are explicitly drawn under `Spina::Engine.routes.draw` to point to the controller’s `create` action.

CCaged
50% match
Loading thumbnail…

Sample RestXQ

This example demonstrates how to route HTTP requests and return XML responses using the RESTXQ API in BaseX. It defines multiple endpoint paths, including dynamic segments like `hello/{$who}` and `post/{$post}`, alongside static routes for the root and about pages. A custom error handler returns a 404 status with an HTML page when a requested path does not match any defined route. The code imports a separate model module that provides a `say-hello` function, which is called by the hello endpoint to generate XML output.

CCliffordAnderson
50% match
Loading thumbnail…

Gist 6b70052296ccf0ebf338143509429d64

This example simulates a simplified Facebook-like social network in Ruby, using a `User` class to model profiles, friendships, and wall posts. The code defines methods for adding friends and posting content to another user’s wall, checking friendship status before allowing a post, and initializing two user objects with sample data. It uses the `pry` debugging library via `binding.pry` to pause execution and allow interactive inspection of the state, with no graphical output or external visualization library.

JJastor11
50% match