This page lists the Ruby libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.

What the marks mean.

The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).

Web frameworks and HTTP servers (the routes your code serves)

5 supported, 3 partly, 3 not yet.

Name Status Ways of using it that were tested
AWS SAM template.yaml supported yes: AWS::Serverless::Function (Runtime ruby3.3, Handler file.method under CodeUri) with Events Type HttpApi or Api Path and Method
cuba not yet no: Cuba.define do on get, "vendors" do ... end end
grape partly partly: resource :shipments with version "v1", using: :path and prefix :api
hanami supported yes: class Routes < Hanami::Routes with get "/stores", to: "stores.index" and scope
padrino not yet no: App.controllers :reviews do get :index ... post :create, map: "/reviews" end
rails partly yes: get "/orders", to: "orders#index" in config/routes.rb
yes: get "orders/:id" written without a leading slash
yes: get "/legacy/orders" => "orders#legacy"
no: resources :carts, only: [...] expands to the REST routes
yes: namespace :admin do get "reports" ... end prefixes /admin
yes: scope path: "/v1" do ... end
yes: match "/checkout", to: ..., via: [:get, :post]
yes: root "home#index"
roda not yet no: route do |r| r.on "wishlists" do r.get true ... end; r.is "health" ... end
Serverless Framework serverless.yml supported yes: functions.<name>.handler file.method with events httpApi or http
sinatra supported yes: top-level get "/tickets" do ... end in a classic app
yes: class X < Sinatra::Base with get/delete blocks
sinatra-contrib partly partly: namespace "/api" do get "/status" end (Sinatra::Namespace)
Vercel Functions (Ruby runtime, /api directory) supported yes: api/<name>.rb defining Handler = Proc.new do |request, response|: the file path is the route, every verb
yes: api/<name>.rb defining class Handler < WEBrick::HTTPServlet::AbstractServlet with do_GET/do_POST: verbs from the do_ methods
yes: api/wishlists/[id].rb: a bracketed file name is a dynamic path segment

The language's own HTTP server

0 supported, 1 partly, 2 not yet.

Name Status Ways of using it that were tested
drb not yet no: DRb.start_service("druby://host:port", front_object)
rack not yet no: def call(env) branching on env["PATH_INFO"] and env["REQUEST_METHOD"]
no: Rack::Request#get? and #path_info == "/gift-cards"
no: map "/admin/ping" do run lambda end in config.ru or Rack::Builder
webrick partly no: server.mount_proc "/receipts" do |req, res| ... end
yes: server.mount "/refunds", RefundServlet where the servlet defines do_GET / do_POST

HTTP client libraries (the calls your code makes to other services)

2 supported, 7 partly, 1 not yet.

Name Status Ways of using it that were tested
activeresource not yet no: class X < ActiveResource::Base; self.site = base; X.find(:all) is GET /products.json
excon partly yes: Excon.get(absolute url)
partly: Excon.new(base).get(path: "/receipts")
no: conn.request(method: :post, path: ...)
faraday partly no: Faraday.new(url: base) then conn.get(relative path)
partly: conn.post(path) do |req| req.body = ... end
yes: Faraday.get(absolute url)
partly: Faraday.new(ENV.fetch("RODA_URL")) with the value in docker-compose
no: conn.run_request(:delete, path, body, headers)
http (http.rb) partly yes: HTTP.get(url)
yes: HTTP.auth(token).post(url, json: ...)
no: HTTP.persistent(base) do |http| http.get(path) end
httparty partly yes: HTTParty.get(absolute url)
no: include HTTParty; base_uri "..."; self.class.get(path)
httpclient supported yes: HTTPClient.new.get(url) and .post(url, body)
httpx supported yes: HTTPX.get(url) and HTTPX.post(url, json:)
rest-client partly yes: RestClient.get(url) and RestClient.post(url, payload, headers)
yes: RestClient::Resource.new(base)["vendors"].get
no: RestClient::Request.execute(method: :delete, url: ...)
several (main project) partly partly: main calls a server in each framework through a different client form
typhoeus partly yes: Typhoeus.get(url)
no: Typhoeus::Request.new(url, method: :post).run
no: hydra.queue(Typhoeus::Request.new(url)); hydra.run

