Derive a list/map from another via live binding
Common functions used across Polkadot, derived from RPC calls and storage queries.
Derive util for Valtio
Cryptographic key pairs for the XRP Ledger
Pure javascript implementation of Bip32Ed25519, used for Cardano blockchain key pair.
Ethereum Name Service (ENS) Name Normalizer
Additional polkadot.js derives for Acala Network
Set the title on a pad in Etherpad, also includes real time updates to the UI
Astro’s [Go](https://golang.org/) + WASM compiler.
A function to create a derived Zustand store from stores
Simple runtime TypeScript validator library
Cryptographic key pairs for the XRP Ledger
IOTA Signing Scheme
This package holds key identifiers for Exodus' own BIP43 purpose
Cryptographic types and functions for Cardano
Universal Module for HKDF (Hash-based Key Derivation Function) in JavaScript
HKDF with no dependencies using runtime's native crypto
Pure JS Cardano Wallet library
Key derivation based on Hierarchical Deterministic (HD)/Mnemonic keys and BIP32, for Kadena
Library to derive a type from another.
This package provides support for Hierarchical Deterministic (HD) Wallet.
Webb JS API derived methods
The `package-deps-hash` library generates a JSON object containing the git hashes of all files used to produce a given package. This is useful for scenarios where you want to define a "change receipt" file to be published with a package. The [Rush](http
Utilities for working with bolt07 data formats
Derive macros for proto-scan crate
Macro implementation of #[derive(UserSubmittable)]
Makes it possible to derive Uavcan related types
CsvPirate is the easy way to create a CSV of essentially anything in Ruby, in full pirate regalia. It works better if you are wearing a tricorne!
RText can be used to derive textual languages from an RGen metamodel with very little effort.
Common logic gates written in Ruby. A proof that all logical operations can be derived from AND, OR and NOT.
A friendly static site builder
A relatively large collection of russian first, last names and patronymics, information on their popularity and utilities for making their derivatives. With this gem you can form pretty realistic russian names.
If you've gone through the trouble of linking your schema with proper foreign keys, defining associations in ActiveRecord feels like double work. ActiveSchema discovers the associations and validations that can be derived from the database schema.
This Sinatra extension, derived from omniauth_pure by Marcus Proske, adds OmniAuth authorization to your Sinatra application, so your users can login using FaceBook, Twitter and many other authorization providers, as long as you supply the API keys. It uses DataMapper and HAML.
This gem creates a thin shell to encapsulate primitive literal types such as integers, floats and symbols. There are a family of wrappers which mimic the behavior of what they contain. Primitive types have several drawbacks: no constructor to call, can't create instance variables, and can't create singleton methods. There is some utility in wrapping a primitive type. You can simulate a call by reference for example. You can also simulate mutability, and pointers. Some wrappers are dedicated to holding a single type while others may hold a family of types such as the `Number` wrapper. What is interesting to note is Number objects do not derive from `Numeric`, but instead derive from `Value` (the wrapper base class); but at the same time, `Number` objects mimic the methods of `Fixnum`, `Complex`, `Float`, etc. Many of the wrappers can be used in an expression without having to call an access method. There are also new types: `Bool` which wraps `true,false` and `Property` which wraps `Hash` types. The `Property` object auto-methodizes the key names of the Hash. Also `Fraction` supports mixed fractions.
Adds support for displaying your ActiveRecord tables, named scopes, collections, or plain arrays in a table view when working in rails console, shell, or email template. Enumerable#to_table_display returns the printable strings; Object#pt calls #to_table_display on its first argument and puts out the result. Columns you haven't loaded (eg. from using :select) are omitted, and derived/calculated columns (eg. again, from using :select) are added. Both #to_table_display and Object#pt methods take :only, :except, and :methods which work like the #to_xml method to change what attributes/methods are output. The normal output uses #inspect on the data values to make them printable, so you can see what type the values had. When that's inconvenient or you'd prefer direct display, you can pass the option :inspect => false to disable inspection.
PluginFactory is a mixin module that turns an including class into a factory for its derivatives, capable of searching for and loading them by name. This is useful when you have an abstract base class which defines an interface and basic functionality for a part of a larger system, and a collection of subclasses which implement the interface for different underlying functionality. An example of where this might be useful is in a program which talks to a database. To avoid coupling it to a specific database, you use a Driver class which encapsulates your program's interaction with the database behind a useful interface. Now you can create a concrete implementation of the Driver class for each kind of database you wish to talk to. If you make the base Driver class a PluginFactory, too, you can add new drivers simply by dropping them in a directory and using the Driver's `create` method to instantiate them:
With dokkit you can: * generate static websites * generate many types of documents in many formats * write your documents using a simple wiki syntax and obtain high quality output (with pdflatex) * generate different output formats from the same source document * use models to quickly generate the documents you want (technical report, howto, guides, presentation, website, etc.) * simply derive new documentation models from the existing ones * simply modify existing models to fit your needs For more information about dokkit visit the website[http://dokkit.rubyforge.org/]
chef-gen-flavor-base is a base class to make it easy to create 'flavors' for use with [chef-gen-flavors](https://github.com/jf647/chef-gen-flavors). chef-gen-flavors plugs into the 'chef generate' command provided by ChefDK to let you provide an alternate template for cookbooks and other chef components. This gem simply provides a class your flavor can derive from; templates are provided by separate gems, which you can host privately for use within your organization or publicly for the Chef community to use. An example flavor that demonstrates how to use this gem is distributed separately: [chef-gen-flavor-example](https://github.com/jf647/chef-gen-flavor-example) At present this is focused primarily on providing templates for generation of cookbooks, as this is where most organization-specific customization takes place. Support for the other artifacts that ChefDK can generate may work, but is not the focus of early releases.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.