identifying the country from where the number is frm
A little library for asserting types and values, with zero dependencies.
minimal implementation of a PassThrough stream
Properly hijack require, i.e., properly define require hooks and customizations
Contract between the CLI and authentication plugins, for the exchange of AWS credentials
Return the filename and line number of the calling function
Return the filename and line number of the calling function
Utilities for executing code in Web Workers
JavaScript/TypeScript-native RPC library with Promise Pipelining
AWS SDK for JavaScript Codecatalyst Client for Node.js, Browser and React Native
A JavaScript SDK for integrating calling apps into HubSpot.
react native toast like component, pure javascript solution
when you want to fire an event no matter how a process exits.
Microsoft Azure SDK for JavaScript - Logger
Call an array of promise-returning functions, restricting concurrency to a specified limit.
A debug logger package for other Google libraries
Node addon for string extraction for msgpackr
<!-- automd:badges color=yellow codecov bundlephobia packagephobia -->
JavaScript library for reading EXIF image metadata
Contentstack provides the Live Preview SDK to establish a communication channel between the various Contentstack SDKs and your website, transmitting live changes to the preview pane.
AWS SDK for JavaScript Codecommit Client for Node.js, Browser and React Native
XMLHttpRequest for Node
A CSS parser, transformer, and minifier written in Rust
A jQuery plugin that attempts to determine the user's intent on mouseover and thus delay or prevent the accidental firing of callbacks.
Just to log down what methods are called and from where
See who is calling your method
See where each database call is coming from in your code, and get query profiling to see which queries are taking up the most time in the database.
Since Rails 5 you can no longer call some ActiveRecord class methods named like their Enumerable counterparts. This gem reinstates the expected behaviour, where you can always get the method from Enumerable by calling to_a on the relation.
Allows you to decouple the code implementing a exception-handling strategy from the code which decides which strategy to use. In other words, when you handle a Mulligan::Condition in your rescue clause, you can choose from a set of strategies (called "restarts") exposed by the exception to take the stack back to where #raise was called, execute your strategy, and pretend that the exception was never raised.
Monkey patch objects using Ruby 2.0 refinements, if available.
Ruby bindings (via Rust/magnus) for the Zstandard compressor with persistent ZSTD_CCtx / ZSTD_DCtx contexts that are reused across calls. Provides Zstd frame compress/decompress at module level and a stateful Dictionary class for dict-bound compression. Designed to be safe to call from multiple Ractors and competitive with rlz4 on small messages, where per-call context allocation in zstd-ruby dominates the cost.
Templater has the ability to both copy files from A to B and also to render templates using ERB. Templater consists of four parts: - Actions (File copying routines, templates generation and directories creation routines). - Generators (set of rules). - Manifolds (generator suites). - The command line interface. Hierarchy is pretty simple: manifold has one or many public and private generators. Public ones are supposed to be called by end user. Generators have one or more action that specify what they do, where they take files, how they name resulting files and so forth.
DeprecateSoft is a lightweight Ruby gem that lets you gracefully deprecate methods in your codebase without breaking functionality. It wraps existing instance or class methods and lets you plug in custom before/after hooks for tracking usage via logging, Redis, DataDog, or any other observability tools. Once you verify in your tracking that a method is no longer called, you can remove it safely from your code base. This is especially useful in large codebases where you want to safely remove legacy methods, but first need insight into whether and where they're still being called. Hooks are configured once globally and apply project-wide. Fully compatible with Rails or plain Ruby applications.
Help the user get to a place where the speedy F8/F10/F11/etc keys work. == Pry F-Keys [+F4+] ls -l (show all locally-defined variables and values) [+F5+] whereami (show the code context) [+F6+] up (a frame, depends on pry-stack_explorer, as does the next one) [+F7+] down [+F8+] continue (depends on pry-debugger, as do step/next/finish) [+Shift-F8+] try-again (restart from last 'raise', depends on pry-rescue) [+F10+] next (run the current statement) [+F11+] step (step into the next method call) [+Shift-F11+] finish (get back out of the last 'step')
People love Base classes! They have tons of methods waiting to be used. Just check out `ActiveRecord::Base`'s method list: >> ActiveRecord::Base.methods.length => 530 But why stop there? Why not have even more methods? In fact, let's put *every method* on one Base class! So I did. It's called Base. Just subclass it and feel free to directly reference any class method, instance method, or constant defined on any module or class in the system. Like this: class Cantaloupe < Base def embiggen encode64(deflate(SEPARATOR)) end end >> Cantaloupe.new.embiggen => "eJzTBwAAMAAw\n" See that `embiggen` method calling `encode64` and `deflate` methods? Those come from the `Base64` and `Zlib` modules. And the `SEPARATOR` constant is defined in `File`. Base don't care where it's defined! Base calls what it wants! By the way, remember those 530 ActiveRecord methods? That's amateur stuff. Check out Base loaded inside a Rails app: >> Base.new.methods.count => 6947 It's so badass that it takes *five seconds* just to answer that question! Base is just craaazzy! It's the most fearless class in all of Ruby. Base doesn't afraid of anything!
Iterate over multiple enumerators in parallel, using the external interface based on the #next method. Each call to #next returns an array, containing the next element for each of the enumerators. A StopIteration exception is raised as soon as any of the enumerators runs out of elements. SyncEnum differs from the standard library's REXML::SyncEnumerator in its use of the #next external iterator interface, while REXML::SyncEnumerator uses an #each internal iterator interface. The external interface is more convenient when you expect to end iteration before reaching the end of any of the enumerations, including cases where an enumerator generates an unending sequence.