Rename BurstStrategy -> Burst.

samuel-williams-shopify · samuel-williams-shopify · commit 378c0b59ecae · 2025-09-10T00:08:04.000+12:00
diff --git a/context/generic-limiter.md b/context/generic-limiter.md
@@ -101,7 +101,7 @@ Async do
 		# 1-second window:
 		1.0,
 		# Allow bursting:
-		Async::Limiter::Timing::BurstStrategy::Greedy,
+		Async::Limiter::Timing::Burst::Greedy,
 		# 5 operations per second:
 		5
 	)
diff --git a/context/getting-started.md b/context/getting-started.md
@@ -115,7 +115,7 @@ Async do
 	# Max 3 tasks within any 1-second sliding window
 	timing = Async::Limiter::Timing::SlidingWindow.new(
 		1.0, # 1-second window.
-		Async::Limiter::Timing::BurstStrategy::Greedy, # Allow bursting
+		Async::Limiter::Timing::Burst::Greedy, # Allow bursting
 		3 # 3 tasks per window
 	)
 	
diff --git a/context/timing-strategies.md b/context/timing-strategies.md
@@ -43,7 +43,7 @@ Provides smooth rate limiting with continuous rolling time windows:
 # Allow 3 operations within any 1-second sliding window
 timing = Async::Limiter::Timing::SlidingWindow.new(
 	1.0,                                             # 1-second window
-	Async::Limiter::Timing::BurstStrategy::Greedy,   # Burst behavior
+	Async::Limiter::Timing::Burst::Greedy,   # Burst behavior
 	3                                                # 3 operations per window
 )
 
@@ -67,14 +67,14 @@ Different burst behaviors affect how operations are scheduled:
 # Greedy: Allow immediate bursts up to the limit
 greedy_timing = Async::Limiter::Timing::SlidingWindow.new(
 	2.0,                                           # 2-second window
-	Async::Limiter::Timing::BurstStrategy::Greedy, # Allow bursts
+	Async::Limiter::Timing::Burst::Greedy, # Allow bursts
 	6                                              # 6 operations per 2 seconds
 )
 
 # Conservative: Spread operations evenly over time
 conservative_timing = Async::Limiter::Timing::SlidingWindow.new(
 	2.0,                                               # 2-second window
-	Async::Limiter::Timing::BurstStrategy::Conservative, # Even distribution
+	Async::Limiter::Timing::Burst::Conservative, # Even distribution
 	6                                                  # 6 operations per 2 seconds
 )
 
@@ -107,7 +107,7 @@ Operations can consume different amounts of the rate limit:
 ```ruby
 timing = Async::Limiter::Timing::SlidingWindow.new(
 	1.0,                                             # 1-second window
-	Async::Limiter::Timing::BurstStrategy::Greedy,
+	Async::Limiter::Timing::Burst::Greedy,
 	10.0                                             # 10 units per second
 )
 
@@ -143,7 +143,7 @@ Provides rate limiting with discrete time boundaries:
 # Allow 5 operations per 2-second window with fixed boundaries
 timing = Async::Limiter::Timing::FixedWindow.new(
 	2.0,                                             # 2-second windows
-	Async::Limiter::Timing::BurstStrategy::Greedy,   # Allow bursting within window
+	Async::Limiter::Timing::Burst::Greedy,   # Allow bursting within window
 	5                                                # 5 operations per window
 )
 
@@ -166,7 +166,7 @@ end
 # Demonstrate window boundaries
 timing = Async::Limiter::Timing::FixedWindow.new(
 	1.0,                                             # 1-second windows
-	Async::Limiter::Timing::BurstStrategy::Greedy,
+	Async::Limiter::Timing::Burst::Greedy,
 	3                                                # 3 operations per window
 )
 
@@ -193,12 +193,12 @@ end
 ```ruby
 # Greedy allows all operations immediately within each window
 greedy_timing = Async::Limiter::Timing::FixedWindow.new(
-	2.0, Async::Limiter::Timing::BurstStrategy::Greedy, 4
+	2.0, Async::Limiter::Timing::Burst::Greedy, 4
 )
 
 # Conservative spreads operations evenly within each window
 conservative_timing = Async::Limiter::Timing::FixedWindow.new(
-	2.0, Async::Limiter::Timing::BurstStrategy::Conservative, 4
+	2.0, Async::Limiter::Timing::Burst::Conservative, 4
 )
 
 puts "=== Greedy Fixed Window ==="
