async-background 1.0.2 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 233f46d3617b40d9a8a27f83689050b0127603679342ddfa80a18eea0137651c
-  data.tar.gz: 5d70fe357702dff97b51734c1fddf64178f3ea0d9d9d88449fe3af9b32fc59d3
+  metadata.gz: d9bd77f8af5601609ef43abb3b108ce225e0b20357e712023e2118a06c7e3496
+  data.tar.gz: a0e71bfec3a834da9d7a2df0fbd161ee42bbedff00ea1e90f62bee89d9c1edb3
 SHA512:
-  metadata.gz: 148770cb2522083b5944a5ee0f5830a1e1453f9c06647feaf0b92842e6008e2654aefd7e8c4a4a97509fc823702d64176a7bf4e30e8a08d409308f57792bbb1d
-  data.tar.gz: 99e64f1f1066528429617270d54ae64109896d1318634f5b4b001a9d10e4ed19b88239dc4b7a089c885d4f481d2799b22b70495b763d64df51702c82b15865f8
+  metadata.gz: 3f7d7bd4011648a53092257c35906face2cb05bb46c24233cd9739fd37fa07b19d6476e1ad3a433891abce6146fde4c6fcbaf7fff1a73721fe2fde0dcdde1243
+  data.tar.gz: 25070911a4a50ed9142f582bffe6f385aeb236885e417409324804b1525cdea5e30889dc92d14f15c0480386a790732cf84aab54858d73c1b0177eff65af8f9c

data/CHANGELOG.md

@@ -1,5 +1,86 @@
 # Changelog
 
+## 1.1.1
+
+### Changed
+
+- Refactored runner lifecycle and queue execution, runtime task coordination,
+  job option normalization, metrics access, and web request handling into
+  smaller focused components.
+- Moved dashboard HTML, CSS, and JavaScript into separate packaged assets.
+- No public API or queue schema changes are intended.
+
+### Validation
+
+- Full spec suite: 431 examples, 0 failures.
+
+## 1.1.0
+
+The gem no longer depends on `async`. The same worker runs under any
+`Fiber::Scheduler` the host installs — Falcon/Async, Itsi, or another
+implementation.
+
+### Breaking
+
+- `Runner#run` no longer starts a reactor. It needs an active
+  `Fiber.scheduler` and raises `Runtime::SchedulerRequired` without one:
+
+  ```ruby
+  Async { runner.run }                             # Falcon / Async
+  Async::Background::Scheduler.run { runner.run }  # async or itsi via ENV
+  ```
+
+- Job timeouts raise `Async::Background::Runtime::TimeoutError` instead of
+  `Async::TimeoutError`. Update rescue sites and any stored `error_class`.
+- `Runner#drain_jobs` is bounded (`drain_timeout:` default 30s). In-flight jobs
+  that outlive it are cancelled. Pass `drain_timeout: nil` for an unbounded wait.
+- `TaskGroup#stop_all(grace = nil)` returns whether the group drained, not a
+  count of cancelled tasks.
+- `Async::Background::Error` is the base class for `Runtime::Error` and
+  `ConfigError`. Both are still `StandardError`.
+
+### Added
+
+- `Async::Background::Runtime` — `Task`, `TaskGroup`, `Semaphore`,
+  `Notification`, `with_timeout`, `native_timeouts?`, `with_error_handler`.
+- `Async::Background::Scheduler` — optional bootstrap
+  (`require "async/background/scheduler"`) that installs `async` or
+  `itsi-scheduler` from `ASYNC_BACKGROUND_SCHEDULER`. `Scheduler.preload!`
+  loads the gem before fork. `Scheduler.run` on Itsi uses the current thread;
+  `ASYNC_BACKGROUND_SCHEDULER_THREAD=1` restores a dedicated thread.
+
+### Fixed
+
+- The saturated-queue wake-up fires from `TaskGroup#on_release`, after the job
+  has left `@jobs`. Signalling from the task's `ensure` left the listener
+  seeing a full group on any scheduler that resumes `unblock` immediately.
+- `Runtime.with_timeout` calls `scheduler.timeout_after` when the hook exists.
+  The `::Timeout.timeout` fallback uses `Thread#raise` and can hit the wrong
+  fiber; a missing hook now warns once per scheduler class.
+- `SocketWaker#close` stops the accept loop before the self-connect that
+  unblocks it, and hangs up tracked client sockets. A fiber parked in
+  `IO#wait_readable` is not cancellable via `Task#stop` on a scheduler without
+  `#fiber_interrupt`.
+- `Runtime.error_handler` is scoped per runner (`on_error:` /
+  `with_error_handler`). A process-global handler was overwritten by the next
+  runner and never restored.
+- A failure awaited via `Task#wait` is no longer also sent to the error handler.
+- `Semaphore.new(0)` raises `ArgumentError` instead of deadlocking on acquire.
+
+### Changed
+
+- `async` is a development dependency. Runtime gems are `console`, `fugit`
+  and `base64`.
+- `SocketWaker#start_accept_loop` no longer needs a parent task (the
+  argument is still accepted and ignored).
+- Shutdown closes the waker before the store, so the listener cannot be inside
+  `Store#fetch` when the connection disappears.
+
+### Unchanged
+
+- Dashboard, `perform_async` / `perform_in` / `perform_at`, SQLite schema,
+  and the cross-process wake protocol.
+
 ## 1.0.2
 
 Queue maintenance bug fix plus profiler-driven work on the hot paths that

