retriable 3.2.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8df6a3c9b00afd6e5f3e307fdb07d3cedae54c43b4f3537998ebae78dd17ab29
-  data.tar.gz: 46023d8f2d1731ea9a3c66c61839b04aa49b18d3def72d1ea1fc36d9c9e7a1c3
+  metadata.gz: c0e8971cb9e6833e2795f2537ee69950714f7eb85989b497d15fad7f2e2552b6
+  data.tar.gz: 222c0e1664bf327dfb22cf161c42a3f3bec07a54ea3787af24a86ebd86abcd50
 SHA512:
-  metadata.gz: cd71b6a0a42cb2c6482409bcbc42d57504c5f601aa33e80d8a032dd97e31df582234bbb8959c1cf70eb92b7cf67c650497820be5b219053322317cbb7d748efa
-  data.tar.gz: 617c7c1785c0b7691655615484251b8b591afa43d211d0ea4ef0d94def9747e84814dbdbe9095c388c112a9957c6050d17ba4c3044bb2e2f299bf4d892f6fd04
+  metadata.gz: b768d200c1dd25f9a5218096e5bba26b0ee815833fb87ed6a004d90d7f94208f4520df0fdb1172fc6fdea55209cf1eeb15d6efc39a52bd2f32c0222b5aecca5a
+  data.tar.gz: 0a095f55fcdbe49adf71bb06682c062ed98a4328ef0e4648926e6782b93152c337cd78b2f30a2bf5a79affc37c31c3f2b39730600c3c63b5dcb41d5c09b59380

data/.github/workflows/main.yml

@@ -2,9 +2,9 @@ name: CI
 
 on:
   push:
-    branches: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
     types: [opened, synchronize, reopened]
 
 jobs:

data/.gitignore

@@ -4,6 +4,8 @@
 /_yardoc/
 /coverage/
 /doc/
+/docs/plans/
+/.worktrees/
 /pkg/
 /spec/reports/
 /tmp/

data/.rubocop.yml

@@ -1,3 +1,7 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.3
+
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
@@ -13,12 +17,6 @@ Style/TrailingCommaInArguments:
 Lint/InheritException:
   Enabled: false
 
-Layout/FirstArrayElementIndentation:
-  Enabled: false
-
-Layout/FirstHashElementIndentation:
-  Enabled: false
-
 Style/NegatedIf:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,7 +1,13 @@
 # HEAD
 
+## 3.3.0
+
+- Refactor `Retriable.retriable` internals into focused private helpers to improve readability while preserving behavior.
+- Modernize `.rubocop.yml` with explicit modern defaults to enable new cops while preserving existing project style policies.
+
 ## 3.2.1
-- Remove executables from gemspec as it was poluting the path for some users. Thanks @hsbt.
+
+- Remove executables from gemspec as it was polluting the path for some users. Thanks @hsbt.
 
 ## 3.2.0
 

data/lib/retriable/exponential_backoff.rb

@@ -2,12 +2,12 @@
 
 module Retriable
   class ExponentialBackoff