@@ -342,7 +342,7 @@ Pure rate limiting without concurrency constraints:
 ```ruby
 # Unlimited concurrency, but rate limited
 timing = Async::Limiter::Timing::SlidingWindow.new(1.0, 
-	Async::Limiter::Timing::BurstStrategy::Greedy, 5)
+	Async::Limiter::Timing::Burst::Greedy, 5)
 
 limiter = Async::Limiter::Generic.new(timing: timing)
 
@@ -389,7 +389,7 @@ queue = Async::Queue.new
 
 # Add timing constraint
 timing = Async::Limiter::Timing::FixedWindow.new(2.0,
-	Async::Limiter::Timing::BurstStrategy::Greedy, 4)
+	Async::Limiter::Timing::Burst::Greedy, 4)
 
 limiter = Async::Limiter::Queued.new(queue, timing: timing)
 
@@ -484,7 +484,7 @@ class JobProcessor
 		# Process jobs in batches every 30 seconds, up to 50 jobs per batch
 		timing = Async::Limiter::Timing::FixedWindow.new(
 			30.0,  # 30-second windows
-			Async::Limiter::Timing::BurstStrategy::Greedy,
+			Async::Limiter::Timing::Burst::Greedy,
 			50     # 50 jobs per window
 		)
 		
diff --git a/fixtures/async/limiter/a_limiter.rb b/fixtures/async/limiter/a_limiter.rb
@@ -133,7 +133,7 @@ module Limiter
 				include Sus::Fixtures::Async::SchedulerContext
 				
 				with Async::Limiter::Timing::SlidingWindow do
-					let(:timing) {Async::Limiter::Timing::SlidingWindow.new(0.1, Async::Limiter::Timing::BurstStrategy::Greedy, 10)}
+					let(:timing) {Async::Limiter::Timing::SlidingWindow.new(0.1, Async::Limiter::Timing::Burst::Greedy, 10)}
 					let(:limiter) {subject.new(timing: timing)}
 					
 					it "can acquire several times" do
diff --git a/guides/generic-limiter/readme.md b/guides/generic-limiter/readme.md
@@ -101,7 +101,7 @@ Async do
 		# 1-second window:
 		1.0,
 		# Allow bursting:
-		Async::Limiter::Timing::BurstStrategy::Greedy,
+		Async::Limiter::Timing::Burst::Greedy,
 		# 5 operations per second:
 		5
 	)
diff --git a/guides/getting-started/readme.md b/guides/getting-started/readme.md
@@ -115,7 +115,7 @@ Async do
 	# Max 3 tasks within any 1-second sliding window
 	timing = Async::Limiter::Timing::SlidingWindow.new(
 		1.0, # 1-second window.
-		Async::Limiter::Timing::BurstStrategy::Greedy, # Allow bursting
+		Async::Limiter::Timing::Burst::Greedy, # Allow bursting
 		3 # 3 tasks per window
 	)
 	
diff --git a/guides/timing-strategies/readme.md b/guides/timing-strategies/readme.md
@@ -43,7 +43,7 @@ Provides smooth rate limiting with continuous rolling time windows:
 # Allow 3 operations within any 1-second sliding window
 timing = Async::Limiter::Timing::SlidingWindow.new(
 	1.0,                                             # 1-second window
-	Async::Limiter::Timing::BurstStrategy::Greedy,   # Burst behavior
+	Async::Limiter::Timing::Burst::Greedy,   # Burst behavior
 	3                                                # 3 operations per window
 )
 
@@ -67,14 +67,14 @@ Different burst behaviors affect how operations are scheduled:
 # Greedy: Allow immediate bursts up to the limit
 greedy_timing = Async::Limiter::Timing::SlidingWindow.new(
 	2.0,                                           # 2-second window
-	Async::Limiter::Timing::BurstStrategy::Greedy, # Allow bursts
+	Async::Limiter::Timing::Burst::Greedy, # Allow bursts
 	6                                              # 6 operations per 2 seconds
 )
 
 # Conservative: Spread operations evenly over time
 conservative_timing = Async::Limiter::Timing::SlidingWindow.new(
 	2.0,                                               # 2-second window
-	Async::Limiter::Timing::BurstStrategy::Conservative, # Even distribution
+	Async::Limiter::Timing::Burst::Conservative, # Even distribution
 	6                                                  # 6 operations per 2 seconds
 )
 
@@ -107,7 +107,7 @@ Operations can consume different amounts of the rate limit:
 ```ruby
 timing = Async::Limiter::Timing::SlidingWindow.new(
 	1.0,                                             # 1-second window
-	Async::Limiter::Timing::BurstStrategy::Greedy,
+	Async::Limiter::Timing::Burst::Greedy,
 	10.0                                             # 10 units per second
 )
 
