Tree

Simple trees for ActiveRecord

Ancestry tree view in ActiveAdmin resource

A GeoTree is a variant of a k-d tree, and stores data points that have a latitude and longitude, a unique integer identifier, and an optional 'weight' (e.g., the size of a city). GeoTrees are disk-based data structures and can store a very large number of points efficiently. If desired, for smaller data sets, memory-only trees can be constructed instead. The gem includes MultiTree, a GeoTree variant that supports queries at multiple levels of detail. For example, when focusing on a small region it can return points that would be omitted when querying a much larger region.

generate plain css tree structure

Drop Zone is a solution to the problem of restricted sales in censored markets. The proposal is for the design of a protocol and reference client that encodes the location and a brief description of a good onto The Blockchain. Those wishing to purchase the good can search for items within a user-requested radius. Sellers list a good as available within a geographic region, subject to some degree of precision, for the purpose of obfuscating their precise location. Goods are announced next to an expiration, a hashtag, and if space permits, a description. Once a buyer finds a good in a defined relative proximity, a secure communication channel is opened between the parties on the Bitcoin test network ("testnet"). Once negotiations are complete, the buyer sends payment to the seller via the address listed on the Bitcoin mainnet. This spend action establishes reputation for the buyer, and potentially for the seller. Once paid, the seller is to furnish the exact GPS coordinates of the good to the buyer (alongside a small note such as "Check in the crevice of the tree"). When the buyer successfully picks up the item at the specified location, the buyer then issues a receipt with a note by spending flake to the address of the original post. In this way, sellers receive a reputation score. The solution is akin to that of Craigslist.org or Uber, but is distributed and as such provides nearly risk-free terms to contraband sellers, and drastically reduced risk to contraband buyers.

CQL Parser, with serialization from cql node tree to cql, xcql, and solr query

Quick #rebuild! method implementation for closure_tree on PostgreSQL.

An Acts As Tree like implementation for MongoMapper based on mongo_mapper_acts_as_tree

Sort Tree or List Structures by Drag n Drop

Kaitai Struct is a declarative language used for describe various binary data structures, laid out in files or in memory: i.e. binary file formats, network stream packet formats, etc. The main idea is that a particular format is described in Kaitai Struct language (.ksy file) and then can be compiled with ksc into source files in one of the supported programming languages. These modules will include a generated code for a parser that can read described data structure from a file / stream and give access to it in a nice, easy-to-comprehend API. This package is a visualizer tool for .ksy files. Given a particular binary file and .ksy file(s) that describe its format, it can visualize internal data structures in a tree form and a multi-level highlight hex viewer.

This library uses the output of the ps command to creaste process tree data structure for the current host.

This Gem eagerly loads trees by indexing the nodes of the tree. The number of queries needed for loading a tree is N, Where N is the number of different models(ActiveRecords) in the tree. Each inner object in the tree have an index node instance that is connecting it to the root. When the root of the tree is loaded, only the objects that are in the tree are fetched(Pruning). The index nodes are created when the root element is saved and stored in the IndexNode model.

This package contains a simple wrapper for the TreeTagger, a POS tagger based on decision trees and developed by Helmut Schmid at IMS in Stuttgart, Germany. You should have the TreeTagger with all library files installed on your machine in order to use this wrapper.

Filter arbitrary data trees with a concise query language.

A binary decision tree useful for brackets of single elimination tournaments.

ruby-radix is an implementation of a radix tree data structure for the storage and retrieval of IPv4 and IPv6 network prefixes.

A refinements for Hash to use it as a tree.

svn_wc_tree provides an Web Application Front End GUI to a working copy of an remote SVN Repository.

This gem serves a tool for parsing a document written in ZenML, an alternative new syntax for XML, to an XML node tree. This also contains some utility classes to transform XML documents.

A jekyll plugin for building hierarchial navigation trees from pages.

Command line app and library code for Iroki, a phylogenetic tree customization program.

monos - monorepo / mono source tree tools and (startup) scripts

acts_as_better_tree is great for anyone who needs a fast tree capable of handling millions of nodes without slowing down on writes like nestedset or on reads like a standard tree.

Produces a clean output for Ripper, making the output tree usable and readable.

This is a wrapper library for managing ActiveAdmin's menu structure in a simple yaml format, and automatically setting the priority and parent.

Guard::CtagsComposer uses ctags utility and generates 2 files: tags -- with tags generated from project's source tree and vendor.tags -- with tags generated from vendor folder.

Allows ActiveRecord Models to be easily structured as a tree

Pegarus is, broadly, an implementation of LPEG on Rubinius. LPEG implements a Parsing Expression Grammar using a parsing machine rather than the Packrat algorithm. (See "A Text Pattern-Matching Tool based on Parsing Expression Grammars" by Roberto Ierusalimschy.) Pegarus actually implements an abstract syntax tree (AST) for the PEG. There are various options to execute the AST against a subject string. One option is a simple AST-walking evaluator. A second option is an implementation of the LPEG parsing machine. A third option is a compiler that targets Rubinius bytecode.

This is a filetree, written with Backbone. It is meant to be tree that will update your file nodes live and sort them when the node state is changed.

Mappum is the tree to tree (object, bean etc.) mapping DSL.

Decision trees that request facts as needed

== FEATURES/PROBLEMS: Chirp is a DSL for manipulating file systems. In the same way that rake is aimed at making system buildig easy, chirp is designed to make doing things to entire file systems easy. Chirp is still very much in development and you should be very careful with it: since chirp does operate on whole directory trees, it is capable of doing a lot of damage. == SYNOPSIS: FIX (code sample of usage)

Command line app that produces the MD5 hash of all files in a set of folders

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

A binary tree of one-time singatures known as a merkle tree. Often used in distributed systems such as Git, Cassandra or Bitcoin for efficiently summarizing sets of data.

A mixin to help you generate tree graph

Jumoku provides you with tree behaviors to mixin and tree classes to inherit from. Raw tree, common binary trees, custom trees...

ACLS is a library for autoloading Ruby source files in one or more directory trees.

Drag&Drop GUI helper for awesome_nested_set gem. Sortable tree view helper

This gem implements a rooted, ordered tree, with a focus on easy iteration over nodes and access to basic tree properties. Moved to ---> "rooted".

scorm2004-manifest is a Ruby gem that provides a manifest file parser for SCORM 2004 4th edition. It parses and validates the manifest file according to SCORM 2004 4th Edition Content Aggregation Model (CAM) Version 1.1. After parsing and validating, it builds an object tree that captures XML's hierarchical structure.

Organise ActiveRecord model into a tree structure

Builds a tree by linking callable nodes. The nodes that match the conditions are called in a chain from the root node to the leaf node. These are like nested `if` or `case` expressions.

The abstract syntax tree for ruby mappers

another ruby wrapper for Stuttgarter Tree Tagger

Caplets modernizes your capistrano deployments. At its most basic, it provides a fast, efficient git-based deployment without copying release trees or symlink tomfoolery. In addition, it includes modules for common tasks such as writing config files and crontabs, working with bundler, and using a networked filesystem.

gem version of acts_as_tree with some other features and tests

With treeoid, you can create tree-style hierarchies for Mongoid classes. Just "include Treeoid" and you're ready to roll. You get a "parent" accessor, a "children" array, plus a scope called "hierarchically" that spits everything out in hierarchical order - perfect for front end rendering.

Use this acts_as extension if you want to model a tree structure by providing a parent association and a children association.

Manage trees of keys