The language's own HTTP client

0 supported, 2 partly, 1 not yet.

Name Status Ways of using it that were tested
drb not yet no: DRbObject.new_with_uri("druby://host:port").method(args)
net/http partly yes: Net::HTTP.get(URI(url))
yes: Net::HTTP.get_response(URI.parse(url))
yes: Net::HTTP.post(URI(url), body, headers) and post_form
no: Net::HTTP.start(host, port) do |http| http.get(path) end
no: http.request(Net::HTTP::Delete.new(path)) and Net::HTTP::Post.new(uri)
open-uri partly yes: URI.open(url).read
partly: URI(url).open { } and URI.parse(url).read

gRPC

0 supported, 2 partly, 0 not yet.

Name Status Ways of using it that were tested
grpc partly yes: class X < Pkg::S::Service with snake_case methods, GRPC::RpcServer#handle(X)
no: Pkg::S::Stub.new(addr, creds) then stub.place_order(req)
yes: stub.list_orders(req) returns an enumerator
no: stub.place_order(req, return_op: true).execute
no: GRPC::ClientStub#request_response("/pkg.S/M", req, marshal, unmarshal)
gruf partly yes: class X < Gruf::Controllers::Base; bind Pkg::S::Service; def place_order
no: Gruf::Client.new(service: Pkg::S, options: { hostname: }) then client.call(:PlaceOrder, ...)

Databases and data stores

8 supported, 2 partly, 8 not yet.

Name Status Ways of using it that were tested
activerecord partly yes: Order.where(...) on a model with self.table_name
yes: Order.create!(attrs) and order.update!(...)
yes: model without table_name: Coupon reads table coupons
no: ActiveRecord::Base.connection.execute(raw SQL)
yes: Order.find_by_sql("SELECT ...")
aws-sdk-dynamodb not yet no: Aws::DynamoDB::Client#put_item(table_name:) and query
aws-sdk-s3 not yet no: Aws::S3::Client#put_object(bucket:) and get_object
no: Aws::S3::Resource.new.bucket(name).object(key).put(body:)
dalli supported yes: Dalli::Client.new(servers).set(key, value, ttl)
dynamoid supported yes: include Dynamoid::Document; table name: :wishes; Wish.where(...).all
elasticsearch (elasticsearch-ruby) not yet no: Elasticsearch::Client#index(index:) and search(index:)
File, FileUtils (core) supported yes: File.write(path, data), File.read(path), FileUtils.mkdir_p
mongo not yet no: client[:ratings].insert_one / find
mongoid supported yes: include Mongoid::Document; store_in collection: ...; Review.where / create!
mysql2 supported yes: Mysql2::Client.new(...).query(sql) and prepare(sql).execute
pg supported yes: PG.connect(...).exec(sql) and exec_params(sql, params)
rails (ActiveSupport cache) not yet no: Rails.cache.fetch(key, expires_in:) { } and Rails.cache.delete(key)
redis (redis-rb) supported yes: Redis.new(url:); redis.set / get / lpush
redis-client not yet no: RedisClient.config(...).new_client.call("SET", key, value)
searchkick not yet no: class Product < ApplicationRecord; searchkick; end; Product.search(text)
sequel partly partly: DB[:invoices].where(...).all and DB[:invoices].insert(...)
yes: class Invoice < Sequel::Model(:invoices); Invoice.where(...)
no: DB.run(raw SQL)
several (main project) not yet no: main writes tables, queues and topics that services read
sqlite3 supported yes: SQLite3::Database.new(path).execute(sql)

Messaging and events (queues, topics, streams)

5 supported, 7 partly, 9 not yet.

