Tree

Ruby micro framework for easy create ruby applications (daemons, EventMachine-apps, db-apps, cli...). Features: bundler, environments, activesupport, rails dirs tree. Fast loading and low memory using.

Rumale::Ensemble provides ensemble learning algorithms, such as AdaBoost, Gradient Tree Boosting, and Random Forest, with Rumale interface.

Uses the closure tree pattern with a scope field to maintain separate hierarchies

Syntax tree generator made with Ruby

Peachy is an XML slurper that sits on top of existing XML parsers. It dynamically creates object-trees for simple integration of XML data sources.

Encode Trees in RDBMS using nested interval method for powerful querying and speedy inserts.

RSence is a different and unique development model and software frameworks designed first-hand for real-time web applications. RSence consists of separate, but tigtly integrated data- and user interface frameworks. RSence could be classified as a thin server - thick client system. Applications and submobules are installed as indepenent plugin bundles into the plugins folder of a RSence environment, which in itself is a self-contained bundle. A big part of RSence itself is implemented as shared plugin bundles. The user interface framework of RSence is implemented in high-level user interface widget classes. The widget classes share a common foundation API and access the browser's native API's using an abstracted event- and element layer, which provides exceptional cross-browser compatibility. The data framework of RSence is a event-driven system, which synchronized shared values between the client and server. It's like a realtime bidirectional form-submission engine that handles data changes intelligently. On the client, changed values trigger events on user interface widgets. On the server, changed values trigger events on value responder methods of server plugin modules. It doesn't matter if the change originates on client or server, it's all synchronized and propagated automatically. The server framework is implemented as a high-level, modular data-event-driven system, which handles delegation of tasks impossible to implement using a client-only approach. Client sessions are selectively connected to other client sessions and legacy back-ends via the server by using the data framework. The client is written in Javascript and the server is written in Ruby. The client also supports CoffeeScript for custom logic. In many cases, no custom client logic is needed; the user interfaces can be defined in tree-like data models. By default, the models are parsed from YAML files, and other structured data formats are possible, including XML, JSON, databases or any custom logic capable of producing similar objects. The server can connect to custom environments and legacy backends accessible on the server, including software written in other languages.

Collection of Capistrano recipes

Selection list management and form and view helpers. Manages one table to hold all selections items/dropdown lists ( tree ). Dynamic lookup to find parent or children ( eg. Selection.priorities ). Form helper to display lists ( eg. f.selections :priorities ). Handling of archived items ( displaying if selected only ).

DeepTree simplifies fetching deeply nested nodes in Ruby hashes.

A gem for ztree jquery plugin.

This is a Ruby library for building trees representing HTML structure.

A robust and customizable Ruby gem for creating Behavior Trees.

Pure ruby implementation of a btree as described in Introduction to Algorithms by Cormen, Leiserson, Rivest and Stein, Chapter 18.

Synchrotron monitors a local directory tree and performs nearly instantaneous one-way synchronization of changes to a remote directory using rsync.

A basic tree structure.

Arboreal is yet another extension to ActiveRecord to support tree-shaped data structures. Internally, Arboreal maintains a computed "ancestry_string" column, which caches the path from the root of a tree to each node, allowing efficient retrieval of both ancestors and descendants. Arboreal surfaces relationships within the tree like "children", "ancestors", "descendants", and "siblings" as scopes, so that additional filtering/pagination can be performed.

Print TracePoint(:b_call, :b_return, :c_call, :c_return, :call, :return, :class, :end, :thread_begin, :thread_end) in tree view, to console or html

A Ruby port of the Android implementation of Java's java.util.TreeMap class. This is an AVL tree based implementation of Java's java.util.TreeMap structure. It implements Java's java.util.NavigableMap interface. The reference implementation is at https://android.googlesource.com/platform/libcore.git/+/android-6.0.1_r32/luni/src/main/java/java/util/TreeMap.java

ActionTree is a DRY request router. It provides a compact DSL for defining actions and mapping requests to invoke them.

http://wikipedia.com/wiki/Interval_tree

A Ruby port of the Android implementation of Java's java.util.TreeMap class. This is an AVL tree based implementation of Java's java.util.TreeMap structure. It implements Java's java.util.NavigableMap interface. The reference implementation is at https://android.googlesource.com/platform/libcore.git/+/android-6.0.1_r32/luni/src/main/java/java/util/TreeMap.java

A Ruby GEDCOM text file parser and producer, that produces a tree of objects from each of the GEDCOM file types and subtypes. Understands the full GEDCOM 5.5 grammar, and will handle unknown tags hierarchies as a Note class.

Tool that allows to generate Objective-C and Swift dependency tree from object files For usages examples run: objc_dependency_tree_generator -h

Format your RSpec dots like a christmas tree!

Daedalus is a build system based on years of attempting to build Rubinus with a collection of Rake tasks. Rubinius is a complex system. It has dependencies on external C libraries (some of which are vendored), internal C/C++ libraries, Ruby C-extensions, and compiled Ruby code. The Rubinius bytecode compiler is written in Ruby, so we have to bootstrap compiling it. Rake fails at this task because there is no way to manage multiple, independent dependency trees without subprocessing another Rake process. This results in unreasonable and unmanagable complexity.

Data structures (lists, stacks, trees, heaps, graphs..) in pure Ruby.

Calculates the minimum set of operations that transform one tree into another.

Htree provides a tree data structure which represent HTML and XML data

RubyMacros is a lisp-like macro pre-processor for Ruby. More than just a purely textual substitution scheme, RubyMacros can manipulate and morph Ruby parse trees (in the form of RedParse Nodes) at parse time in just about any way you see fit. Macros are programmed in ruby itself. And since parse trees are represented in RedParse format, they're easier to use (programatically) and more object- oriented than other available ruby parsetree formats. (RedParse Node format is actually designed to be straightforward to use and to represent the structure of ruby source code very closely.)

Routing tree web framework, inspired by Sinatra and Cuba

Naive implementation of Radix Tree for Ruby

Extracts skills, strains, profession, and requirement trees into JSON

Binary Tree based bracketing system

An extension of ancestry gem to show a tree view

newick-ruby provides routines for parsing newick-format phylogenetic trees.

Port of classic Rails ActsAsTree for MongoMapper

Port of the old, venerable ActsAsTree with a bit of a twist

Sets up a directory tree for coding projects based on customizable templates

A parser to generate a tree structure from a logical query string using treetop.

LittleBoxes is a light library that provides a dependency tree that represents your application configuration. It automatically configures your dependencies and lazy-loads by default.

A simple library to create and manage basic tree-esque structures.

Capistrano tasks used for common Youth Tree deployments.

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

Minimal CMS Rails Engine or more likelly a "static" pages manager. Pages can be created, deleted, edited and arranged into sections using a file tree like interface courtesy of jQuery tree (http://jstree.com). It attempts to be as minimal, flexible and unobtrusive as posible leaving a lot of functionality like templating languages and authentication/authorization for page creation, deletion and editing for the Rails app developer to implement. (It now works after premature release)

hax0r vim script to give you a tree explorer

Binary streamable bit-effective protocol to effectively store object tree hierarchies

Parses a usable tree from ASCII art.

A screen + vim IDE setup for editing a Rails tree

like tree command for Ruby ancestors.