Convert an array to an object template.
Parameterised tests for Jest
Run an array of functions in parallel
Copy a descriptor from object A to object B
General purpose glob-based configuration matching.
utilities for primitive JavaScript types
Parses set-cookie headers into objects
A drop-in replacement for (some of) TaffyDB.
Read/write IEEE754 floating point numbers from/to a Buffer or array-like object
template compiler for Vue 2.x
Polyfill of future proposal for `util.parseArgs()`
Flatten nested arrays
Parse and stringify JSON with comments. It will retain comments even after saved!
template compiler for Vue 2.0
No description provided.
Block API for WordPress.
Matches strings against configurable strings, globs, regular expressions, and/or functions
ByteStream is a library making possible to manipulates single bytes and bits on pure JavaScript
Returns true if a value is a plain object, array or function.
Loop over each item in an array and call the given function on every element.
Yjs encoding protocols
Fast JavaScript array sorting by implementing Python's Timsort algorithm
Array-slice method. Slices `array` from the `start` index up to, but not including, the `end` index.
Takes a grid of values (GeoJSON format) and a set of threshold ranges. It outputs polygons that group areas within those ranges, effectively creating filled contour isobands.
ETags are good, however normally they are generated based on strings. However, very often it is easier to pass in a complete model object as your ETag, or it's parametrized represenation (record id) together with the version. Or an array of objects (if you want to cache your object listing page and prevent it from spending time on template rendering). This module will take care of transforming any object into a stringified representation that is usable as an etag with minimum fuss.
Stencil is a templating library with a number of design goals. * Limited code in templates. This isn't meant to embed ruby in anything - it allows for simple control structures, since that's typically what you need in a template, but full access to the Ruby interpreter is just a tempatation into sin. (From a separation of concerns standpoint.) There's a certain amount of code available in conditionals and interpolations, since otherwise they're much harder to do... * Easy to extend. If you do need something extra from a template, not having it in the templating language is frustrating. It's easy to add features to stencil, since they're described in as well-designed classes. * Generic output. Not everything is a website or a mime-encoded email. It's nice to be able to spit out generic text from time to time. * Data sourced from simple datatypes - hashes and array, referenced with data paths. Views can be extracted from any object, or built up in code.
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.
C, then D, C++, C# -- now C^2, simple C templates using Ruby. Consider this to be a sort of carpenter's square. We call it C^2, or csquare. It's a simple tool for simple jobs. This gem was developed for use in NMatrix (part of the SciRuby Project). We wanted to be able to write a single function and have it be modified to produce C sources for each datatype (rational, complex, integer, float, Ruby object, etc). It also produces some rudimentary function pointer arrays if you so desire, so that these functions can be accessed using array notation. Experimental! Use at your own risk. Actually, don't use this at all! It's extremely buggy and probably won't be useful for your purposes. It's really custom-designed to handle a specific use case: NMatrix dtype templates.