error-c is constant based error define micro framework, you can define error with message(dynamic) more staticaly and safely on typescript
TypeScript SDK for Spain's AEAT VERI*FACTU electronic invoicing system (RD 1007/2023, Order HAC/1177/2024). Covers voluntary submission, on-request mode, hash chaining, mandatory QR code, XAdES-BES signing, NIF/NIF-IVA validation and the full AEAT error c
Create an error from multiple errors
Parse JSON with more helpful errors
Clean up error stack traces
A collection of standard object serializers for Pino
Easy error subclassing and stack customization
Runs (webpack) loaders
Wrap zod validation errors in user-friendly readable messages
Simple reusable React error boundary component
Minimal module to check if a file is executable.
A Minipass stream that raises an error if you get a different number of bytes than expected
Standard error objects for pug
Serialize/deserialize an error into a plain object
Error parser to parse an error instance into a collection of frames
Turn a writable and readable stream into a streams2 duplex stream with support for async initialization and streams1/streams2 input
Strict TypeScript and Flow types for style based on MDN data
Human-friendly process signals
Create an error from multiple errors
libuv errno details exposed
Extract the actual stack of an error
Like request, but smaller.
Simple dependency graph.
Type check values
Sentry integration that allows capturing error-chain errors.
Define custom errors without boilerplate using the custom_error! macro.
A Macros 1.1 implementation of error-chain
Formats a standard error and its sources
Core error type for easy_error
Easy error handling in no-alloc and no-std environments
Procedural macros of the `embedded-error-chain` crate
Yet another error boilerplate library.
Exports the error chain 0.11 types.
Faux' apt package manager for Debian
error-chain for minimalist
derives for error-chain-mini
Handle Ctrl-C and broken-pipe errors gracefully in Ruby command-line tools
Conyard is a Ruby experiment in generating source code for use by C, C++, and Objective-C projects. It is designed to reduce the amount of typing (and therefore errors) introduced by sleep-deprived programmers.
em-udns is an async DNS resolver for EventMachine based on udns C library. Having most of the core written in C, em-udns becomes very fast. It can resolve DNS A, AAAA, PTR, MX, TXT, SRV and NAPTR records, and can handle every kind of errors (domain/record not found, request timeout, malformed response...).
TreRegex provides a high-performance Ruby interface to the TRE C library using FFI. It brings robust approximate (fuzzy) regular expression matching to Ruby, featuring multi-byte Unicode string safety, and granular error limits
Ruby interface for libtoxcore. It can be used to create Tox chat client or bot. The interface is object-oriented instead of C-style (raises exceptions instead of returning error codes, uses classes to represent primitives, etc.)
Ruby Gem for parsing C++ header files. This library is based on Nokogiri (http://nokogiri.org) and takes as input the xml files generated by Doxygen (www.doxygen.org). Parsing with Doxygen allows us to parse even a set of non-compilable include files. This is very useful in case you need to extract metadata for a big library which won't normally compile because of being incomplete or needing further build configuration (think of Makefiles, Visual Studio and similar). By using other tools which rely on a real C/C++ processor like gccxml or swig, you would normally get lots of compilation-related errors (which is undesired because we don't want to compile anything!). Doxyparser is, in such cases, the lean alternative.
= sal-tools - A library for the analyze of SAL code == SYNOPSIS This library gives the basic functionality to analyse Gupta source code. Copyright (c)2007-2011 by Michael Ehehalt Error and feature list at the end of the document == Other stuff Author:: M. Ehehalt <flynn42ryder@rubyforge.org> License:: Copyright (C) 2007, 2008, ... M. Ehehalt Released under the GNU GPL 2 license == Warranty This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
Avoid all errors when accessing (deeply nested) Hash, Array or Struct keys. Safer than dig(), as will quietly return nil (or your default) if the keys requested are invalid for any reason at all. Bonus: you don't even need to fiddle with existing code. If you have already written something to access a deep key (e.g. hash[:a][:b][:c]), just surround this with '.dial' and '.call'.
Creates an Xcode project from a pebble project that contains the needed search paths, resources and .c files to start right away. Each time you build your watch app from the IDE, all warnings and errors of the underlying ´pebble build` command will be presented right in the editor. With AppCode you can even build, install the .pbw to your watch, and look at the live logs as a one-step action directly from your IDE!
GQLite is a Rust-language library, with a C interface, that implements a small, fast, self-contained, high-reliability, full-featured, Graph Query database engine. GQLite support multiple database backends, such as SQLite and redb. This enable to achieve high performance and for application to combine Graph queries with traditional SQL queries. GQLite source code is license under the [MIT License](LICENSE) and is free to everyone to use for any purpose. The official repositories contains bindings/APIs for C, C++, Python, Ruby and Crystal. The library is still in its early stage, but it is now fully functional. Development effort has now slowed down and new features are added on a by-need basis. It supports a subset of OpenCypher, with some ISO GQL extensions. Example of use -------------- ```ruby require 'gqlite' begin # Create a database on the file "test.db" connection = GQLite::Connection.new filename: "test.db" # Execute a simple query to create a node and return all the nodes value = connection.execute_oc_query("CREATE () MATCH (n) RETURN n") # Print the result if value.nil? puts "Empty results" else puts "Results are #{value.to_s}" end rescue GQLite::Error => ex # Report any error puts "An error has occured: #{ex.message}" end ``` The documentation for the GQL query language can found in [OpenCypher](https://auksys.org/documentation/5/libraries/gqlite/opencypher/) and for the [API](https://auksys.org/documentation/5/libraries/gqlite/api/).
# Introduction The Dyspatch API is based on the REST paradigm, and features resource based URLs with standard HTTP response codes to indicate errors. We use standard HTTP authentication and request verbs, and all responses are JSON formatted. See our [Implementation Guide](https://docs.dyspatch.io/development/implementing_dyspatch/) for more details on how to implement Dyspatch. ## API Client Libraries Dyspatch provides API Clients for popular languages and web frameworks. - [Java](https://github.com/getdyspatch/dyspatch-java) - [Javascript](https://github.com/getdyspatch/dyspatch-javascript) - [Python](https://github.com/getdyspatch/dyspatch-python) - [C#](https://github.com/getdyspatch/dyspatch-dotnet) - [Go](https://github.com/getdyspatch/dyspatch-golang) - [Ruby](https://github.com/getdyspatch/dyspatch-ruby)
Have you ever wanted to call <code>exit()</code> with an error condition, but weren't sure what exit status to use? No? Maybe it's just me, then. Anyway, I was reading manpages late one evening before retiring to bed in my palatial estate in rural Oregon, and I stumbled across <code>sysexits(3)</code>. Much to my chagrin, I couldn't find a +sysexits+ for Ruby! Well, for the other 2 people that actually care about <code>style(9)</code> as it applies to Ruby code, now there is one! Sysexits is a *completely* *awesome* collection of human-readable constants for the standard (BSDish) exit codes, used as arguments to +exit+ to indicate a specific error condition to the parent process. It's so fantastically fabulous that you'll want to fork it right away to avoid being thought of as that guy that's still using Webrick for his blog. I mean, <code>exit(1)</code> is so passé! This is like the 14-point font of Systems Programming. Like the C header file from which this was derived (I mean forked, naturally), error numbers begin at <code>Sysexits::EX__BASE</code> (which is way more cool than plain old +64+) to reduce the possibility of clashing with other exit statuses that other programs may already return. The codes are available in two forms: as constants which can be imported into your own namespace via <code>include Sysexits</code>, or as <code>Sysexits::STATUS_CODES</code>, a Hash keyed by Symbols derived from the constant names. Allow me to demonstrate. First, the old way: exit( 69 ) Whaaa...? Is that a euphemism? What's going on? See how unattractive and... well, 1970 that is? We're not changing vaccuum tubes here, people, we're <em>building a totally-awesome future in the Cloud™!</em> include Sysexits exit EX_UNAVAILABLE Okay, at least this is readable to people who have used <code>fork()</code> more than twice, but you could do so much better! include Sysexits exit :unavailable Holy Toledo! It's like we're writing Ruby, but our own made-up dialect in which variable++ is possible! Well, okay, it's not quite that cool. But it does look more Rubyish. And no monkeys were patched in the filming of this episode! All the simpletons still exiting with icky _numbers_ can still continue blithely along, none the wiser.
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.