Tree

Provides a generic tree data structure with ability to store keyed node elements in the tree. The implementation mixes in the Enumerable module.

A Parsing Expression Grammar (PEG) Parser generator DSL for Ruby

A RBTree is a sorted associative collection that is implemented with a Red-Black Tree. It maps keys to values like a Hash, but maintains its elements in ascending key order. The interface is the almost identical to that of Hash.

Easily and efficiently make your ActiveRecord model support hierarchies

A gem that adds simple support for organizing ActiveRecord models into parent–children relationships.

Resources and tools for developers to integrate Braintree's global payments platform.

RubyTree is a Ruby implementation of the generic tree data structure. It provides simple APIs to store named nodes, and to access, modify, and traverse the tree. The data model is node-centric, where nodes in the tree are the primary structural elements. It supports all common tree-traversal methods (pre-order, post-order, and breadth first). RubyTree mixes in the Enumerable and Comparable modules and behaves like a standard Ruby collection (iteration, comparison, etc.). RubyTree also includes a binary tree implementation, which provides in-order node traversal besides the other methods. RubyTree can import from and export to JSON, and supports Ruby’s object marshaling.

A parser based on ripper

A tree structure for Mongoid documents using the materialized path pattern

A Ruby Gem implementation of Bitcoin HD Wallets

Drag&Drop GUI for awesom_nested_set. Render Tree Helper. Very fast! Ready for Rails 4

StreetAddress::US allows you to send any string to parse and if the string is a US address returns an object of the address broken into it's substituent parts. A port of Geo::StreetAddress::US by Schuyler D. Erle and Tim Bunce.

AVL tree, Red black tree and Lock-free Red black tree in Ruby

Hirb provides a mini view framework for console applications and uses it to improve ripl(irb)'s default inspect output. Given an object or array of objects, hirb renders a view based on the object's class and/or ancestry. Hirb offers reusable views in the form of helper classes. The two main helpers, Hirb::Helpers::Table and Hirb::Helpers::Tree, provide several options for generating ascii tables and trees. Using Hirb::Helpers::AutoTable, hirb has useful default views for at least ten popular database gems i.e. Rails' ActiveRecord::Base. Other than views, hirb offers a smart pager and a console menu. The smart pager only pages when the output exceeds the current screen size. The menu is used in conjunction with tables to offer two dimensional menus.

ID3-based implementation of the M.L. Decision Tree algorithm

A kdtree is a data structure that makes it possible to quickly solve the nearest neighbor problem. This is a native 2d kdtree suitable for production use with millions of points.

A stackable dynamic tree based Rack router.

Ancestry allows the records of a ActiveRecord model to be organized in a tree structure, using the materialized path pattern. It exposes the standard relations (ancestors, parent, root, children, siblings, descendants) and allows them to be fetched in a single query. Additional features include named scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.

Print directory or structured data in a tree like format.

Supervisors, Supervision Groups, and Supervision Trees for Celluloid.

Heap, Priority Queue, Deque, Stack, Queue, Red-Black Trees, Splay Trees, sorting algorithms, and more

ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers. As an example: def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end becomes: [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]

Routing tree web toolkit

A library for working with Abstract Syntax Trees.

A fake Braintree that you can run integration tests against

A modular scale is a list of values that share the same relationship. These values are often used to size type and create a sense of harmony in a design. Proportions within modular scales are all around us from the spacing of the joints on our fingers to branches on trees. These natural proportions have been used since the time of the ancient Greeks in architecture and design and can be a tremendously helpful tool to leverage for web designers.

A RBTree is a sorted associative collection that is implemented with a Red-Black Tree. It maps keys to values like a Hash, but maintains its elements in ascending key order. The interface is the almost identical to that of Hash. This is a fork of the original gem that fixes various bugs on Ruby 2.3+.

Organize ActiveRecord model into a tree structure using PostgreSQL LTree

SortableTree provides sorting of lists and hierarchies from ActiveAdmin index views.

The Ruby Language Toolkit provides classes for creating context-free grammars, lexers, parsers, and abstract syntax trees.

Treequel is an LDAP toolkit for Ruby. It is intended to allow quick, easy access to LDAP directories in a manner consistent with LDAP's hierarchical, free-form nature. It's inspired by and modeled after [Sequel][sequel], a kick-ass database library. For more information on how to use it, check out the [manual](manual/index_md.html).

A set of feature-rich extendible Netzke components (such as Grid, Tree, Form, Window) and component extensions which can be used as building blocks for your apps

Guard::CtagsBundler uses ctags utility and generates 2 files: tags -- with tags generated from project's source tree and gems.tags -- with tags generated from rubygems from project's bundle.

Tokyo Cabinet is a library of routines for managing a database. The database is a simple data file containing records, each is a pair of a key and a value. Every key and value is serial bytes with variable length. Both binary data and character string can be used as a key and a value. There is neither concept of data tables nor data types. Records are organized in hash table, B+ tree, or fixed-length array.

Used for generated API clients

DataMapper plugin allowing the creation of tree structures from data models

The RKelly library will parse JavaScript and return a parse tree.

Rumale is a machine learning library in Ruby. Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python. Rumale supports Support Vector Machine, Logistic Regression, Ridge, Lasso, Multi-layer Perceptron, Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest, K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering, Mutidimensional Scaling, t-SNE, Fisher Discriminant Analysis, Neighbourhood Component Analysis, Principal Component Analysis, Non-negative Matrix Factorization, and many other algorithms.

Organizes ActiveRecord models into a tree/hierarchy using a materialized path implementation based around PostgreSQL's ltree datatype. ltree's operators ensure that queries are fast and easily understood.

Recursively traverse trees using a single SQL query

Ruby & JRuby gem with a fast k-d tree C implementation using FFI bindings with support for latitude/longitude and geo distance range search

Provides automatic deadlock retry and logging functionality for ActiveRecord and MySQL

jsTree is jquery plugin, that provides interactive trees. It is absolutely free, open source and distributed under the MIT license.

CompTree is a parallel computation tree structure based upon concepts from pure functional programming.

Provides ActiveModel compatible wrappers for Braintree models and more.

An official library for the SmartyStreets APIs

Fetch, Upload, Organize, and Distribute Software Packages

Organise Mongoid model into a tree structure

A Ruby implementation of the Centered Interval Tree data structure. See also: http://en.wikipedia.org/wiki/Interval_tree

This gem facilitates modeling a test suite that is written in Gherkin (e.g. Cucumber, SpecFlow, Lettuce, etc.). It does this by providing an abstraction layer on top of the Abstract Syntax Tree that the 'cucumber-gherkin' gem generates when parsing features, as well as providing models for feature files and directories in order to be able to have a fully traversable model tree of a test suite's structure. These models can then be analyzed or manipulated more easily than the underlying AST layer.