-    ATTRIBUTES = [
-      :tries,
-      :base_interval,
-      :multiplier,
-      :max_interval,
-      :rand_factor,
+    ATTRIBUTES = %i[
+      tries
+      base_interval
+      multiplier
+      max_interval
+      rand_factor
     ].freeze
 
     attr_accessor(*ATTRIBUTES)
@@ -21,6 +21,7 @@ module Retriable
 
       opts.each do |k, v|
         raise ArgumentError, "#{k} is not a valid option" if !ATTRIBUTES.include?(k)
+
         instance_variable_set(:"@#{k}", v)
       end
     end

data/lib/retriable/version.rb

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

data/lib/retriable.rb

@@ -21,61 +21,113 @@ module Retriable
       raise ArgumentError, "#{context_key} not found in Retriable.config.contexts. Available contexts: #{config.contexts.keys}"
     end
 
-    retriable(config.contexts[context_key].merge(options), &block) if block
+    return unless block_given?
+
+    retriable(config.contexts[context_key].merge(options), &block)
   end
 
-  def retriable(opts = {})
+  def retriable(opts = {}, &block)
     local_config = opts.empty? ? config : Config.new(config.to_h.merge(opts))
 
-    tries             = local_config.tries
-    base_interval     = local_config.base_interval
-    max_interval      = local_config.max_interval
-    rand_factor       = local_config.rand_factor
-    multiplier        = local_config.multiplier
-    max_elapsed_time  = local_config.max_elapsed_time
-    intervals         = local_config.intervals
-    timeout           = local_config.timeout
-    on                = local_config.on
-    on_retry          = local_config.on_retry
-    sleep_disabled    = local_config.sleep_disabled
+    tries = local_config.tries
+    intervals = build_intervals(local_config, tries)
+    timeout = local_config.timeout
+    on = local_config.on
+    on_retry = local_config.on_retry
+    sleep_disabled = local_config.sleep_disabled
+    max_elapsed_time = local_config.max_elapsed_time
 
     exception_list = on.is_a?(Hash) ? on.keys : on
+    exception_list = [*exception_list]
     start_time = Time.now
     elapsed_time = -> { Time.now - start_time }
 
-    if !intervals
-      intervals = ExponentialBackoff.new(
-        tries:          tries - 1,
-        base_interval:  base_interval,
-        multiplier:     multiplier,
-        max_interval:   max_interval,
-        rand_factor:    rand_factor
-      ).intervals
-    end
-
     tries = intervals.size + 1
 
+    execute_tries(
+      tries: tries, intervals: intervals, timeout: timeout,
+      exception_list: exception_list, on: on, on_retry: on_retry,
+      elapsed_time: elapsed_time, max_elapsed_time: max_elapsed_time,
+      sleep_disabled: sleep_disabled, &block
+    )
+  end
+
+  def execute_tries( # rubocop:disable Metrics/ParameterLists
+    tries:, intervals:, timeout:, exception_list:,
+    on:, on_retry:, elapsed_time:, max_elapsed_time:, sleep_disabled:, &block
+  )
     tries.times do |index|
       try = index + 1
 
       begin
-        return Timeout.timeout(timeout) { return yield(try) } if timeout
-
-        return yield(try)
-      rescue *[*exception_list] => exception
-        if on.is_a?(Hash)
-          raise unless exception_list.any? do |e|
-            exception.is_a?(e) && ([*on[e]].empty? || [*on[e]].any? { |pattern| exception.message =~ pattern })
-          end
-        end
+        return call_with_timeout(timeout, try, &block)
+      rescue *exception_list => e
+        raise unless retriable_exception?(e, on, exception_list)
 
         interval = intervals[index]
-        on_retry.call(exception, try, elapsed_time.call, interval) if on_retry
+        call_on_retry(on_retry, e, try, elapsed_time.call, interval)
 
-        raise if try >= tries || (elapsed_time.call + interval) > max_elapsed_time
+        raise unless can_retry?(try, tries, elapsed_time.call, interval, max_elapsed_time)
 
         sleep interval if sleep_disabled != true
       end
     end
   end
+
+  def build_intervals(local_config, tries)
+    return local_config.intervals if local_config.intervals
+
+    ExponentialBackoff.new(
+      tries: tries - 1,
+      base_interval: local_config.base_interval,
+      multiplier: local_config.multiplier,
+      max_interval: local_config.max_interval,
+      rand_factor: local_config.rand_factor,
+    ).intervals
+  end
+
+  def call_with_timeout(timeout, try)
+    return Timeout.timeout(timeout) { yield(try) } if timeout
+
+    yield(try)
+  end
+
+  def call_on_retry(on_retry, exception, try, elapsed_time, interval)
+    return unless on_retry
+
+    on_retry.call(exception, try, elapsed_time, interval)
+  end
+
+  def can_retry?(try, tries, elapsed_time, interval, max_elapsed_time)
+    try < tries && (elapsed_time + interval) <= max_elapsed_time
+  end
+
+  # When `on` is a Hash, we need to verify the exception matches a pattern.
+  # For any non-Hash `on` value (e.g., Array of classes, single Exception class,
+  # or Module), the `rescue *exception_list` clause already guarantees the
+  # exception is retriable, so we return true unconditionally.
+  def retriable_exception?(exception, on, exception_list)
+    return false if on.is_a?(Hash) && !hash_exception_match?(exception, on, exception_list)
+
+    true
+  end
+
+  def hash_exception_match?(exception, on, exception_list)
+    exception_list.any? do |error_class|
+      next false unless exception.is_a?(error_class)
+
+      patterns = [*on[error_class]]
+      patterns.empty? || patterns.any? { |pattern| exception.message =~ pattern }
+    end
+  end
+
+  private_class_method(
+    :execute_tries,
+    :build_intervals,
+    :call_with_timeout,
+    :call_on_retry,
+    :can_retry?,
+    :retriable_exception?,
+    :hash_exception_match?,
+  )
 end

data/retriable.gemspec

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-lib = File.expand_path("../lib", __FILE__)
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "retriable/version"
 
@@ -9,7 +10,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Jack Chu"]
   spec.email         = ["jack@jackchu.com"]
   spec.summary       = "Retriable is a simple DSL to retry failed code blocks with randomized exponential backoff"
-  spec.description   = "Retriable is a simple DSL to retry failed code blocks with randomized exponential backoff. This is especially useful when interacting external api/services or file system calls."
+  spec.description   = "Retriable is a simple DSL to retry failed code blocks with randomized " \
+                       "exponential backoff. This is especially useful when interacting with external " \
+                       "APIs/services or file system calls."
   spec.homepage      = "https://github.com/kamui/retriable"
   spec.license       = "MIT"
 

data/spec/retriable_spec.rb

@@ -96,6 +96,28 @@ describe Retriable do
       expect(@tries).to eq(10)
     end
 
+    it "does not call on_retry when explicitly set to false" do
+      callback_called = false
+      original_on_retry = described_class.config.on_retry
+
+      begin
+        described_class.configure do |c|
+          c.on_retry = proc { |_exception, _try, _elapsed_time, _next_interval| callback_called = true }
+        end
+
+        expect do
+          described_class.retriable(on_retry: false, tries: 3) { increment_tries_with_exception }
+        end.to raise_error(StandardError)
+
+        expect(@tries).to eq(3)
+        expect(callback_called).to be(false)
+      ensure
+        described_class.configure do |c|
+          c.on_retry = original_on_retry
+        end
+      end
+    end
+
     context "with rand_factor 0.0 and an on_retry handler" do
       let(:tries) { 6 }
       let(:no_rand_timetable) { { 1 => 0.5, 2 => 0.75, 3 => 1.125 } }
@@ -255,6 +277,17 @@ describe Retriable do
   end
 
   context "#configure" do
+    it "exposes only the intended public API" do
+      public_api_methods = %i[
+        retriable
+        with_context
+        configure
+        config
+      ]
+
+      expect(described_class.singleton_methods(false)).to match_array(public_api_methods)
+    end
+
     it "raises NoMethodError on invalid configuration" do
       expect { described_class.configure { |c| c.does_not_exist = 123 } }.to raise_error(NoMethodError)
     end
@@ -275,6 +308,22 @@ describe Retriable do
       expect(@tries).to eq(1)
     end
 
+    it "returns nil when called without a block" do
+      expect(described_class.with_context(:sql)).to be_nil
+      expect(@tries).to eq(0)
+    end
+
+    it "passes try count through to the context block" do
+      seen_tries = []
+
+      described_class.with_context(:api) do |try|
+        seen_tries << try
+        raise StandardError if try < 3
+      end
+
+      expect(seen_tries).to eq([1, 2, 3])
+    end
+
     it "respects the context options" do
       expect { described_class.with_context(:api) { increment_tries_with_exception } }.to raise_error(StandardError)
       expect(@tries).to eq(api_tries)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: retriable
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.3.0
 platform: ruby
 authors:
 - Jack Chu
@@ -52,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.1'
 description: Retriable is a simple DSL to retry failed code blocks with randomized
-  exponential backoff. This is especially useful when interacting external api/services
+  exponential backoff. This is especially useful when interacting with external APIs/services
   or file system calls.
 email:
 - jack@jackchu.com