Push an array of items into an array, while being robust against prototype modification
SDK that facilitates the interaction with the Safe Transaction Service API
Give a regex, get a robust predicate function that tests it against a string.
`Array.prototype.concat`, but made safe by ignoring Symbol.isConcatSpreadable
Substrate-connect well known chain specifications
Safer Node.js Buffer API
Network configurations for Privy SDKs
A flexible way to handle safe area, also works on Android and web.
Light client that connects to Polkadot and Substrate-based blockchains
A history of deployments of the Delegation Framework
detect possibly catastrophic, exponential-time regular expressions
Fault-tolerant CSS parser for PostCSS
Resources common to all Ethereum implementations
Singleton factory used by Safe related contracts
Modern Buffer API polyfill without footguns
Singleton factory used by Safe related contracts
WAGMI connector for Safe Apps
Old abstractions from LangChain.js
Deterministic and safely JSON.stringify to quickly serialize JavaScript objects
An SDK for Pancakeswap EVM based chains
Safe Json Utils
A provider wrapper of Safe Apps SDK
A deep deletion module for node (like `rm -rf`)
detect possibly catastrophic, exponential-time regular expressions
A Maybe/Optional type for Ruby providing Some and None containers with safe chaining, pattern matching via deconstruct_keys, filtering, and value extraction.
Chain multiple methods together safely without having to repeat the safe navigation operator for each call
[Ruby on Rails Training] Cryptodemo will allow us to perform safe transactions keeping an immutable chain state.
Flexor provides autovivifying nested access, nil-safe chaining, and seamless conversion between hashes and method-style access. Built for flexible data containers, middleware state, and prototyping.
BreakerMachines is a production-ready circuit breaker implementation for Ruby that prevents cascade failures in distributed systems. Built on the battle-tested state_machines gem, it provides a clean DSL, thread-safe operations, multiple storage backends, and comprehensive introspection tools. Unlike other solutions, BreakerMachines prioritizes safety by avoiding dangerous forceful timeouts while supporting fallback chains, jitter, and event callbacks.
This class provides a Ruby-oriented scheme to safely overwrite an existing file, leaving a backup file unless specified otherwise. It writes a temporary file first, which is renamed to the original file in one action. It accepts a block like some IO class-methods (e.g., each_line) and chaining like String methods (e.g., sub and gsub).
Radioactive wraps Net::HTTP with defenses against SSRF, DNS rebinding, slowloris, response and decompression bombs, redirect chains into private addresses, and disallowed schemes. Safe-by-default for use cases like link previews, image proxies, webhook delivery, and metadata extraction from user-supplied URLs.
== 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.
A comprehensive Ruby implementation of a Knowledge-Based System featuring: • RETE Algorithm: Optimized forward-chaining inference engine with unlinking optimization for high-performance pattern matching • Declarative DSL: Readable, expressive syntax for rule definition with built-in condition helpers • Blackboard Architecture: Multi-agent coordination with message passing and knowledge source registration • Flexible Persistence: SQLite (durable), Redis (fast), and hybrid storage backends with audit trails • Concurrent Execution: Thread-safe auto-inference mode for real-time processing • AI Integration: Native support for LLM integration (Ollama, OpenAI) for hybrid symbolic/neural reasoning • Production Features: Session management, fact history, query API, statistics tracking Perfect for expert systems, trading algorithms, IoT monitoring, portfolio management, and AI-enhanced decision systems.
No description provided.
No description provided.
No description provided.