Hashing

Performance-oriented subclass of Hash which provides symbolized keys and method access

This gem simulates named-parameters in Ruby. It's a complement to the common Ruby idiom of using Hash args to emulate the use of named parameters.

Temporally Ordered IDs. Generate universally unique identifiers (UUID) that sort lexically in time order. Torid exists to solve the problem of generating UUIDs that when ordered lexically, they are also ordered temporally. I needed a way to generate ids for events that are entering a system with the following criteria: 1. Fast ID generation 2. No central coordinating server/system 3. No local storage 4. Library code, that is multiple apps on the same machine can use the same code and they will not generate duplicate ids 5. Eventually stored in a UUID field in a database. So 128bit ids are totally fine. The IDs that Torid generates are 128bit IDs made up of 2, 64bit parts. * 64bit microsecond level UNIX timestamp * 64bit hash of the system hostname, process id and a random value.

Embeds start and end byte offsets of JSON objects into generated Ruby hashes.

Optout helps you write code that will call exec() and system() like functions. It allows you to map hash keys to command line arguments and define validation rules that must be met before the command line options are created.

Convert an Array where Array.all? {|e| [OpenStruct,Hash,ActiveRecord::Base].any? { |type| e.kind_of?(type) }} to a Google spreadsheet

This gem adds a `to_hash` method to Nokogiri XML nodes into a Ruby hash. In the resulting hash, all keys are constants. This gem also picks up attributes, processing instructions and doctype declarations. The resulting Hash is wordy, but complete. As an added bonus, we include line numbers where possible.

Easily convert hashes to Ruby objects. Originally developed at www.onthebeach.co.uk.

NiceHash creates hashes following certain patterns so your testing will be much easier. Parse and filter JSON. You can easily generate all the hashes you want following the criteria you specify. Many other features coming to Hash class like the methods 'bury' or select_key, access the keys like methods: my_hash.my_key.other_key. You will be able to generate thousands of different hashes just declaring one and test easily APIs based on JSON for example. Perfect to be used in test data factories

hash-to-ostruct recursively transforms Hash to OpenStruct It supports: * hash of hashes * hash of arrays with hashes as elements

Define a set of fields and serialize them to a hash.

CommandSet is a user interface framework. Its focus is a DSL for defining commands, much like Rake or RSpec. A default readline based terminal interpreter (complete with context sensitive tab completion, and the amenities of readline: history editing, etc) is included. It could very well be adapted to interact with CGI or a GUI - both are planned. CommandSet has a lot of very nice features. First is the domain-specific language for defining commands and sets of commands. Those sets can further be neatly composed into larger interfaces, so that useful or standard commands can be resued. Optional application modes, much like Cisco's IOS, with a little bit more flexibility. Arguments have their own sub-language, that allows them to provide interface hints (like tab completion) as well as input validation. On the output side of things, CommandSet has a very flexible output capturing mechanism, which generates a tree of data as it's generated, even capturing writes to multiple places at once (even from multiple threads) and keeping everything straight. Methods that normally write to stdout are interposed and fed into the tree, so you can hack in existing scripts with minimal adjustment. The final output can be presented to the user in a number of formats, including contextual coloring and indentation, or even progress hashes. XML is also provided, although it needs some work. Templates are on the way. While you're developing your application, you might find the record and playback utilities useful. cmdset-record will start up with your defaults for your command set, and spit out an interaction script. Then you can replay the script against the live set with cmdset-playback. Great for ad hoc testing, usability surveys and general demos.

Parse *.gemspec file. Convert to Ruby Hash object.

Typed::Hash

Crypt3 is a ruby version of crypt(3), a salted one-way hashing of a password.

Implements a multi-level nested document, that notifies about changes, and some other related features

bloombroom has two bloom filter implementations, a standard filter for bounded key space and a continuous filter for unbounded keys (stream). also contains fast C/FFI FNV hashing and fast bit field and bit bucket field (multi bits).

Openstruct like access without all the headaches of Hash method overrides etc...

Very useful for configuration files, SymbolMatrix is a hash-like multidimentional Symbol-only class with ability to discover and load YAML data

Rumale::FeatureExtraction provides feature extraction methods, such as TF-IDF and feature hashing, with Rumale interface.