Name Status Ways of using it that were tested
actioncable not yet no: ActionCable.server.broadcast("orders_channel", data) and stream_from "orders_channel"
activejob not yet no: Job.perform_later(args) and Job.set(wait:).perform_later
no: class X < ApplicationJob; queue_as :shipping; def perform
activesupport (Notifications) not yet no: ActiveSupport::Notifications.instrument("order.placed") and subscribe("order.placed")
aws-sdk-sns supported yes: Aws::SNS::Client#publish(topic_arn:, message:)
aws-sdk-sqs partly partly: Aws::SQS::Client#send_message(queue_url:) and receive_message
bunny partly no: channel.topic("orders").publish(body, routing_key:)
yes: channel.default_exchange.publish(body, routing_key: queue)
partly: channel.queue("invoice-requests").subscribe { |d, p, body| }
delayed_job not yet no: Delayed::Job.enqueue(job, queue:) and Object.delay.method(args)
google-cloud-pubsub partly partly: pubsub.topic(name).publish(data) and subscription(name).listen { }
karafka partly partly: routes.draw { topic :loyalty_events { consumer X } } with X#consume
yes: Karafka.producer.produce_async(topic:, payload:)
nats-pure not yet no: NATS.connect(url); nats.publish(subject, data); nats.subscribe(subject) { }
rdkafka supported yes: producer.produce(topic: "payments", payload:) and consumer.subscribe("payments-settled")
redis (redis-rb) supported yes: redis.publish(channel, msg) and redis.subscribe(channel) { |on| on.message { } }
resque not yet no: Resque.enqueue(JobClass, args) with @queue and self.perform
ruby-kafka supported yes: kafka.deliver_message(value, topic:) and consumer.subscribe + each_message
rufus-scheduler supported yes: scheduler.every "10m" do ... end and scheduler.cron "0 3 * * *"
shoryuken partly partly: include Shoryuken::Worker; shoryuken_options queue: ...; Worker.perform_async(body)
sidekiq partly partly: include Sidekiq::Job (the name since 6.3) with perform
partly: include Sidekiq::Worker with perform
no: Job.perform_async(args) and perform_in(seconds, args)
no: Job.set(queue: "critical").perform_async(args)
no: Sidekiq::Client.push("class" => "Job", "queue" => ...)
sneakers partly partly: include Sneakers::Worker; from_queue "q"; def work(msg)
sucker_punch not yet no: include SuckerPunch::Job; Job.perform_async(args)
waterdrop not yet no: WaterDrop::Producer.new { }.produce_sync(topic:, payload:)
wisper not yet no: include Wisper::Publisher; broadcast(:order_placed, ...); flow.subscribe(listener) / on(:event)

Build tools and package managers

6 supported, 1 partly, 0 not yet.

Name Status Ways of using it that were tested
bundler supported yes: Gemfile plus config.ru Sinatra app, lib/, spec/, gems installed into vendor/bundle
bundler (appraisal) supported yes: gemfiles/*.gemfile variants generated by Appraisal beside the real Gemfile
bundler (path gems) supported yes: gems/* libraries and apps/* that load them through gem "x", path: "../../gems/x"
none (plain Ruby) supported yes: plain scripts: bin/.rb load lib/.rb with require_relative; no Gemfile
rake supported yes: a task project: Rakefile and lib/tasks/*.rake, no Gemfile
rubygems (gemspec executables) partly partly: a command-line gem: exe/shopctl named in spec.executables, Thor CLI in lib/
rubygems (gemspec) + bundler supported yes: a library gem: .gemspec, Gemfile with gemspec, lib/<name>/, spec/, sig/ RBS, pkg/ and doc/ output

Project and folder layouts

8 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
bundler (several apps) supported yes: services/orders (Rack), services/billing (Rails) and libs/shop_events (gem), each with its own Gemfile
hanami 2 supported yes: a Hanami 2 app with slices/admin and slices/main beside app/
packwerk / packs-rails supported yes: one Rails app split into packs/<name>/ (package.yml, app/), all deployed together
rails supported yes: a Rails app: bin/rails, app/, lib/, test/ (Minitest), db/schema.rb (generated), public/assets (compiled), tmp/, log/
rails engines supported yes: a host Rails app with engines/billing (an isolated engine gem with its own test/dummy app)
RSpec, Minitest, Cucumber supported yes: a library with spec/ (RSpec), test/ (Minitest) and features/ (Cucumber step definitions and support)
sorbet + tapioca supported yes: typed code with generated sorbet/rbi/gems and sorbet/rbi/dsl, and RBS signatures in sig/
zeitwerk (no Rails) supported yes: a Rack app whose lib/ is autoloaded by Zeitwerk: constants are used with no require