No more crazy checks to safely get a nested value inside an object
The Aikido Safe Chain wraps around the [npm cli](https://github.com/npm/cli), [npx](https://github.com/npm/cli/blob/latest/docs/content/commands/npx.md), [yarn](https://yarnpkg.com/), [pnpm](https://pnpm.io/), [pnpx](https://pnpm.io/cli/dlx), [rush](https
Assert that safe-chain npm alias is properly configured
safe-chain-object 解决 Javascript 项目中，对值进行数据类型，值判断的复杂性，支持无限层级数据判断，支持常用类型判断。
Give a regex, get a robust predicate function that tests it against a string.
`Array.prototype.concat`, but made safe by ignoring Symbol.isConcatSpreadable
Chain functions, generators, Node streams, and Web streams into a pipeline with backpressure support.
Push an array of items into an array, while being robust against prototype modification
Safer Node.js Buffer API
Collection of Safe modules contract deployments
HANDLE CONFIGURATION ONCE AND FOR ALL
Singleton factory used by Safe related contracts
detect possibly catastrophic, exponential-time regular expressions
Modern Buffer API polyfill without footguns
A utility for managing a prototype chain
A flexible way to handle safe area, also works on Android and web.
Fault-tolerant CSS parser for PostCSS
TypeScript definitions for stream-chain
API for combining call site modifiers
A functional, type-safe utility library for elegant error handling and asynchronous operations in JavaScript/TypeScript.
Ensures safe database operations for Kysely
A simple asynchronous tool
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.
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.