@@ -143,7 +143,7 @@ Provides rate limiting with discrete time boundaries:
 # Allow 5 operations per 2-second window with fixed boundaries
 timing = Async::Limiter::Timing::FixedWindow.new(
 	2.0,                                             # 2-second windows
-	Async::Limiter::Timing::BurstStrategy::Greedy,   # Allow bursting within window
+	Async::Limiter::Timing::Burst::Greedy,   # Allow bursting within window
 	5                                                # 5 operations per window
 )
 
@@ -166,7 +166,7 @@ end
 # Demonstrate window boundaries
 timing = Async::Limiter::Timing::FixedWindow.new(
 	1.0,                                             # 1-second windows
-	Async::Limiter::Timing::BurstStrategy::Greedy,
+	Async::Limiter::Timing::Burst::Greedy,
 	3                                                # 3 operations per window
 )
 
@@ -193,12 +193,12 @@ end
 ```ruby
 # Greedy allows all operations immediately within each window
 greedy_timing = Async::Limiter::Timing::FixedWindow.new(
-	2.0, Async::Limiter::Timing::BurstStrategy::Greedy, 4
+	2.0, Async::Limiter::Timing::Burst::Greedy, 4
 )
 
 # Conservative spreads operations evenly within each window
 conservative_timing = Async::Limiter::Timing::FixedWindow.new(
-	2.0, Async::Limiter::Timing::BurstStrategy::Conservative, 4
+	2.0, Async::Limiter::Timing::Burst::Conservative, 4
 )
 
 puts "=== Greedy Fixed Window ==="
@@ -342,7 +342,7 @@ Pure rate limiting without concurrency constraints:
 ```ruby
 # Unlimited concurrency, but rate limited
 timing = Async::Limiter::Timing::SlidingWindow.new(1.0, 
-	Async::Limiter::Timing::BurstStrategy::Greedy, 5)
+	Async::Limiter::Timing::Burst::Greedy, 5)
 
 limiter = Async::Limiter::Generic.new(timing: timing)
 
@@ -389,7 +389,7 @@ queue = Async::Queue.new
 
 # Add timing constraint
 timing = Async::Limiter::Timing::FixedWindow.new(2.0,
-	Async::Limiter::Timing::BurstStrategy::Greedy, 4)
+	Async::Limiter::Timing::Burst::Greedy, 4)
 
 limiter = Async::Limiter::Queued.new(queue, timing: timing)
 
