An in-memory FIFO cache with fixed TTL for Node.js, designed to streamline the common get-or-fetch pattern by automating value retrieval. It uses an internal keyed lock to coalesce concurrent fetches for the same key, reducing redundant network calls and
DOM trap for a focus
It is a trap! (for a focus)
Control Flow primitives and components that require specifying explicit keys to identify or rerender elements.
Flattens React children and fragments to an array with predictable and stable keys
A mutex for guarding async workflows
A inter-process and inter-machine lockfile utility that works on a local or network file system
provides locking mechanism to sync across browser tabs
Lock on asynchronous code
a map from arrays of values to values
An efficient keyed Promise lock for Node.js projects, ensuring the mutually exclusive execution of tasks associated with the same key. Key features include active key metrics and the ability to gracefully await the completion of all currently executing or
Mutex locks for async functions
TypeScript definitions for async-lock
Enables body scroll locking (for iOS Mobile and Tablet, Android, desktop Safari/Chrome/Firefox) without breaking scrolling of a target element (eg. modal/lightbox/flyouts/nav-menus)
React focus lock for all Chakra components
Simple lock class
An efficient Promise lock for Node.js projects, ensuring mutually exclusive execution of asynchronous tasks. Key features include a backpressure indicator, access to the currently executing task promise for smart reuse (useful when launching a duplicate t
lock asynchronous resources.
Provides an enum of all possible VNode Flags used when calling Inferno.createVNode
mutex lock for javascript
Throttle the parallelism of an asynchronous (promise returning) function / functions
🔐Body scroll locking that just works with everything
It is a trap! (for a focus)
To lock a key of the Redis, then daemonize. If killed, it will release the key.
Memcache key lock, extracted from cache-money.
Memcache key lock, extracted from cache-money, adapted to Rails memcache store.
Module for adding redis functionality to classes: simple key namespacing and locking and connections
Key based pessimistic locking for Ruby and MongoDB. Is this key avaliable? Yes - Lock it for me for a sec will you. No - OK I'll just wait here until its ready.
This gem allows you to lock specific chunks of code based on a shared key. It's a Mutex, but locks beyond a single machine by utilizing Redis's SETNX.
Adds pessimistic locking capabilities to the redis gem. Since these capabilities are utilized client-side, all clients must use this gem and follow the order of lock => make changes => unlock in order to obtain maximum safety when modifying sensitive keys. Tested with redis-server 2.0.4 and should work with all versions > 0.091.
safe is a credentials manager for the linux command line written in Ruby. It locks and unlocks secrets in a safe simple and intuitive manner. You can then visit websites, manufacture keys and passwords, inject credentials into Jenkins, and interact with many tools including S3, GoogleDrive, Terraform, Git and Docker.
A generic index DRb server. The core index is a hash, each key is an individual term, each value is an array of references for that term. Searches the index with a simple regexp grep against the hash keys to return a single array of all references on matching terms. Multi-user ready via a simple locking mechanism that probably doesn't scale too well. BSD License.
A Bundler plugin + CLI that probes whether gems compile under Spinel and gates `bundle lock` on a forward-compatible, engine-rev-keyed compatibility ledger.
Ravanello is the cli for analyze keys in redis and size of it's values. Example of usage: ```bash gem install ravanello ravanello --version REDIS_URL="redis://localhost/db" ravanello analyze --rules rules.yml ``` The rules files specifies the structure of the redis keys (splitted by :) and should looks like this: ```yml rules: resque: - 'delayed' - 'resque-retry' - 'timestamps' - 'lock' - 'meta' ``` After analyzing you will get the report in console: ``` Q-ty Size Key (sample) 4 24 * (hello) 1 6 denormalized:companies:* (denormalized:companies:99585213) ```
SafeMemoize is a production-ready, zero-dependency memoization library for Ruby. It uses Ruby's prepend mechanism to wrap methods with a thread-safe cache (Mutex + double-check locking) that correctly handles nil and false return values — fixing the silent bug in the common ||= pattern. Results are cached per unique argument combination, so parameterized methods only compute each variant once. Additional features include TTL expiration, LRU cache size limiting, conditional caching via if:/unless: predicates, lifecycle hooks for hit/eviction/expiration events, per-instance metrics (hit rate, miss rate, computation time), targeted cache invalidation, custom cache key generators, and introspection helpers. Method visibility (public, protected, private) is fully preserved.
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.