retriable 4.0.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 392e6bc1b69a4c85c286f5df1b90c5991243cd7290cd3b41c028f253ad16dae4
-  data.tar.gz: f078e585b65160045cc71e4a9f8746b7b480645cf841ff13a7bbbec78fc9ffeb
+  metadata.gz: 5961397b426eeaf2d2df8631f0a5dfe05adf52d5b9070ddbdf7b7825fd88f144
+  data.tar.gz: c982809ef09eb85ddedfcee95be53741846f6e4438af27e403c9ad4b020214c1
 SHA512:
-  metadata.gz: 01dc250d04fbc71c89d6af526ab061ec4439d382ec50872776859415df9bad2d1d4c8f2e0cfb53fc263343d72871ce691df5840721d33caf0ccaacee03bf9f6e
-  data.tar.gz: f1ae42a3015541313322371fd297f5f677d1a974747b48a524c25e1f676fc7adeb8d309975851198c69632fc124a34e4db5488486783a40beb8758ef12cf6c01
+  metadata.gz: 30d8bfeeff407ab15fa9be7c2af2993142dce86d8406318e220afdb111c728b0c8c7cd2d6b105312ed9623074a5b20c88a9c19a6c33c3169d673d2276e0b52c4
+  data.tar.gz: f333fbf26eff94629f85f5d58688245025be3f39830bcad59da7f42ab52ad1506b155c03e1d96020a728b489ed016cb8ee1fcd5cde0a7a0ce3cfe59ad078c4d8

data/.github/workflows/main.yml

@@ -30,8 +30,6 @@ jobs:
             "4.0",
             jruby,
           ]
-    env:
-      CC_TEST_REPORTER_ID: 20a1139ef1830b4f813a10a03d90e8aa179b5226f75e75c5a949b25756ebf558
 
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
@@ -63,3 +61,21 @@ jobs:
 
       - name: Run rubocop
         run: bundle exec rubocop
+
+      - name: Validate RBS
+        run: bundle exec rbs -I sig validate
+
+  audit:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+
+      - name: Setup ruby
+        uses: ruby/setup-ruby@afeafc3d1ab54a631816aba4c914a0081c12ff2f # v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: true
+
+      - name: Run bundler-audit
+        run: bundle exec bundle-audit check --update

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # HEAD
 