data/README.md

@@ -1,8 +1,8 @@
 # Async::Background
 
-A lightweight cron, interval, and job-queue scheduler for Ruby's
-[Async](https://github.com/socketry/async) ecosystem. Built for
-[Falcon](https://github.com/socketry/falcon), works with any Async app.
+A lightweight cron, interval, and job-queue scheduler for Ruby fibers.
+Works with any `Fiber::Scheduler` — [Falcon](https://github.com/socketry/falcon) /
+[Async](https://github.com/socketry/async), [Itsi](https://itsi.fyi), or your own.
 
 - **Cron & interval scheduling** on a single event loop with a min-heap.
 - **Dynamic job queue** backed by SQLite, with delayed jobs
@@ -15,11 +15,11 @@ A lightweight cron, interval, and job-queue scheduler for Ruby's
 
 ---
 
-## Why Async? Why fibers?
+## Why fibers?
 
-The whole gem is built around the assumption that Falcon's reactor schedules
-many fibers on top of one OS thread per process — so the dashboard's SSE
-stream, the cron scheduler, and the queue worker all share that one thread
+The whole gem is built around the assumption that the host schedules many
+fibers on top of one OS thread per process — so the dashboard's SSE stream,
+the cron scheduler, and the queue worker all share that one thread
 cooperatively. A blocked fiber yields; a blocked thread doesn't.
 
 ![Threads vs fibers under different Ruby web servers](docs/fibers-vs-threads.svg)
@@ -30,13 +30,31 @@ open tab.
 
 ---
 
+## Fiber scheduler
+
+`Runner#run` does not start a reactor. The host must install a
+`Fiber.scheduler` first:
+
+```ruby
+Async { runner.run }  # Falcon / Async
+
+require "async/background/scheduler"
+Async::Background::Scheduler.run { runner.run }  # ASYNC_BACKGROUND_SCHEDULER=async|itsi
+```
+
+Without a scheduler it raises `Runtime::SchedulerRequired`.
+Worker setup for Falcon and Itsi is in [Get started](docs/GET_STARTED.md).
+
+---
+
 ## Requirements
 
 | Dependency           | Version          | Required?            |
 | -------------------- | ---------------- | -------------------- |
 | Ruby                 | `>= 3.3`         | yes                  |
-| `async`              | `~> 2.0`         | yes                  |
+| a `Fiber::Scheduler` | `async ~> 2.0`, `itsi-scheduler`, … | yes — installed by the host, not by this gem |
 | `fugit`              | `~> 1.0`         | yes                  |
+| `console`            | `~> 1.0`         | yes                  |
 | `sqlite3`            | `~> 2.0`         | for the queue & dashboard |
 | `async-utilization`  | `>= 0.3, < 0.5`  | for metrics          |
 
@@ -48,16 +66,16 @@ open tab.
 # Gemfile
 gem "async-background"
 
-gem "sqlite3",           "~> 2.0"          # if you use the queue or dashboard
-gem "async-utilization", ">= 0.3", "< 0.5" # if you want worker metrics
+gem "async", "~> 2.0"          # or `itsi-scheduler`
+gem "sqlite3", "~> 2.0"        # queue / dashboard
+gem "async-utilization", ">= 0.3", "< 0.5"  # optional metrics
 ```
 
 ---
 
 ## ➡️ [Get started](docs/GET_STARTED.md)
 
-A four-step walkthrough: schedule config, Falcon integration, Docker, queue,
-delayed jobs.
+Schedule config, Falcon or Itsi workers, Docker, queue, delayed jobs.
 
 ---
 
@@ -120,9 +138,12 @@ jobs use wall-clock time, because "every day at 3am" needs to mean 3am.
 
 ## How it works
 
-A single Async task sleeps until the next entry is due, then dispatches it
-under a semaphore that caps concurrency. Overlapping ticks are skipped and
-rescheduled.
+A single fiber sleeps until the next entry is due, then dispatches it under a
+semaphore that caps concurrency. Overlapping ticks are skipped and rescheduled.
+Every dispatched job is tracked in a `Runtime::TaskGroup`, so shutdown drains
+in-flight work before the SQLite store and the wake-up socket are closed. The
+drain is bounded by `drain_timeout:` (30s by default; pass `nil` for the old
+unbounded wait) so one wedged job cannot turn SIGTERM into SIGKILL.
 
 ```
 schedule.yml → build_heap → MinHeap<Entry> → scheduler loop → Semaphore → run_job

data/async-background.gemspec

@@ -8,12 +8,13 @@ Gem::Specification.new do |spec|
   spec.authors = ['Roman Hajdarov']
   spec.email   = ['romnhajdarov@gmail.com']
 
-  spec.summary     = 'Lightweight heap-based cron/interval scheduler for Async.'
-  spec.description = 'A production-grade lightweight scheduler built on top of Async. ' \
-                     'Single event loop with min-heap timer, skip-overlapping execution, ' \
-                     'jitter, monotonic clock intervals, semaphore concurrency control, ' \
-                     'and deterministic worker sharding. Designed for Falcon but works ' \
-                     'with any Async-based application.'
+  spec.summary     = 'Lightweight heap-based cron/interval scheduler for any Fiber scheduler.'
+  spec.description = 'A production-grade lightweight background job scheduler built on the ' \
+                     'Fiber::Scheduler interface itself, not on any one implementation: it ' \
+                     'runs under Async/Falcon, Itsi, or anything else that installs a ' \
+                     'scheduler. Single event loop with min-heap timer, skip-overlapping ' \
+                     'execution, jitter, monotonic clock intervals, semaphore concurrency ' \
+                     'control, and deterministic worker sharding.'
 
   spec.homepage = 'https://github.com/roman-haidarov/async-background'
   spec.license  = 'MIT'
@@ -30,15 +31,20 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 3.3'
 
-  spec.add_dependency 'async',   '~> 2.0'
+  # No scheduler dependency on purpose. The gem uses the Fiber::Scheduler
+  # interface (Fiber.schedule, #block/#unblock, Timeout) and requires the host
+  # to install an implementation.
   spec.add_dependency 'console', '~> 1.0'
   spec.add_dependency 'fugit',   '~> 1.0'
   spec.add_dependency 'base64',  '~> 0.2'
 
   # Optional: add to your own Gemfile if you need these features
+  #   gem 'async', '~> 2.0'                      # or any other Fiber scheduler
+  #   gem 'itsi-scheduler'                       # ... such as this one
   #   gem 'sqlite3', '~> 2.0'
   #   gem 'async-utilization', '>= 0.3', '< 0.5' # shared-memory worker metrics
 
+  spec.add_development_dependency 'async', '~> 2.0'
   spec.add_development_dependency 'rake',  '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.12'
   spec.add_development_dependency 'rack',  '~> 3.0'

data/lib/async/background/job.rb

@@ -8,42 +8,81 @@ module Async
       BACKOFFS        = %i[fixed linear exponential].freeze
       DEFAULT_JITTER_FOR = { fixed: 0.0, linear: 0.0, exponential: 0.5 }.freeze
 
+      NormalizedOptions = Data.define(:timeout, :retries, :retry_delay, :backoff, :attempt, :jitter)
+      private_constant :NormalizedOptions
+
       Options = Data.define(:timeout, :retry, :retry_delay, :backoff, :attempt, :jitter) do
         def initialize(timeout: DEFAULT_TIMEOUT, retry: 0, retry_delay: nil, backoff: :fixed, attempt: nil, jitter: nil)
-          timeout     = Integer(timeout)
-          retries     = Integer(binding.local_variable_get(:retry) || 0)
-          retry_delay = Float(retry_delay) unless retry_delay.nil?
-          backoff     = backoff.to_sym
-          attempt     = Integer(attempt) unless attempt.nil?
-          jitter      = Float(jitter) unless jitter.nil?
-
-          raise ArgumentError, "timeout must be > 0"                        unless timeout.positive?
-          raise ArgumentError, "retry must be >= 0"                         if     retries.negative?
-          raise ArgumentError, "attempt must be >= 0"                       if     attempt && attempt.negative?
-          raise ArgumentError, "backoff must be one of #{BACKOFFS.inspect}" unless BACKOFFS.include?(backoff)
-          if retries.positive?
-            raise ArgumentError, "retry_delay is required when retry > 0" if retry_delay.nil?
-            raise ArgumentError, "retry_delay must be > 0"                unless retry_delay.positive?
-          end
-          raise ArgumentError, "jitter must be in [0, 1]" if jitter && !(0.0..1.0).cover?(jitter)
-
-          super(timeout:, retry: retries, retry_delay:, backoff:, attempt:, jitter:)
+          retries = Integer(binding.local_variable_get(:retry) || 0)
+          settings = NormalizedOptions.new(
+            Integer(timeout), retries, retry_delay.nil? ? nil : Float(retry_delay), backoff.to_sym,
+            attempt.nil? ? nil : Integer(attempt), jitter.nil? ? nil : Float(jitter)
+          )
+          validate_options!(settings)
+          super(timeout: settings.timeout, retry: settings.retries, retry_delay: settings.retry_delay,
+                backoff: settings.backoff, attempt: settings.attempt, jitter: settings.jitter)
         end
 
         def retry?          = self.retry.positive?
         def attempts_made   = attempt || 0
         def next_attempt    = attempts_made + 1
         def with_attempt(n) = with(attempt: Integer(n))
+
         def next_retry_delay(for_attempt = next_attempt, rng: Random)
-          raise ArgumentError, "attempt must be > 0" unless for_attempt.positive?
-          raise ArgumentError, "retry_delay must be configured" if retry_delay.nil?
+          raise ArgumentError, 'attempt must be > 0' unless for_attempt.positive?
+          raise ArgumentError, 'retry_delay must be configured' if retry_delay.nil?
 
-          base = case backoff
-          when :fixed       then retry_delay
-          when :linear      then retry_delay * for_attempt
-          when :exponential then retry_delay * (2**(for_attempt - 1))
-          end
+          apply_jitter(base_retry_delay(for_attempt), rng)
+        end
+
+        private
+
+        def validate_options!(settings)
+          validate_timeout!(settings.timeout)
+          validate_retry_count!(settings.retries)
+          validate_attempt!(settings.attempt)
+          validate_backoff!(settings.backoff)
+          validate_retry_delay!(settings)
+          validate_jitter!(settings.jitter)
+        end
 
+        def validate_timeout!(timeout)
+          raise ArgumentError, 'timeout must be > 0' unless timeout.positive?
+        end
+
+        def validate_retry_count!(retries)
+          raise ArgumentError, 'retry must be >= 0' if retries.negative?
+        end
+
+        def validate_attempt!(attempt)
+          raise ArgumentError, 'attempt must be >= 0' if attempt&.negative?
+        end
+
+        def validate_backoff!(backoff)
+          raise ArgumentError, "backoff must be one of #{BACKOFFS.inspect}" unless BACKOFFS.include?(backoff)
+        end
+
+        def validate_retry_delay!(settings)
+          return unless settings.retries.positive?
+
+          raise ArgumentError, 'retry_delay is required when retry > 0' if settings.retry_delay.nil?
+          raise ArgumentError, 'retry_delay must be > 0' unless settings.retry_delay.positive?
+        end
+
+        def validate_jitter!(jitter)
+          raise ArgumentError, 'jitter must be in [0, 1]' if jitter && !(0.0..1.0).cover?(jitter)
+        end
+
+        def base_retry_delay(for_attempt)
+          multiplier = case backoff
+                       when :fixed then 1
+                       when :linear then for_attempt
+                       when :exponential then 2**(for_attempt - 1)
+                       end
+          retry_delay * multiplier
+        end
+
+        def apply_jitter(base, rng)
           factor = jitter || DEFAULT_JITTER_FOR[backoff]
           factor.zero? ? base : base * (1 + rng.rand * factor)
         end
@@ -56,9 +95,17 @@ module Async
       module ClassMethods
         def perform_now(*args) = new.perform(*args)
 
-        def perform_async(*args, options: EMPTY_OPTIONS)     = Async::Background::Queue.enqueue(self, *args, options: options)
-        def perform_in(delay, *args, options: EMPTY_OPTIONS) = Async::Background::Queue.enqueue_in(delay, self, *args, options: options)
-        def perform_at(time, *args, options: EMPTY_OPTIONS)  = Async::Background::Queue.enqueue_at(time, self, *args, options: options)
+        def perform_async(*args, options: EMPTY_OPTIONS)
+          Async::Background::Queue.enqueue(self, *args, options: options)
+        end
+
+        def perform_in(delay, *args, options: EMPTY_OPTIONS)
+          Async::Background::Queue.enqueue_in(delay, self, *args, options: options)
+        end
+
+        def perform_at(time, *args, options: EMPTY_OPTIONS)
+          Async::Background::Queue.enqueue_at(time, self, *args, options: options)
+        end
 
         def options(**values)
           @options = Options.new(**values).to_h.compact

data/lib/async/background/metrics.rb

@@ -29,53 +29,57 @@ module Async
 
         validate_worker!(worker_index, total_workers)
         initialize_registry!(worker_index, total_workers, shm_path)
-      rescue LoadError => error
-        mark_unavailable!(error)
+      rescue LoadError => e
+        mark_unavailable!(e)
       end
 
       def enabled? = @enabled
 
-      def job_started(_entry)
-        return unless enabled?
+      module JobEvents
+        def job_started(_entry)
+          return unless enabled?
 
-        increment(:total_runs)
-        increment(:active_jobs)
-        set(:last_run_at, Process.clock_gettime(Process::CLOCK_REALTIME).to_i)
-      end
+          increment(:total_runs)
+          increment(:active_jobs)
+          set(:last_run_at, Process.clock_gettime(Process::CLOCK_REALTIME).to_i)
+        end
 
-      def job_succeeded(_entry, duration)
-        return unless enabled?
+        def job_succeeded(_entry, duration)
+          return unless enabled?
 
-        increment(:total_successes)
-        set(:last_duration_ms, duration_to_milliseconds(duration))
-      end
+          increment(:total_successes)
+          set(:last_duration_ms, duration_to_milliseconds(duration))
+        end
 
-      def job_finished(entry, duration)
-        job_succeeded(entry, duration)
-        job_stopped(entry)
-      end
+        def job_finished(entry, duration)
+          job_succeeded(entry, duration)
+          job_stopped(entry)
+        end
 
-      def job_failed(_entry, _error)
-        increment(:total_failures) if enabled?
-      end
+        def job_failed(_entry, _error)
+          increment(:total_failures) if enabled?
+        end
 
-      def job_timed_out(_entry)
-        increment(:total_timeouts) if enabled?
-      end
+        def job_timed_out(_entry)
+          increment(:total_timeouts) if enabled?
+        end
 
-      def job_stopped(_entry)
-        decrement(:active_jobs) if enabled?
-      end
+        def job_stopped(_entry)
+          decrement(:active_jobs) if enabled?
+        end
 
-      def job_skipped(_entry)
-        increment(:total_skips) if enabled?
+        def job_skipped(_entry)
+          increment(:total_skips) if enabled?
+        end
       end
+      private_constant :JobEvents
+      include JobEvents
 
       def values
         enabled? ? registry.values : {}
       end
 
-      class << self
+      module Reader
         def available?
           load_utilization!
           true
@@ -138,6 +142,8 @@ module Async
         end
       end
 
+      extend Reader
+
       private
 
       def initialize_registry!(worker_index, total_workers, path)
@@ -145,9 +151,7 @@ module Async
         ensure_shm!(total_workers, path)
 
         @registry = ::Async::Utilization::Registry.new
-        unless @registry.respond_to?(:metric)
-          raise LoadError, 'async-utilization >= 0.3 is required for metrics'
-        end
+        raise LoadError, 'async-utilization >= 0.3 is required for metrics' unless @registry.respond_to?(:metric)
 
         attach_observer!(worker_index, path)
         @metric_handles = SCHEMA_FIELDS.keys.to_h { |name| [name, @registry.metric(name)] }.freeze
@@ -196,7 +200,11 @@ module Async
           file.flock(File::LOCK_EX)
           file.truncate(mapped_size) if file.size < mapped_size
         ensure
-          file.flock(File::LOCK_UN) rescue nil
+          begin
+            file.flock(File::LOCK_UN)
+          rescue StandardError
+            nil
+          end
         end
       end
 

data/lib/async/background/min_heap.rb

@@ -41,7 +41,7 @@ module Async
       private
 
       def sift_up(i)
-        while i > 0
+        while i.positive?
           parent = (i - 1) >> 1
           break if @data[parent].next_run_at <= @data[i].next_run_at
 
@@ -50,20 +50,24 @@ module Async
         end
       end
 
-      def sift_down(i)
-        while true
-          smallest = i
-          left  = (i << 1) + 1
-          right = left + 1
+      def sift_down(index)
+        loop do
+          child = smallest_child(index)
+          break if child == index
 
-          smallest = left  if left < @data.size && @data[left].next_run_at < @data[smallest].next_run_at
-          smallest = right if right < @data.size && @data[right].next_run_at < @data[smallest].next_run_at
+          swap(index, child)
+          index = child
+        end
+      end
 
-          break if smallest == i
+      def smallest_child(index)
+        left = (index << 1) + 1
+        right = left + 1
+        smallest = index
 
-          swap(i, smallest)
-          i = smallest
-        end
+        smallest = left if left < @data.size && @data[left].next_run_at < @data[smallest].next_run_at
+        smallest = right if right < @data.size && @data[right].next_run_at < @data[smallest].next_run_at
+        smallest
       end
 
       def swap(a, b)

data/lib/async/background/queue/client.rb

@@ -43,17 +43,20 @@ module Async
 
         def enqueue(job_class, *args, options: EMPTY_OPTIONS)
           ensure_configured!
-          default_client.push(resolve_class_name(job_class), normalized_args(args), nil, options: build_options(job_class, options))
+          default_client.push(resolve_class_name(job_class), normalized_args(args), nil,
+                              options: build_options(job_class, options))
         end
 
         def enqueue_in(delay, job_class, *args, options: EMPTY_OPTIONS)
           ensure_configured!
-          default_client.push_in(delay, resolve_class_name(job_class), normalized_args(args), options: build_options(job_class, options))
+          default_client.push_in(delay, resolve_class_name(job_class), normalized_args(args),
+                                 options: build_options(job_class, options))
         end
 
         def enqueue_at(time, job_class, *args, options: EMPTY_OPTIONS)
           ensure_configured!
-          default_client.push_at(time, resolve_class_name(job_class), normalized_args(args), options: build_options(job_class, options))
+          default_client.push_at(time, resolve_class_name(job_class), normalized_args(args),
+                                 options: build_options(job_class, options))
         end
 
         private
@@ -79,7 +82,7 @@ module Async
         end
 
         def ensure_configured!
-          raise "Async::Background::Queue not configured" unless default_client
+          raise 'Async::Background::Queue not configured' unless default_client
         end
 
         def normalized_args(args) = args.empty? ? EMPTY_ARGS : args
@@ -95,10 +98,10 @@ module Async
           return EMPTY_OPTIONS unless job_class.respond_to?(:resolve_options)
 
           options = if job_class.respond_to?(:queue_options)
-            job_class.queue_options
-          else
-            job_class.resolve_options
-          end
+                      job_class.queue_options
+                    else
+                      job_class.resolve_options
+                    end
 
           options.empty? ? EMPTY_OPTIONS : options
         end

data/lib/async/background/queue/options.rb

@@ -6,9 +6,9 @@ module Async
       EMPTY_ARGS = [].freeze
       EMPTY_OPTIONS = {}.freeze
 
-      SYNCHRONOUS_LEVELS = {normal: 'NORMAL', full: 'FULL', extra: 'EXTRA'}.freeze
+      SYNCHRONOUS_LEVELS = { normal: 'NORMAL', full: 'FULL', extra: 'EXTRA' }.freeze
       WAL_AUTOCHECKPOINT_RANGE = 100..10_000
-      DEFAULT_STORE_OPTIONS = {mmap: true, synchronous: :normal, wal_autocheckpoint: 1_000}.freeze
+      DEFAULT_STORE_OPTIONS = { mmap: true, synchronous: :normal, wal_autocheckpoint: 1_000 }.freeze
       DEFAULTS = DEFAULT_STORE_OPTIONS
       MMAP_SIZE = 268_435_456
 
@@ -45,7 +45,7 @@ module Async
         private
 
         def validate_mmap!(value)
-          return if value == true || value == false
+          return if [true, false].include?(value)
 
           raise ArgumentError, "mmap must be true or false, got #{value.inspect}"
         end