@@ -484,7 +484,7 @@ class JobProcessor
 		# Process jobs in batches every 30 seconds, up to 50 jobs per batch
 		timing = Async::Limiter::Timing::FixedWindow.new(
 			30.0,  # 30-second windows
-			Async::Limiter::Timing::BurstStrategy::Greedy,
+			Async::Limiter::Timing::Burst::Greedy,
 			50     # 50 jobs per window
 		)
 		
diff --git a/lib/async/limiter.rb b/lib/async/limiter.rb
@@ -8,7 +8,7 @@
 require_relative "limiter/timing/sliding_window"
 require_relative "limiter/timing/fixed_window"
 require_relative "limiter/timing/leaky_bucket"
-require_relative "limiter/timing/burst_strategy"
+require_relative "limiter/timing/burst"
 require_relative "limiter/timing/ordered"
 require_relative "limiter/generic"
 require_relative "limiter/limited"
diff --git a/lib/async/limiter/timing/burst.rb b/lib/async/limiter/timing/burst.rb
@@ -25,7 +25,7 @@ module Timing
 			#   0s         60s        120s       180s
 			#   Tasks spread evenly: 0s, 12s, 24s, 36s, 48s
 			#
-			module BurstStrategy
+			module Burst
 				# Allows tasks to cluster within windows for high-throughput scenarios.
 				#
 				# Greedy strategies permit multiple tasks to start immediately as long as
diff --git a/lib/async/limiter/timing/sliding_window.rb b/lib/async/limiter/timing/sliding_window.rb
@@ -4,7 +4,7 @@
 # Copyright, 2025, by Samuel Williams.
 
 require "async/clock"
-require_relative "burst_strategy"
+require_relative "burst"
 
 module Async
 	module Limiter
@@ -22,13 +22,13 @@ class SlidingWindow
 				
 				# Initialize a window timing strategy.
 				# @parameter duration [Numeric] Duration of the window in seconds.
-				# @parameter burst_strategy [#can_acquire?] Controls bursting vs smooth behavior.
+				# @parameter burst [#can_acquire?] Controls bursting vs smooth behavior.
 				# @parameter limit [Integer] Maximum tasks per window.
-				def initialize(duration, burst_strategy, limit)
+				def initialize(duration, burst, limit)
 					raise ArgumentError, "duration must be positive" unless duration.positive?
 					
 					@duration = duration
-					@burst_strategy = burst_strategy
+					@burst = burst
 					@limit = limit
 					
 					@start_time = nil
@@ -56,7 +56,7 @@ def can_acquire?(cost = 1, current_time = Clock.now)
 					frame_changed = frame_changed?(current_time)
 					
 					# Check both window and frame constraints with cost
-					@burst_strategy.can_acquire?(@count + cost - 1, @limit, frame_changed)
+					@burst.can_acquire?(@count + cost - 1, @limit, frame_changed)
 				end
 				
 				# Record that a task was acquired.
@@ -80,7 +80,7 @@ def wait(mutex, deadline = nil, cost = 1)
 							return false
 						end
 						