+## 4.1.1
+
+### Bug fixes
+
+- `retry_if`, `on_retry`, and `on_give_up` are now validated to be callable
+  (respond to `#call`) or falsy. A non-callable truthy value raises
+  `ArgumentError` at configuration time instead of a later `NoMethodError` on a
+  retry path. ([#140](https://github.com/kamui/retriable/pull/140))
+
+### Internal
+
+- Add RBS type signatures for the public API (`Retriable.configure`, `config`,
+  `retriable`, `with_override`, `with_context`, and `Retriable::Config`) and
+  validate them in CI with `rbs validate`.
+  ([#142](https://github.com/kamui/retriable/pull/142))
+- Enforce a minimum test coverage floor and add a `bundler-audit` dependency
+  audit job to CI. ([#143](https://github.com/kamui/retriable/pull/143))
+- Remove an unused `CC_TEST_REPORTER_ID` from the CI workflow.
+  ([#141](https://github.com/kamui/retriable/pull/141))
+
+## 4.1.0
+
+### Bug fixes
+
+- A per-call or `with_context` `tries:` now clears an inherited `intervals:` from
+  global config or a context, matching the documented precedence. Previously
+  `Retriable.retriable(tries: 1)` was silently ignored when `intervals` was
+  configured, running `intervals.size + 1` times. Passing both `intervals:` and
+  `tries:` in the same call still lets `intervals:` win.
+
 ## 4.0.0
 
 **This is a major release with breaking changes. Please read carefully before upgrading.**

data/Gemfile

@@ -10,7 +10,9 @@ group :test do
 end
 
 group :development do
+  gem "bundler-audit", "~> 0.9"
   gem "listen", "~> 3.1"
+  gem "rbs", "~> 3.0", platforms: :ruby
   gem "rubocop", "~> 1.86"
 end
 

data/README.md

@@ -206,6 +206,11 @@ end
 `#configure` sets defaults only. Per-call options passed to `Retriable.retriable` and
 `Retriable.with_context` still take precedence.
 
+When a higher-precedence layer sets `tries:` without `intervals:`, it clears any
+`intervals:` inherited from a lower layer (so `retriable(tries: 1)` runs once even
+if `intervals` was configured). Within a single call, passing `intervals:` still
+overrides `tries:`.
+
 ### Override
 
 `#with_override` is a block-scoped API for forcing retry options that should

data/lib/retriable/config.rb

@@ -51,6 +51,9 @@ module Retriable
     end
 
     def validate!
+      validate_callable(:retry_if, retry_if)
+      validate_callable(:on_retry, on_retry)
+      validate_callable(:on_give_up, on_give_up)
       validate_on(on)
       validate_intervals
       if unbounded_tries?(tries)

data/lib/retriable/validation.rb

@@ -28,6 +28,13 @@ module Retriable
       validate_non_negative_number(name, value)
     end
 
+    def validate_callable(name, value)
+      return unless value # nil/false disable the callback
+      return if value.respond_to?(:call)
+
+      raise ArgumentError, "#{name} must respond to #call or be nil"
+    end
+
     def validate_rand_factor
       return if finite_number?(rand_factor) && rand_factor >= 0 && rand_factor <= 1
 

data/lib/retriable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Retriable
-  VERSION = "4.0.0"
+  VERSION = "4.1.1"
 end

data/lib/retriable.rb

@@ -58,7 +58,7 @@ module Retriable
     local_config = if opts.empty? && !override_config
                      config
                    else
-                     Config.new(apply_override_options(config.to_h.merge(opts), override_config))
+                     Config.new(apply_override_options(merge_layer(config.to_h, opts), override_config))
                    end
 
     # Config is mutable through `configure`, so validate again immediately before use.
@@ -216,9 +216,17 @@ module Retriable
   def apply_override_options(options, overrides)
     return options unless overrides
 
-    options = options.merge(overrides)
-    options[:intervals] = nil if overrides.key?(:tries) && !overrides.key?(:intervals)
-    options
+    merge_layer(options, overrides)
+  end
+
+  # Merge a higher-precedence option layer onto a base layer. A higher layer
+  # that sets `tries` without `intervals` clears the base layer's inherited
+  # `intervals`, so a caller's `tries:` is never silently ignored. When the
+  # higher layer supplies its own `intervals`, those win (same-call override).
+  def merge_layer(base, higher)
+    merged = base.merge(higher)
+    merged[:intervals] = nil if higher.key?(:tries) && !higher.key?(:intervals)
+    merged
   end
 
   def available_contexts
@@ -228,7 +236,7 @@ module Retriable
   def context_options_for(context_key, options)
     context_options = config_contexts.fetch(context_key, {})
     context_options = {} unless context_options.is_a?(Hash)
-    context_options = context_options.merge(options)
+    context_options = merge_layer(context_options, options)
 
     override_context_options = override_contexts[context_key]
     return context_options unless override_context_options.is_a?(Hash)
@@ -262,6 +270,7 @@ module Retriable
     :retriable_exception?,
     :hash_exception_match?,
     :apply_override_options,
+    :merge_layer,
     :available_contexts,
     :context_options_for,
     :config_contexts,

data/sig/retriable.rbs

@@ -1,4 +1,32 @@
 module Retriable
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  OVERRIDE_THREAD_KEY: Symbol
+
+  def self.configure: () { (Config) -> void } -> void
+  def self.config: () -> Config
+  def self.with_override: (Hash[Symbol, untyped] options) { () -> untyped } -> untyped
+  def self.with_context: (Symbol context_key, ?Hash[Symbol, untyped] options) ?{ (Integer) -> untyped } -> untyped
+  def self.retriable: (?Hash[Symbol, untyped] options) { (Integer) -> untyped } -> untyped
+
+  class Config
+    ATTRIBUTES: Array[Symbol]
+
+    attr_accessor tries: Numeric
+    attr_accessor base_interval: Numeric
+    attr_accessor max_interval: Numeric
+    attr_accessor rand_factor: Numeric
+    attr_accessor multiplier: Numeric
+    attr_accessor sleep_disabled: bool
+    attr_accessor max_elapsed_time: Numeric?
+    attr_accessor intervals: Array[Numeric]?
+    attr_accessor on: untyped
+    attr_accessor retry_if: untyped
+    attr_accessor on_retry: untyped
+    attr_accessor on_give_up: untyped
+    attr_accessor contexts: Hash[Symbol, untyped]
+
+    def initialize: (?Hash[Symbol, untyped] opts) -> void
+    def to_h: () -> Hash[Symbol, untyped]
+    def validate!: () -> void
+  end
 end

data/spec/config_spec.rb

@@ -163,4 +163,21 @@ describe Retriable::Config do
         .to raise_error(ArgumentError, /on must be an Exception class/)
     end
   end
+
+  context "callable option validation" do
+    %i[retry_if on_retry on_give_up].each do |opt|
+      it "accepts a callable for #{opt}" do
+        expect { described_class.new(opt => ->(*) {}) }.not_to raise_error
+      end
+
+      it "accepts nil and false for #{opt}" do
+        expect { described_class.new(opt => nil) }.not_to raise_error
+        expect { described_class.new(opt => false) }.not_to raise_error
+      end
+
+      it "rejects a non-callable truthy value for #{opt}" do
+        expect { described_class.new(opt => 5) }.to raise_error(ArgumentError, /#{opt}.*#call/)
+      end
+    end
+  end
 end

data/spec/retriable_spec.rb

@@ -760,6 +760,38 @@ describe Retriable do
     end
   end
 
+  context "#retriable tries/intervals precedence" do
+    it "lets a per-call tries clear globally configured intervals" do
+      described_class.configure { |c| c.intervals = [0.5, 1.0] }
+
+      expect do
+        described_class.retriable(tries: 1) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      expect(@tries).to eq(1)
+    end
+
+    it "still lets per-call intervals win when both intervals and tries are given" do
+      expect do
+        described_class.retriable(intervals: [0.5, 1.0], tries: 1) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      expect(@tries).to eq(3) # intervals.size + 1
+    end
+
+    it "lets a with_context tries clear context intervals" do
+      described_class.configure do |c|
+        c.contexts[:api] = { intervals: [0.5, 1.0] }
+      end
+
+      expect do
+        described_class.with_context(:api, tries: 1) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      expect(@tries).to eq(1)
+    end
+  end
+
   context "#with_override" do
     it "takes precedence over both global config and local options" do
       described_class.configure { |c| c.tries = 2 }

data/spec/spec_helper.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "simplecov"
-SimpleCov.start
+SimpleCov.start do
+  minimum_coverage 95
+end
 
 require "pry"
 require_relative "../lib/retriable"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: retriable
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.1
 platform: ruby
 authors:
 - Jack Chu