Skip to main content
100%

Gist dd282dd3104915ca1d7bbe96b2294fe1

✓ Published0🌍 Public
Aalper
Last edited Sep 3, 2018
Created on Sep 3, 2018

This example demonstrates a Swift decoding strategy for a trending GIFs API response, using a custom `Trending` initializer that iterates through a nested unkeyed container to parse each `Gif` object. It shows how to skip malformed entries by attempting to decode each item as `Gif` first, and falling back to `AnyCodable` to log and discard problematic records while preserving the valid ones. The code relies on `Decoder`, `KeyedDecodingContainer`, and `UnkeyedDecodingContainer` APIs to filter the data array, ensuring the resulting `data` property contains only successfully decoded GIFs.

AI-generated description

Similar vizzes

Loading thumbnail…

Swift Structs to Decode Gists API

This example shows Swift structs that decode the GitHub Gists API response for a user's public gists, modeling the `Gist`, `File`, and `Owner` objects with their nested properties. It uses the `Codable` protocol and a `JSONDecoder` with an ISO 8601 date strategy to parse the JSON from `https://api.github.com/users/kevingutowski/gists`, mapping snake_case API fields like `forks_url` to camelCase Swift properties via `CodingKeys`. The code also demonstrates decoding the dynamic `files` dictionary using `GenericCodingKeys` to handle arbitrary filenames.

KKevinGutowski
68% match
Loading thumbnail…

Trying to figure out how to encode response into swift objects

This example shows how to map a GitHub Gist API response into Swift model objects. It defines `Gist` and `File` structs that conform to the `Codable` protocol, with a custom `CodingKeys` enum to map the JSON key `raw_url` to the `rawURL` property. The provided `response.json` demonstrates the nested structure of the files dictionary, which the code flattens into an array of `File` objects. The example uses `JSONDecoder` to parse the data into these strongly typed Swift types.

KKevinGutowski
65% match
Loading thumbnail…

Elm HTTP Example w/ability to change input

This example demonstrates an Elm application that fetches and displays random GIFs from the Giphy API, with a text input allowing users to change the search topic. The interface shows a button to request another GIF and an image element that updates with each new result. The code uses Elm’s `Http` module with a `Json.Decode` pipeline to extract the `image_url` field from the API’s JSON response, and Bootstrap CDN styles via the `Bootstrap.CDN` and `Bootstrap.Grid` modules. The application’s architecture follows Elm’s standard Model-Update-View pattern, managing state through messages like `MorePlease` and `Change`.

CCliffordAnderson
53% match
Loading thumbnail…

Decode JSON with Dynamic Keys using Decodable

This example demonstrates how to decode a JSON object with dynamic keys using Swift’s `Decodable` protocol, mapping student IDs like "S001" to an array of `Student` objects. The `School` struct implements a custom `init(from:)` decoder, which uses a `nestedContainer(keyedBy: GenericCodingKeys.self)` to iterate over all keys in the "students" dictionary and decode each entry. `GenericCodingKeys` is a custom `CodingKey` type that accepts any string value, while Foundation’s `JSONDecoder` parses the embedded sample JSON data. The code prints the first decoded student after processing.

KKevinGutowski
52% match
Loading thumbnail…

Gist 0591ab79900b3fe44d8b1560e3c35f40

This example demonstrates a workflow for converting animated WebP files into GIF format. The script uses `iwatch` to monitor a directory for new WebP files, then extracts each frame with `webpmux` and converts the frames to PNG using ImageMagick’s `convert`. Finally, it assembles the PNG sequence into a GIF with `ffmpeg`, while cleaning up temporary files. The code relies on the WebP tools API, ImageMagick, and FFmpeg’s glob pattern to handle the batch conversion, showing a practical pipeline for format transformation.

UUtopiah
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
52% match
Loading thumbnail…

Gist of a stolen gist

This example visualizes the structure of a “stolen gist” — a curated piracy resource list — as an interactive hierarchical map. It shows the document’s nested sections and subsections as collapsible, color-coded nodes, revealing the organization of topics like torrenting, Usenet, and streaming. Built with React, it uses a custom recursive rendering of the markdown headings, with d3.forceSimulation to position nodes and CSS transitions for expand/collapse animations, sourced directly from the raw gist file.

IIoTeacher
51% match
Loading thumbnail…

Gist Scraping Script Prototype

This prototype demonstrates a data migration workflow that iterates through every file within each GitHub Gist associated with a given username. The visualization shows the raw JSON structure of a Gist, including its metadata and file contents. The application uses the Octokit library to fetch Gist data from the GitHub API and displays example file entries such as `App.js`, `data.csv`, and `package.json`. This proof of concept is built with React and includes placeholder functions for generating identifiers and converting timestamps, though the actual migration logic is not yet implemented.

CCurran Kelleher
51% match