Data Structures

Primitive JSON data store. Key-value structure with namespaces.

A schema language / type system / validation framework, for semi-structured data and for data in dynamic languages

Data structure for quick item lookup via indexes.

factbook-readers - turn thee world factbook country profile pages into open structured data e.g JSON

Provides higher level data structures in Ruby using standard Redis commands. Also provides basic object mapping for pre-existing types.

RedisRpc is the easiest to use RPC library in the world. (No small claim!). This version is a repackage that only has Ruby implementation. Redis is a powerful in-memory data structure server that is useful for building fast distributed systems. Redis implements message queue functionality with its use of list data structures and the `LPOP`, `BLPOP`, and `RPUSH` commands. RedisRpc implements a lightweight RPC mechanism using Redis message queues to temporarily hold RPC request and response messages. These messages are encoded as JSON strings for portability. Many other RPC mechanisms are either programming language specific (e.g. Java RMI) or require boiler-plate code for explicit typing (e.g. Thrift). RedisRpc was designed to be extremely easy to use by eliminating boiler-plate code while also being programming language neutral. High performance was not an initial goal of RedisRpc and other RPC libraries are likely to have better performance. Instead, RedisRpc has better programmer performance; it lets you get something working immediately.

Reins is a ruby gem that automates the creation of javascript controllers that match the structure of your rails controllers. This includes passing custom data to the JS controllers from the server.

sportdb-structs - sport data structures for matches, scores, leagues, seasons, rounds, groups, teams, clubs and more

FatTable is a gem that treats tables as a data type. It provides methods for constructing tables from a variety of sources, building them row-by-row, extracting rows, columns, and cells, and performing aggregate operations on columns. It also provides as set of SQL-esque methods for manipulating table objects: select for filtering by columns or for creating new columns, where for filtering by rows, order_by for sorting rows, distinct for eliminating duplicate rows, group_by for aggregating multiple rows into single rows and applying column aggregate methods to ungrouped columns, a collection of join methods for combining tables, and more. Furthermore, FatTable provides methods for formatting tables and producing output that targets various output media: text, ANSI terminals, ruby data structures, LaTeX tables, Emacs org-mode tables, and more. The formatting methods can specify cell formatting in a way that is uniform across all the output methods and can also decorate the output with any number of footers, including group footers. FatTable applies formatting directives to the extent they makes sense for the output medium and treats other formatting directives as no-ops. FatTable can be used to perform operations on data that are naturally best conceived of as tables, which in my experience is quite often. It can also serve as a foundation for providing reporting functions where flexibility about the output medium can be quite useful. Finally FatTable can be used within Emacs org-mode files in code blocks targeting the Ruby language. Org mode tables are presented to a ruby code block as an array of arrays, so FatTable can read them in with its .from_aoa constructor. A FatTable table can output as an array of arrays with its .to_aoa output function and will be rendered in an org-mode buffer as an org-table, ready for processing by other code blocks.

An unofficial ruby library for quickly parsing 23andme raw data files into a plain Ruby structures for quick processing and analysis.

A very specific and opinionated web framework to traverse a graph data structure

A C extension implementation of a d-ary heap data structure, suitable for use in e.g. priority queues or Djikstra's algorithm.

An API engine for Rails. Structure of the API is opinionated and designed to directly interface with ember-data.

This library offers general purpose higher-level data structures that focus on Hash manipulation.

Maps data to another structure through a mapping

Ricordami ("Remember me" in Italian) is an attempt at providing a simple interface to build Ruby objects that can be validated, persisted and queried in a Redis data structure server.

A doc converter to another doc. Doc is a data structure like a hash, array or a simple string

Ruby 1.8/1.9 binding of Tx, a library for a compact trie data structure

RubyLogParser enables the output from Microsoft's Log Parser to be processed by Ruby data structures (arrays and hashes).

Plain old Ruby for generating primitive data structures from object graphs.

This is a data structure to represent and manage k-trees, primarily created for use in RubyNEAT, but may see other possible applications. The goal here is to be roebust in the creation of your k-tree, to allow you to prune during creation, since, especially for higher-dimensional trees, the number of leaf node can become very large. So a parent will have children nodes created down to the desired resolution, and immediately after the creation of the children, will check to see if there's enough variance among the children to keep them. If not, they are pruned immediately.

