Sorbet's runtime type checking component

Type checking and type casting of parameters for Action Pack

Makes sure users don't accidentally create an account for the wrong e-mail address. Because 'gmial' isn't actually what they meant to type. Similarly, 'yaho.com', or the strange-but-true '.c0m'. Not even making that one up. If you're concerned about false-positives, it's super-easy to check. There's only a single method. Also, it's fully-tested.

RubyLess is an interpreter for "safe ruby". The idea is to transform some "unsafe" ruby code into safe, type checked ruby, eventually rewriting some variables or methods.

Type check JSON objects

A type coercion lib works with Sorbet's static type checker and type definitions; raises an error if the coercion fails.

The Master of Syntax Error brings you... this debugging exercise type "activate" to start the exercise, happy ...debugging your project type "checkme" for an update on your debugging progress, or if your are sick of it just type "fixme" to fix the errors

MooseX is an extension of Ruby object DSL. The main goal of MooseX is to make Ruby Object Oriented programming easier, more consistent, and less tedious. With MooseX you can think more about what you want to do and less about the mechanics of OOP. It is a port of Moose/Moo from Perl to Ruby world, providing method delegation, type check, traits, monads, plugins, lazy attributes, aspects and much more.

Various DSLs to clean, question (Ask), and validate (Demand) your objects, their classes (data types), and their properties.

Sinja is a Sinatra extension for quickly building RESTful, {json:api}-compliant web services, leveraging the excellent JSONAPI::Serializers gem for payload serialization. It enhances Sinatra's DSL to enable resource-, relationship-, and role-centric API development, and it configures Sinatra with the proper settings, MIME-types, filters, conditions, and error-handling. There are many parsing (deserializing), rendering (serializing), and other "JSON API" libraries available for Ruby, but relatively few that attempt to correctly implement the entire {json:api} server specification, including routing, request header and query parameter checking, and relationship side-loading. Sinja lets you focus on the business logic of your applications without worrying about the specification, and without pulling in a heavy framework like Rails. It's lightweight, ORM-agnostic, and Ember.js-friendly!

Type-checked set and array

RDL is a gem that adds types and contracts to Ruby. RDL includes extensive support for specifying method types, which can either be enforced as contracts or statically checked.

Allows you check if an object match a class expression. It is typically used to check the type of method paraameters. It is an alternative to using Ruby-3 .rbs files but with a different syntax and only dynamic checks Typically you'll include the Constrain module and use #constrain to check the type of method parameters: include Constrain # f takes a String and an array of Integer objects. Raise a Constrain::Error # if parameters doesn't have the expected types def f(a, b) constrain a, String constrain b, [Integer] end Constrain works with ruby-2 (and maybe ruby-3)

A gem that provides DSL for serialization of plain old Ruby objects to JSON in a declarative style by defining a `schema`. It also provides a trivial type checking in the runtime before serialization.

# Gadget Some methods for getting metadata and other deep details from a PostgreSQL database. ## Installation Add this line to your application's Gemfile: gem 'gadget' And then execute: $ bundle Or install it yourself as: $ gem install gadget ## Usage `#tables(conn)` Returns a list of all tables in the schema reachable through `conn`. `#columns(conn, tablename=nil)` Returns a list of all columns in the schema reachable through `conn`. If `tablename` is given, returns the columns in only that table. `#foreign_keys(conn, tablename=nil)` Returns a list of all foreign keys in the schema reachable through `conn`. If `tablename` is given, returns the foreign keys in only that table. `#constraints(conn, tablename=nil)` Returns a list of all constraints in the schema reachable through `conn`. If `tablename` is given, returns the constraints in only that table. `#dependencies(conn)` Returns a structure representing the dependencies between tables in the schema reachable through `conn`. Table A is defined as dependent on table B if A contains a foreign key reference to B. `#tables_in_dependency_order(conn)` Returns a list of all tables in the schema reachable through `conn`, ordered such that any given table appears later in the list than all of its dependencies. `#dependency_graph(conn)` Returns `.dot` script (suitable for feeding into Graphviz) describing the table dependency graph. `#functions(conn)` Returns a list of all functions in the schema reachable through `conn`. `#sequences(conn)` Returns a list of all sequences in the schema reachable through `conn`. `#triggers(conn)` Returns a list of all triggers in the schema reachable through `conn`. `#types(conn)` Returns a list of all types in the schema reachable through `conn`. ## Contributing 1. Fork it 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create new Pull Request

Run-time type checker and transformer for Ruby

rubber-c-binder allows a rubyish means of generating bindings for C libraries, including (but not limited to) GObject based libraries. It allows C code to be written in the context of a ruby style class/method layout and eases type checking and conversion between Ruby & C datatypes.

Check yardoc format like tag type.

The fastest type checking gem

Type-checked serializers for your Ruby objects