Ruby library to interact with in-memory hash database collections. Offers very little technical dependencies. In order to develop or run the tests for your application you just need ruby installed, run bundle install and you're good to go. No need to install and start your database, migrate, etc.

Like Factory Girl but for Hashes only

Inheritable Objects and Downward-Compositing Hashes and Arrays; Downward-Transforming Values coming soon.

Ruby 2.3 introduces the new Hash#dig method for safe extraction of a nested value. It is the equivalent of a safely repeated Hash#[] or Array#[]. #dig! on the other hand, is a repeated #fetch.

A small collection of useful hash extensions

Recursively convert your objects into nested hashes

Calculates the SHA256 tree hash of a file or string. It also includes a command line tool.

crypto-lite - cryptographic secure hash functions and public key signature algorithms made easy

Give a hash key, DigDeep will recursively search in the hash and return all values.

Command line tools for processing messages by constructing a pipeline of workers. AMQP and Unix pipes are used to construct the pipeline. Messages are simple Hashes (serialized as YAML) so they can hold any values and change throughout the processing.

resque-status is an extension to the resque queue system that provides simple trackable jobs. It provides a Resque::Plugins::Status::Hash class which can set/get the statuses of jobs and a Resque::Plugins::Status class that when included provides easily trackable/killable jobs.

Extends ActiveSupport's symbolize_keys to recursively symbolize keys at all levels in a Hash

Monkey patches Hash#fetch to also show the entire hash in the error

Now just a thin wrapper for cascading-configuration.

An ActiveSupport cache store that uses the C-based libmemcached client through Evan Weaver's Ruby/SWIG wrapper, memcached. libmemcached is fast, lightweight, and supports consistent hashing, non-blocking IO, and graceful server failover.

Configurable adds methods to declare class configurations. Configurations are inheritable, delegate to methods, and have hash-like access. Configurable constructs configs such that they easily map to config files, web forms, and the command line.

Invoke methods with a consistent Hash interface. Useful for metaprogramming.

A simple wrapper around the ENV hash that by default raises an error when value requested is not set.

rack-indifferent monkey patches Rack::Utils::KeySpaceConstrainedParams to make the hash it stores params in support indifferent access. So web frameworks that use rack-indifferent don't have to make a deep copy of the params to allow indifferent access to the params.

Blueprinter is a JSON Object Presenter for Ruby that takes business objects and breaksthem down into simple hashes and serializes them to JSON. It can be used in Rails in place of otherserializers (like JBuilder or ActiveModelSerializers). It is designed to be simple, direct, and performant.

Encodes and Decodes key-value hashes.

Parses a hash string of the format `'{ :a => "something" }'` into an actual ruby hash object `{ a: "something" }`. This is useful when you by mistake serialize hashes and save it in database column or a text file and you want to convert them back to hashes without the security issues of executing `eval(hash_string)`. By default only following classes are allowed to be deserialized: * TrueClass * FalseClass * NilClass * Numeric * String * Array * Hash A HashParser::BadHash exception is thrown if unserializable values are present.

gem for vertically formatted inspection of a Ruby Hash via an added instance method human_inspect()

Toolkit for working with Hashes

For example a hash like { "properties.age" => 3 } will be converted into { "properties" => {"age" => 3}}

Proxy-objects for making another object threadsafe by proxying calls through mutex and method_missing. Monitored array and hash where all methods are going through monitor. Threadsafe class for including into a class that extends another class in order to make it threadsafe.

Generate decks ready to be imported into Anki! Just pass an array of hashes and get back a string that you can save in a file and import directly into Anki.

Simple, beautiful error messages for Rails. Err_supply unpacks and rekeys the standard Rails error hash to make applying error messages to your views dead simple. Even better, because the library cures Rails' brain-damaged way of recording errors from nested resources/attributes, err_supply works with both simple and complex forms.

Computes Nilsimsa values. Nilsimsa is a distance based hash

GitStore implements a versioned data store based on the revision management system Git. You can store object hierarchies as nested hashes, which will be mapped on the directory structure of a git repository. GitStore checks out the repository into a in-memory representation, which can be modified and finally committed.