The safe way to handle the `connect` socket event
Support for `import <defer|source>` phase syntax in Acorn
A JavaScript library for escaping CSS strings and identifiers while generating the shortest possible ASCII-only output.
Create a deferred promise
For ruby and ruby on rails
A fast and minimal deferred implementation for javascript
Ruby SemVer in TypeScript.
Like ruby's abbrev module, but in js
Convention over configuration for using Vite in Ruby apps
Ruby grammar for tree-sitter
Create a deferred promise that is wrappened in a function
prettier plugin for the Ruby programming language
WebSocket framework for Ruby on Rails.
Oxc Parser Node API
No description provided.
Defer an ES2015 Promise implementation
JavaScript client for graphql-ruby
bootstrap-sass is a Sass-powered version of Bootstrap 3, ready to drop right into your Sass powered applications.
Convention over configuration for using Vite in Rails apps
realistic password strength estimation
A Stimulus Wrapper for Flatpickr library
Provide I18n to your React Native application
Let a globally installed package use a locally installed version of itself if available
Prism Ruby parser
The gem allows you to do deferred tasks within a block
Go's defer functionality in ruby. Never forget to do something.
Q is a lightweight deferred library for Ruby.
Provide a method to release/collect resources in deferred way
For Gophers who are missing Go's defer
Implements the await/defer pattern for event-driven or asynchronous Ruby
This gem defines the Kernel method "it" that queue and defer method calls. This extends the Symbol#to_proc idiom to support chaining multiple methods. For example, items.collect(&it.to_s.capitalize). This also allows conditionals in case statements, such as: case ... when it > 3 then [etc.]. The method is also aliased as "its", for methods that describe possessives rather than actions, such as items.collect(&its.name.capitalize) [This gem is an extension of Jay Philips' "methodphitamine" gem, updated for ruby 1.9 and gemspec compatibility and adding the case statement functionality.]
a helper class do do a chached processing
Bucket Client is a ruby gem that allows programmers to interact with popular Blob Storage cloud services. This intends to act as a layer of abstraction, much like ORM is to databases. With this, you may easily change the blob storage provider or even defer them. The supported cloud storage include: - Google Cloud Platform Cloud Storage - Amazon Web Service S3 Bucket - Digital Ocean Spaces - Azure Blob Storage (Microsoft).
Implementation of a subset of Ruby's Enumerable, using socketry/async to perform operations in parallel wherever possible, while deferring to Enumerable's implementation where not. Async::Enumerable is in the same category as LazyEnumerable, but making a different set of changes to how Enumerable works.
A Sinatra extension that implements the full Inertia.js v2 wire protocol: page-object responses, version mismatch detection (409 + X-Inertia-Location), partial reloads, deferred / lazy / always / optional / merge props, encrypted history, redirect 303 handling, and error/flash session sweeps. Pure Sinatra-compatible: depends only on `sinatra` and `rack`. Runs on MRI Ruby and on the homura Cloudflare Workers + Opal stack.
== Synopsys Ruby Enumerable extension. Main idea is lazy computations within enumerators. == Usage Install as a gem: sudo gem install deferred_enum This gem introduces DeferredEnumerator class: ary = [1, 2, 3, 4] deferred = ary.defer # #<DeferredEnumerator: [1, 2, 3, 4]:each> DeferredEnumerator brings some optimizations to all?, any? and none? predicates deferred.all?(&:even?) # Will stop iteration after first false-result = 1 iteration deferred.none?(&:even?) # 2 iterations deferred.any?(&:even?) # 2 iterations It also introduces lazy versions of Enumerable's #select, #map and #reject methods deferred.map { |i| i + 1 } # #<DeferredEnumerator: #<Enumerator::Generator>:each> deferred.select { |i| i.even? } # #<DeferredEnumerator: #<Enumerator::Generator>:each> deferred.reject { |i| i.odd? } # #<DeferredEnumerator: #<Enumerator::Generator>:each> So you can safely chain your filters, they won't be treated as arrays: deferred.map(&:succ).select(&:even?) # #<DeferredEnumerator: #<Enumerator::Generator>:each> You can build chains of Enumerables: deferred.concat([2]).to_a # [1, 2, 3, 4, 2] Or append elements to the end of enumerator: deferred << 2 You can even remove duplicates from enumerator, though this operation can be tough: deferred.uniq # #<DeferredEnumerator: #<Enumerator::Generator>:each> There are many other methods in DeferredEnumerator, please refer to documentation.