An unofficial ruby wrapper for the Giantbomb API (http://api.giantbomb.com). An API that provides structured data about videogames.

A crit bit tree, also known as a Binary Patricia Trie is a trie (https://en.wikipedia.org/wiki/Trie), also called digital tree and sometimes radix tree or prefix tree (as they can be searched by prefixes), is an ordered tree data structure that is used to store a dynamic set or associative array where the keys are usually strings. Unlike a binary search tree, no node in the tree stores the key associated with that node; instead, its position in the tree defines the key with which it is associated. All the descendants of a node have a common prefix of the string associated with that node, and the root is associated with the empty string. Values are normally not associated with every node, only with leaves and some inner nodes that correspond to keys of interest. For the space-optimized presentation of prefix tree, see compact prefix tree. This code is a wrapper around https://github.com/jfager/functional-critbit. For more information go to: http://cr.yp.to/critbit.html

This gem include api wrapper, response structure and dummy data.

Sketch data structures for Ruby

Stores data in a B+tree structure

sport - sport data structures for matches, scores, leagues, seasons, rounds, groups, teams, clubs and more

hash_key_transformer makes it easy to deeply transform a JSON-like data structure from one style of key to another (for example, from camelCase to snake_case).

Maps values from hashes with different structures and/or key names. Ideal for normalizing arbitrary data to be consumed by your applications, or to prepare your data for different display formats (ie. json). Tiny module that allows you to easily adapt from one hash structure to another with a simple declarative DSL.

A lightweight solution for creating and managing tree data structures

MongoidNestedFields allows you to handle complex data structures inside one field in MongoDB. It also validates whole object graph on field validation

RedisRds provides Ruby interfaces for data structures like String or Hash stored in Redis.

lector parses Ruby data into Ruby data structures.

Gem minitest_log uses Minitest, adding structured logging, data explication, and verdicts.

Module that defines a tree data structure based on a path.

gdstruct - GDS (General Data Structure), a universal, composable data structure, used to store any kind of data. Typical usage is the definition of configurations, specifications and data sets. The GDS language is a special DSL (domain specific language) for defining general data structures. It uses a succinct, indentation-sensitive syntax which makes data representation clear and readable.

sync_issues is a ruby gem to that allows the easy creation and synchronization of issues on GitHub with structured local data.

Symmetrical transformation between structured data and JSON

Tools for working with nested data structures in Ruby

Invertible data filter/mutator on data structures

convert network switch and router config files to structured data

Simple, easy to use data structure classes and Gosu widgets

rQRCode is a library for encoding QR Codes. The simple interface allows you to create QR Code data structures ready to be displayed in the way you choose.

Smartly check whether a given email/domain belongs to a free or disposable mail provider. There are hundreds of lists available in Github repositories or Gists that list various free and disposable email providers. This gem downloads a bunch of these scripts (pre-configured URLs) and parses them to count votes against each domain in the list. We, then, create a Trie structure to efficiently query this data with a given domain or email. For each query, you get back a number specifying how many sources are claiming that the domain is a free or disposable email provider.

Bean Sprout is a library that provides a set of data structures to support extraction and exchanging of general book-keeping information between different systems.

NTable provides a convenient data structure for storing n-dimensional tabular data. It works with zero-dimensional scalar values, arrays, tables, and any arbitrary-dimensional hypertables. Each dimension is described by an axis object. The "rows" in that dimension might be identified by numbers or names. You can perform slice operations across any dimension, as well as reductions and dimensional decomposition. Finally, serialization is provided via a custom JSON schema, as well as a simple "hash of hashes" or "array of arrays" approach.

Wrap your business logic into a common interface with enforced input, output and error data structures

A Deque is a queue type data structure that allows efficient insertion and deletion from both ends of the queue. This implementation wrapps the standard C++ structure of the same name.

It's a way to store data along with a git commit object that is less freeform than something like "Close gh-11" but more freeform than having to add extra data structures to the git commit object. It is also completely compatible for people wanting to read this metadata directly from an interface like git-log or github. This gem allows reading this data.

Dump table's structure and data between mysql servers and databases.