-						next_time = @burst_strategy.next_acquire_time(
+						next_time = @burst.next_acquire_time(
 							@start_time,
 							@duration,
 							@frame_start_time,
diff --git a/test/async/limiter/limited.rb b/test/async/limiter/limited.rb
@@ -171,7 +171,7 @@
 	with "greedy fixed window" do
 		include Sus::Fixtures::Async::SchedulerContext
 		
-		let(:timing) {Async::Limiter::Timing::FixedWindow.new(1.0, Async::Limiter::Timing::BurstStrategy::Greedy, 2)}
+		let(:timing) {Async::Limiter::Timing::FixedWindow.new(1.0, Async::Limiter::Timing::Burst::Greedy, 2)}
 		
 		# High concurrency limit, low timing limit:
 		let(:limiter) {Async::Limiter::Limited.new(10, timing: timing)}
diff --git a/test/async/limiter/timing/burst.rb b/test/async/limiter/timing/burst.rb
@@ -3,11 +3,11 @@
 # Released under the MIT License.
 # Copyright, 2025, by Samuel Williams.
 
-require "async/limiter/timing/burst_strategy"
+require "async/limiter/timing/burst"
 
-describe Async::Limiter::Timing::BurstStrategy do
+describe Async::Limiter::Timing::Burst do
 	with "Greedy" do
-		let(:strategy) {Async::Limiter::Timing::BurstStrategy::Greedy}
+		let(:strategy) {Async::Limiter::Timing::Burst::Greedy}
 		
 		it "allows acquisition when under limit" do
 			expect(strategy.can_acquire?(2, 5, false)).to be == true
@@ -35,7 +35,7 @@
 	end
 	
 	with "Smooth" do
-		let(:strategy) {Async::Limiter::Timing::BurstStrategy::Smooth}
+		let(:strategy) {Async::Limiter::Timing::Burst::Smooth}
 		
 		it "only allows acquisition when frame changed" do
 			expect(strategy.can_acquire?(0, 5, true)).to be == true   # Frame changed
diff --git a/test/async/limiter/timing/fixed_window.rb b/test/async/limiter/timing/fixed_window.rb
@@ -12,7 +12,7 @@
 	let(:fixed_window) do
 		subject.new(
 			1.0,  # 1 second window
-			Async::Limiter::Timing::BurstStrategy::Greedy,
+			Async::Limiter::Timing::Burst::Greedy,
 			3     # 3 tasks per window
 		)
 	end
diff --git a/test/async/limiter/timing/sliding_window.rb b/test/async/limiter/timing/sliding_window.rb
@@ -12,7 +12,7 @@
 	let(:window_strategy) do
 		subject.new(
 			1.0,  # 1 second window
-			Async::Limiter::Timing::BurstStrategy::Greedy,
+			Async::Limiter::Timing::Burst::Greedy,
 			2     # 2 tasks per window
 		)
 	end
@@ -44,7 +44,7 @@
 		# Create a very restrictive window for testing waits
 		restrictive_window = subject.new(
 			0.1,  # 100ms window  
-			Async::Limiter::Timing::BurstStrategy::Smooth,  # Force even distribution
+			Async::Limiter::Timing::Burst::Smooth,  # Force even distribution
 			1     # Only 1 task per window
 		)
 		
@@ -74,7 +74,7 @@
 		# Use the same restrictive window
 		restrictive_window = subject.new(
 			0.2,  # 200ms window
-			Async::Limiter::Timing::BurstStrategy::Smooth,
+			Async::Limiter::Timing::Burst::Smooth,
 			1     # Only 1 task per window
 		)
 		

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ Async do`
`101`	`101`	`# 1-second window:`
`102`	`102`	`1.0,`
`103`	`103`	`# Allow bursting:`
`104`		`- Async::Limiter::Timing::BurstStrategy::Greedy,`
	`104`	`+ Async::Limiter::Timing::Burst::Greedy,`
`105`	`105`	`# 5 operations per second:`
`106`	`106`	`5`
`107`	`107`	`)`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ Async do`
`115`	`115`	`# Max 3 tasks within any 1-second sliding window`
`116`	`116`	`timing = Async::Limiter::Timing::SlidingWindow.new(`
`117`	`117`	`1.0, # 1-second window.`
`118`		`- Async::Limiter::Timing::BurstStrategy::Greedy, # Allow bursting`
	`118`	`+ Async::Limiter::Timing::Burst::Greedy, # Allow bursting`
`119`	`119`	`3 # 3 tasks per window`
`120`	`120`	`)`
`121`	`121`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ module Timing`
`25`	`25`	`# 0s 60s 120s 180s`
`26`	`26`	`# Tasks spread evenly: 0s, 12s, 24s, 36s, 48s`
`27`	`27`	`#`
`28`		`- module BurstStrategy`
	`28`	`+ module Burst`
`29`	`29`	`# Allows tasks to cluster within windows for high-throughput scenarios.`
`30`	`30`	`#`
`31`	`31`	`# Greedy strategies permit multiple tasks to start immediately as long as`