berater 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8ca6fba7e38a014eed325df41dda7372b41ff62d9e78b61565f4d915d8b4677
-  data.tar.gz: 1fae864b93de87ea3dc70531f3f8697e80af526aea53d8ddfe2076eac9bbd61d
+  metadata.gz: dec8c5d6d428f795d1489dace166451e2a3a42592d00d71155ed5cd0d5aaa909
+  data.tar.gz: 6956b6c2804b6d616074e239439d4f2a8e551e900db7801226948b9eb764d0fc
 SHA512:
-  metadata.gz: 1b4b37134edece0657ea9be15119fe25b2208d554b9dbf56edd04f8e5acff77569022be025ec428b81ab1971171ae468e389a9568d7ad0163b0966e622a09f2e
-  data.tar.gz: bd927303eb1475e79a26161a184205008926f95c59a06eee43f453d5e464d15c205a91bffd36228ae28bc5d27f0fa32faebc7c5870ec5d1779bd6c57ecdc0fe2
+  metadata.gz: 327cd2f3a7430c2b81bd1988abd636bfc7d97048c762d3807555e9c1196153570dbe3045fae813852a907ec00b89b8d2c36e9269ed0562419c8d98dd6c1d2b26
+  data.tar.gz: ea1cb39e9201091e4a1357e888ac36f630c326a271e3cfcafa13298b8f54424f776f4dd488e046e2178905d0df9fb5c3b1f0d454e331823cafe5dd338fe9ea6c

data/lib/berater.rb

@@ -1,4 +1,5 @@
 require 'berater/version'
+require 'berater/lock'
 
 
 module Berater
@@ -8,41 +9,26 @@ module Berater
 
   MODES = {}
 
-  attr_accessor :redis, :mode
+  attr_accessor :redis
 
   def configure
-    self.mode = :unlimited # default
-
     yield self
   end
 
-  def new(mode, *args, **opts)
+  def new(key, mode, *args, **opts)
     klass = MODES[mode.to_sym]
 
     unless klass
       raise ArgumentError, "invalid mode: #{mode}"
     end
 
-    klass.new(*args, **opts)
+    klass.new(key, *args, **opts)
   end
 
   def register(mode, klass)
     MODES[mode.to_sym] = klass
   end
 
-  def mode=(mode)
-    unless MODES.include? mode.to_sym
-      raise ArgumentError, "invalid mode: #{mode}"
-    end
-
-    @mode = mode.to_sym
-  end
-
-  def limit(*args, **opts, &block)
-    mode = opts.delete(:mode) { self.mode }
-    new(mode, *args, **opts).limit(&block)
-  end
-
   def expunge
     redis.scan_each(match: "#{self.name}*") do |key|
       redis.del key
@@ -51,6 +37,11 @@ module Berater
 
 end
 
+# convenience method
+def Berater(key, mode, *args, **opts, &block)
+  Berater.new(key, mode, *args, **opts).limit(&block)
+end
+
 # load and register limiters
 require 'berater/base_limiter'
 require 'berater/concurrency_limiter'

data/lib/berater/base_limiter.rb

@@ -1,31 +1,25 @@
 module Berater
   class BaseLimiter
 
-    attr_reader :options
-
-    def initialize(**opts)
-      @options = opts
-    end
-
-    def key
-      if options[:key]
-        "#{self.class}:#{options[:key]}"
-      else
-        # default value
-        self.class.to_s
-      end
-    end
+    attr_reader :key, :options
 
     def redis
       options[:redis] || Berater.redis
     end
 
-    def limit(**opts)
+    def limit
       raise NotImplementedError
     end
 
-    def self.limit(*args, **opts, &block)
-      self.new(*args, **opts).limit(&block)
+    protected
+
+    def initialize(key, **opts)
+      @key = key
+      @options = opts
+    end
+
+    def cache_key(key)
+      "#{self.class}:#{key}"
     end
 
   end

data/lib/berater/concurrency_limiter.rb

@@ -5,14 +5,14 @@ module Berater
 
     attr_reader :capacity, :timeout
 
-    def initialize(capacity, **opts)
-      super(**opts)
+    def initialize(key, capacity, **opts)
+      super(key, **opts)
 
       self.capacity = capacity
       self.timeout = opts[:timeout] || 0
     end
 
-    def capacity=(capacity)
+    private def capacity=(capacity)
       unless capacity.is_a? Integer
         raise ArgumentError, "expected Integer, found #{capacity.class}"
       end
@@ -22,7 +22,7 @@ module Berater
       @capacity = capacity
     end
 
-    def timeout=(timeout)
+    private def timeout=(timeout)
       unless timeout.is_a? Integer
         raise ArgumentError, "expected Integer, found #{timeout.class}"
       end
@@ -32,107 +32,42 @@ module Berater
       @timeout = timeout
     end
 
-    class Lock
-      attr_reader :limiter, :id, :contention
-
-      def initialize(limiter, id, contention)
-        @limiter = limiter
-        @id = id
-        @contention = contention
-        @released = false
-        @locked_at = Time.now
-      end
-
-      def release
-        raise 'lock already released' if released?
-        raise 'lock expired' if expired?
-
-        @released = limiter.release(self)
-      end
-
-      def released?
-        @released
-      end
-
-      def expired?
-        limiter.timeout > 0 && @locked_at + limiter.timeout < Time.now
-      end
-    end
-
     LUA_SCRIPT = <<~LUA.gsub(/^\s*(--.*\n)?/, '')
       local key = KEYS[1]
+      local lock_key = KEYS[2]
       local capacity = tonumber(ARGV[1])
       local ts = tonumber(ARGV[2])
       local ttl = tonumber(ARGV[3])
-
-      local exists
-      local count
       local lock
 
-      -- check to see if key already exists
-      if ttl == 0 then
-        exists = redis.call('EXISTS', key)
-      else
-        -- and refresh TTL while we're at it
-        exists = redis.call('EXPIRE', key, ttl * 2)
+      -- purge stale hosts
+      if ttl > 0 then
+        redis.call('ZREMRANGEBYSCORE', key, '-inf', ts - ttl)
       end
 
-      if exists == 1 then
-        -- purge stale hosts
-        if ttl > 0 then
-          redis.call('ZREMRANGEBYSCORE', key, '-inf', ts - ttl)
-        end
-
-        -- check capacity (subtract one for next lock entry)
-        count = redis.call('ZCARD', key) - 1
-
-        if count < capacity then
-          -- yay, grab a lock
-
-          -- regenerate next lock entry, which has score inf
-          lock = unpack(redis.call('ZPOPMAX', key))
-          redis.call('ZADD', key, 'inf', (lock + 1) % 2^52)
-
-          count = count + 1
-        end
-      elseif capacity > 0 then
-        count = 1
-        lock = "1"
+      -- check capacity
+      local count = redis.call('ZCARD', key)
 
-        -- create structure to track locks and next id
-        redis.call('ZADD', key, 'inf', lock + 1)
-
-        if ttl > 0 then
-          redis.call('EXPIRE', key, ttl * 2)
-        end
-      end
-
-      if lock then
-        -- store lock and timestamp
+      if count < capacity then
+        -- grab a lock
+        lock = redis.call('INCR', lock_key)
         redis.call('ZADD', key, ts, lock)
+        count = count + 1
       end
 
       return { count, lock }
     LUA
 
-    def limit(**opts, &block)
-      unless opts.empty?
-        return self.class.new(
-          capacity,
-          **options.merge(opts)
-          # **options.merge(timeout: timeout).merge(opts)
-        ).limit(&block)
-      end
-
+    def limit
       count, lock_id = redis.eval(
         LUA_SCRIPT,
-        [ key ],
+        [ cache_key(key), cache_key('lock_id') ],
         [ capacity, Time.now.to_i, timeout ]
       )
 
       raise Incapacitated unless lock_id
 
-      lock = Lock.new(self, lock_id, count)
+      lock = Lock.new(self, lock_id, count, -> { release(lock_id) })
 
       if block_given?
         begin
@@ -145,8 +80,8 @@ module Berater
       end
     end
 
-    def release(lock)
-      res = redis.zrem(key, lock.id)
+    private def release(lock_id)
+      res = redis.zrem(cache_key(key), lock_id)
       res == true || res == 1 # depending on which version of Redis
     end
 

data/lib/berater/inhibitor.rb

@@ -3,17 +3,11 @@ module Berater
 
     class Inhibited < Overloaded; end
 
-    def initialize(*args, **opts)
-      super(**opts)
+    def initialize(key = :inhibitor, *args, **opts)
+      super(key, **opts)
     end
 
-    def limit(**opts, &block)
-      unless opts.empty?
-        return self.class.new(
-          **options.merge(opts)
-        ).limit(&block)
-      end
-
+    def limit
       raise Inhibited
     end
 

data/lib/berater/lock.rb

@@ -0,0 +1,36 @@
+module Berater
+  class Lock
+
+    attr_reader :limiter, :id, :contention
+
+    def initialize(limiter, id, contention, release_fn = nil)
+      @limiter = limiter
+      @id = id
+      @contention = contention
+      @locked_at = Time.now
+      @release_fn = release_fn
+      @released_at = nil
+    end
+
+    def locked?
+      @released_at.nil? && !expired?
+    end
+
+    def expired?
+      timeout > 0 && @locked_at + timeout < Time.now
+    end
+
+    def release
+      raise 'lock expired' if expired?
+      raise 'lock already released' unless locked?
+
+      @released_at = Time.now
+      @release_fn ? @release_fn.call : true
+    end
+
+    private def timeout
+      limiter.respond_to?(:timeout) ? limiter.timeout : 0
+    end
+
+  end
+end

data/lib/berater/rate_limiter.rb

@@ -5,14 +5,14 @@ module Berater
 
     attr_accessor :count, :interval
 
-    def initialize(count, interval, **opts)
-      super(**opts)
+    def initialize(key, count, interval, **opts)
+      super(key, **opts)
 
       self.count = count
       self.interval = interval
     end
 
-    def count=(count)
+    private def count=(count)
       unless count.is_a? Integer
         raise ArgumentError, "expected Integer, found #{count.class}"
       end
@@ -22,7 +22,7 @@ module Berater
       @count = count
     end
 
-    def interval=(interval)
+    private def interval=(interval)
       @interval = interval.dup
 
       case @interval
@@ -51,19 +51,11 @@ module Berater
       @interval
     end
 
-    def limit(**opts, &block)
-      unless opts.empty?
-        return self.class.new(
-          count,
-          interval,
-          options.merge(opts)
-        ).limit(&block)
-      end
-
+    def limit
       ts = Time.now.to_i
 
       # bucket into time slot
-      rkey = "%s:%d" % [ key, ts - ts % @interval ]
+      rkey = "%s:%d" % [ cache_key(key), ts - ts % @interval ]
 
       count, _ = redis.multi do
         redis.incr rkey
@@ -72,10 +64,16 @@ module Berater
 
       raise Overrated if count > @count
 
+      lock = Lock.new(self, count, count)
+
       if block_given?
-        yield
+        begin
+          yield lock
+        ensure
+          lock.release
+        end
       else
-        count
+        lock
       end
     end
 

data/lib/berater/unlimiter.rb

@@ -1,18 +1,23 @@
 module Berater
   class Unlimiter < BaseLimiter
 
-    def initialize(*args, **opts)
-      super(**opts)
+    def initialize(key = :unlimiter, *args, **opts)
+      super(key, **opts)
     end
 
-    def limit(**opts, &block)
-      unless opts.empty?
-        return self.class.new(
-          **options.merge(opts)
-        ).limit(&block)
-      end
+    def limit
+      count = redis.incr(cache_key('count'))
+      lock = Lock.new(self, count, count)
 
-      yield if block_given?
+      if block_given?
+        begin
+          yield lock
+        ensure
+          lock.release
+        end
+      else
+        lock
+      end
     end
 
   end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

data/spec/berater_spec.rb

@@ -9,10 +9,10 @@ describe Berater do
   describe '.configure' do
     it 'can be set via configure' do
       Berater.configure do |c|
-        c.mode = :rate
+        c.redis = :redis
       end
 
-      expect(Berater.mode).to eq :rate
+      expect(Berater.redis).to eq :redis
     end
   end
 
@@ -24,20 +24,13 @@ describe Berater do
     end
   end
 
-  describe '.mode' do
-    it 'validates inputs' do
-      expect { Berater.mode = :foo }.to raise_error(ArgumentError)
-    end
-  end
-
-  context 'unlimited mode' do
-    before { Berater.mode = :unlimited }
-
-    describe '.new' do
-      let(:limiter) { Berater.new(:unlimited) }
+  describe '.new' do
+    context 'unlimited mode' do
+      let(:limiter) { Berater.new(:key, :unlimited) }
 
       it 'instantiates an Unlimiter' do
         expect(limiter).to be_a Berater::Unlimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -46,35 +39,22 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:unlimited, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :unlimited, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
-
-    describe '.limit' do
-      it 'works' do
-        expect(Berater.limit).to be_nil
-      end
-
-      it 'yields' do
-        expect {|b| Berater.limit(&b) }.to yield_control
-      end
 
-      it 'never limits' do
-        10.times { expect(Berater.limit { 123 } ).to eq 123 }
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect {|b| Berater(:key, :unlimited, &b) }.to yield_control
       end
     end
-  end
-
-  context 'inhibited mode' do
-    before { Berater.mode = :inhibited }
 
-    describe '.new' do
-      let(:limiter) { Berater.new(:inhibited) }
+    context 'inhibited mode' do
+      let(:limiter) { Berater.new(:key, :inhibited) }
 
       it 'instantiates an Inhibitor' do
         expect(limiter).to be_a Berater::Inhibitor
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -83,27 +63,22 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:inhibited, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :inhibited, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
 
-    describe '.limit' do
-      it 'always limits' do
-        expect { Berater.limit }.to be_inhibited
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect { Berater(:key, :inhibited) }.to be_inhibited
       end
     end
-  end
-
-  context 'rate mode' do
-    before { Berater.mode = :rate }
 
-    describe '.limiter' do
-      let(:limiter) { Berater.new(:rate, 1, :second) }
+    context 'rate mode' do
+      let(:limiter) { Berater.new(:key, :rate, 1, :second) }
 
       it 'instantiates a RateLimiter' do
         expect(limiter).to be_a Berater::RateLimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -112,44 +87,22 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:rate, 1, :second, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :rate, 1, :second, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
-
-    describe '.limit' do
-      it 'works' do
-        expect(Berater.limit(1, :second)).to eq 1
-      end
-
-      it 'yields' do
-        expect {|b| Berater.limit(2, :second, &b) }.to yield_control
-        expect(Berater.limit(2, :second) { 123 }).to eq 123
-      end
 
-      it 'limits excessive calls' do
-        expect(Berater.limit(1, :second)).to eq 1
-        expect { Berater.limit(1, :second) }.to be_overrated
-      end
-
-      it 'accepts options' do
-        redis = double('Redis')
-        expect(redis).to receive(:multi)
-
-        Berater.limit(1, :second, redis: redis) rescue nil
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect {|b| Berater(:key, :rate, 1, :second, &b) }.to yield_control
       end
     end
-  end
 
-  context 'concurrency mode' do
-    before { Berater.mode = :concurrency }
-
-    describe '.limiter' do
-      let(:limiter) { Berater.new(:concurrency, 1) }
+    context 'concurrency mode' do
+      let(:limiter) { Berater.new(:key, :concurrency, 1) }
 
       it 'instantiates a ConcurrencyLimiter' do
         expect(limiter).to be_a Berater::ConcurrencyLimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -158,33 +111,13 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:concurrency, 1, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :concurrency, 1, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
-
-    describe '.limit' do
-      it 'works (without blocks by returning a lock)' do
-        lock = Berater.limit(1)
-        expect(lock).to be_a Berater::ConcurrencyLimiter::Lock
-        expect(lock.release).to be true
-      end
-
-      it 'yields' do
-        expect {|b| Berater.limit(1, &b) }.to yield_control
-      end
-
-      it 'limits excessive calls' do
-        Berater.limit(1)
-        expect { Berater.limit(1) }.to be_incapacitated
-      end
-
-      it 'accepts options' do
-        redis = double('Redis')
-        expect(redis).to receive(:eval)
 
-        Berater.limit(1, redis: redis) rescue nil
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect {|b| Berater(:key, :concurrency, 1, &b) }.to yield_control
       end
     end
   end

data/spec/concurrency_limiter_spec.rb

@@ -1,22 +1,20 @@
 describe Berater::ConcurrencyLimiter do
-  before { Berater.mode = :concurrency }
-
   describe '.new' do
-    let(:limiter) { described_class.new(1) }
+    let(:limiter) { described_class.new(:key, 1) }
 
     it 'initializes' do
+      expect(limiter.key).to be :key
       expect(limiter.capacity).to be 1
     end
 
     it 'has default values' do
-      expect(limiter.key).to eq described_class.to_s
       expect(limiter.redis).to be Berater.redis
     end
   end
 
   describe '#capacity' do
     def expect_capacity(capacity)
-      limiter = described_class.new(capacity)
+      limiter = described_class.new(:key, capacity)
       expect(limiter.capacity).to eq capacity
     end
 
@@ -27,7 +25,7 @@ describe Berater::ConcurrencyLimiter do
     context 'with erroneous values' do
       def expect_bad_capacity(capacity)
         expect do
-          described_class.new(capacity)
+          described_class.new(:key, capacity)
         end.to raise_error ArgumentError
       end
 
@@ -40,7 +38,7 @@ describe Berater::ConcurrencyLimiter do
 
   describe '#timeout' do
     def expect_timeout(timeout)
-      limiter = described_class.new(1, timeout: timeout)
+      limiter = described_class.new(:key, 1, timeout: timeout)
       expect(limiter.timeout).to eq timeout
     end
 
@@ -51,7 +49,7 @@ describe Berater::ConcurrencyLimiter do
     context 'with erroneous values' do
       def expect_bad_timeout(timeout)
         expect do
-          described_class.new(1, timeout: timeout)
+          described_class.new(:key, 1, timeout: timeout)
         end.to raise_error ArgumentError
       end
 
@@ -63,7 +61,7 @@ describe Berater::ConcurrencyLimiter do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new(2, timeout: 1) }
+    let(:limiter) { described_class.new(:key, 2, timeout: 1) }
 
     it 'works' do
       expect {|b| limiter.limit(&b) }.to yield_control
@@ -81,26 +79,26 @@ describe Berater::ConcurrencyLimiter do
     end
 
     it 'limits excessive calls' do
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::Lock
 
       expect(limiter).to be_incapacitated
     end
 
     it 'times out locks' do
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::Lock
       expect(limiter).to be_incapacitated
 
       Timecop.travel(1)
 
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::Lock
       expect(limiter).to be_incapacitated
     end
 
     context 'with capacity 0' do
-      let(:limiter) { described_class.new(0) }
+      let(:limiter) { described_class.new(:key, 0) }
 
       it 'always fails' do
         expect(limiter).to be_incapacitated
@@ -109,60 +107,34 @@ describe Berater::ConcurrencyLimiter do
   end
 
   context 'with same key, different limiters' do
-    let(:limiter_one) { described_class.new(1) }
-    let(:limiter_two) { described_class.new(1) }
+    let(:limiter_one) { described_class.new(:key, 1) }
+    let(:limiter_two) { described_class.new(:key, 1) }
 
     it { expect(limiter_one.key).to eq limiter_two.key }
 
     it 'works as expected' do
-      expect(limiter_one.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter_one.limit).to be_a Berater::Lock
 
       expect(limiter_one).to be_incapacitated
       expect(limiter_two).to be_incapacitated
     end
   end
 
-  context 'with different keys, same limiter' do
-    let(:limiter) { described_class.new(1) }
-
-    it 'works as expected' do
-      one_lock = limiter.limit(key: :one)
-      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
-
-      expect { limiter.limit(key: :one) {} }.to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
-
-      two_lock = limiter.limit(key: :two)
-      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
-
-      expect { limiter.limit(key: :one) {} }.to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.to be_incapacitated
-
-      one_lock.release
-      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.to be_incapacitated
-
-      two_lock.release
-      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
-    end
-  end
-
   context 'with same key, different capacities' do
-    let(:limiter_one) { described_class.new(1) }
-    let(:limiter_two) { described_class.new(2) }
+    let(:limiter_one) { described_class.new(:key, 1) }
+    let(:limiter_two) { described_class.new(:key, 2) }
 
     it { expect(limiter_one.capacity).not_to eq limiter_two.capacity }
 
     it 'works as expected' do
       one_lock = limiter_one.limit
-      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(one_lock).to be_a Berater::Lock
 
       expect(limiter_one).to be_incapacitated
       expect(limiter_two).not_to be_incapacitated
 
       two_lock = limiter_two.limit
-      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(two_lock).to be_a Berater::Lock
 
       expect(limiter_one).to be_incapacitated
       expect(limiter_two).to be_incapacitated
@@ -178,21 +150,21 @@ describe Berater::ConcurrencyLimiter do
   end
 
   context 'with different keys, different limiters' do
-    let(:limiter_one) { described_class.new(1, key: :one) }
-    let(:limiter_two) { described_class.new(1, key: :two) }
+    let(:limiter_one) { described_class.new(:one, 1) }
+    let(:limiter_two) { described_class.new(:two, 1) }
 
     it 'works as expected' do
       expect(limiter_one).not_to be_incapacitated
       expect(limiter_two).not_to be_incapacitated
 
       one_lock = limiter_one.limit
-      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(one_lock).to be_a Berater::Lock
 
       expect(limiter_one).to be_incapacitated
       expect(limiter_two).not_to be_incapacitated
 
       two_lock = limiter_two.limit
-      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(two_lock).to be_a Berater::Lock
 
       expect(limiter_one).to be_incapacitated
       expect(limiter_two).to be_incapacitated

data/spec/concurrency_lock_spec.rb

@@ -1,62 +1,7 @@
-describe Berater::ConcurrencyLimiter::Lock do
-  before { Berater.mode = :concurrency }
+describe Berater::Lock do
+  it_behaves_like 'a lock', Berater.new(:key, :concurrency, 3)
 
-  let(:limiter) { Berater.new(:concurrency, 3) }
-
-  describe '#contention' do
-    it 'tracks contention' do
-      lock_1 = limiter.limit
-      expect(lock_1.contention).to eq 1
-
-      lock_2 = limiter.limit
-      expect(lock_2.contention).to eq 2
-
-      limiter.limit do |lock_3|
-        expect(lock_3.contention).to eq 3
-      end
-    end
-
-    it 'works in block mode' do
-      lock_1 = limiter.limit
-
-      limiter.limit do |lock_2|
-        expect(lock_1.contention).to eq 1
-        expect(lock_2.contention).to eq 2
-      end
-    end
-  end
-
-  describe '#release' do
-    it 'can not be released twice' do
-      lock = limiter.limit
-      expect(lock.release).to be true
-      expect { lock.release }.to raise_error(RuntimeError, /already/)
-    end
-
-    it 'does not work in block mode' do
-      expect do
-        limiter.limit do |lock|
-          lock.release
-        end
-      end.to raise_error(RuntimeError, /already/)
-    end
-  end
-
-  describe '#released?' do
-    it 'works' do
-      lock = limiter.limit
-      expect(lock.released?).to be false
-
-      lock.release
-      expect(lock.released?).to be true
-    end
-
-    it 'works in block mode' do
-      limiter.limit do |lock|
-        expect(lock.released?).to be false
-      end
-    end
-  end
+  let(:limiter) { Berater.new(:key, :concurrency, 3) }
 
   describe '#expired?' do
     let!(:lock) { limiter.limit }
@@ -65,10 +10,12 @@ describe Berater::ConcurrencyLimiter::Lock do
       it { expect(limiter.timeout).to eq 0 }
 
       it 'never expires' do
+        expect(lock.locked?).to be true
         expect(lock.expired?).to be false
 
         Timecop.travel(1_000)
 
+        expect(lock.locked?).to be true
         expect(lock.expired?).to be false
       end
     end
@@ -76,14 +23,14 @@ describe Berater::ConcurrencyLimiter::Lock do
     context 'when timeout is set and exceeded' do
       before { Timecop.travel(1) }
 
-      let(:limiter) { Berater.new(:concurrency, 3, timeout: 1) }
+      let(:limiter) { Berater.new(:key, :concurrency, 3, timeout: 1) }
 
       it 'expires' do
         expect(lock.expired?).to be true
+        expect(lock.locked?).to be false
       end
 
       it 'fails to release' do
-        expect(lock.released?).to be false
         expect { lock.release }.to raise_error(RuntimeError, /expired/)
       end
     end

data/spec/inhibitor_spec.rb

@@ -1,36 +1,24 @@
 describe Berater::Inhibitor do
-  before { Berater.mode = :inhibited }
-
   describe '.new' do
     it 'initializes without any arguments or options' do
       expect(described_class.new).to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
-      expect(described_class.new(:abc, x: 123)).to be_a described_class
+      expect(described_class.new(:abc, :def, x: 123)).to be_a described_class
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to eq described_class.to_s
+      expect(described_class.new.key).to be :inhibitor
       expect(described_class.new.redis).to be Berater.redis
     end
   end
 
-  describe '.limit' do
-    it 'always limits' do
-      expect { described_class.limit }.to be_inhibited
-    end
-
-    it 'works with any arguments or options' do
-      expect { described_class.limit(:abc, x: 123) }.to be_inhibited
-    end
-  end
-
   describe '#limit' do
     let(:limiter) { described_class.new }
 
     it 'always limits' do
-      expect { described_class.limit }.to be_inhibited
+      expect { limiter.limit }.to be_inhibited
     end
   end
 

data/spec/matcher_spec.rb

@@ -1,6 +1,6 @@
 describe 'be_overloaded' do
   context 'Berater::Unlimiter' do
-    let(:limiter) { Berater.new(:unlimited) }
+    let(:limiter) { Berater.new(:key, :unlimited) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }
@@ -19,7 +19,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::Inhibitor' do
-    let(:limiter) { Berater.new(:inhibited) }
+    let(:limiter) { Berater.new(:key, :inhibited) }
 
     it { expect(limiter).to be_overloaded }
     it { expect(limiter).to be_inhibited }
@@ -32,7 +32,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::RateLimiter' do
-    let(:limiter) { Berater.new(:rate, 1, :second) }
+    let(:limiter) { Berater.new(:key, :rate, 1, :second) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }
@@ -67,7 +67,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::ConcurrencyLimiter' do
-    let(:limiter) { Berater.new(:concurrency, 1) }
+    let(:limiter) { Berater.new(:key, :concurrency, 1) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }

data/spec/rate_limiter_spec.rb

@@ -1,23 +1,22 @@
 describe Berater::RateLimiter do
-  before { Berater.mode = :rate }
 
   describe '.new' do
-    let(:limiter) { described_class.new(1, :second) }
+    let(:limiter) { described_class.new(:key, 1, :second) }
 
     it 'initializes' do
+      expect(limiter.key).to be :key
       expect(limiter.count).to eq 1
       expect(limiter.interval).to eq 1
     end
 
     it 'has default values' do
-      expect(limiter.key).to eq described_class.to_s
       expect(limiter.redis).to be Berater.redis
     end
   end
 
   describe '#count' do
     def expect_count(count)
-      limiter = described_class.new(count, :second)
+      limiter = described_class.new(:key, count, :second)
       expect(limiter.count).to eq count
     end
 
@@ -28,7 +27,7 @@ describe Berater::RateLimiter do
     context 'with erroneous values' do
       def expect_bad_count(count)
         expect do
-          described_class.new(count, :second)
+          described_class.new(:key, count, :second)
         end.to raise_error ArgumentError
       end
 
@@ -41,7 +40,7 @@ describe Berater::RateLimiter do
 
   describe '#interval' do
     def expect_interval(interval, expected)
-      limiter = described_class.new(1, interval)
+      limiter = described_class.new(:key, 1, interval)
       expect(limiter.interval).to eq expected
     end
 
@@ -73,7 +72,7 @@ describe Berater::RateLimiter do
     context 'with erroneous values' do
       def expect_bad_interval(interval)
         expect do
-          described_class.new(1, interval)
+          described_class.new(:key, 1, interval)
         end.to raise_error(ArgumentError)
       end
 
@@ -84,82 +83,60 @@ describe Berater::RateLimiter do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new(3, :second) }
+    let(:limiter) { described_class.new(:key, 3, :second) }
 
     it 'works' do
-      expect(limiter.limit).to eq 1
-    end
-
-    it 'counts' do
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
-    end
-
-    it 'yields' do
       expect {|b| limiter.limit(&b) }.to yield_control
       expect(limiter.limit { 123 }).to eq 123
     end
 
+    it 'works without a block' do
+      expect(limiter.limit).to be_a Berater::Lock
+    end
+
     it 'limits excessive calls' do
       3.times { limiter.limit }
 
-      expect { limiter.limit }.to be_overrated
+      expect(limiter).to be_overrated
     end
 
     it 'limit resets over time' do
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
+      3.times { limiter.limit }
       expect(limiter).to be_overrated
 
       # travel forward a second
       Timecop.freeze(1)
 
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
+      3.times { limiter.limit }
       expect(limiter).to be_overrated
     end
   end
 
   context 'with same key, different limiters' do
-    let(:limiter_one) { described_class.new(1, :second) }
-    let(:limiter_two) { described_class.new(1, :second) }
-
-    it 'works as expected' do
-      expect(limiter_one.limit).to eq 1
-
-      expect { limiter_one }.to be_overrated
-      expect { limiter_two }.to be_overrated
-    end
-  end
-
-  context 'with different keys, same limiter' do
-    let(:limiter) { described_class.new(1, :second) }
+    let(:limiter_one) { described_class.new(:key, 1, :second) }
+    let(:limiter_two) { described_class.new(:key, 1, :second) }
 
     it 'works as expected' do
-      expect { limiter.limit(key: :one) }.not_to be_overrated
-      expect { limiter.limit(key: :one) }.to be_overrated
+      expect(limiter_one.limit).not_to be_overrated
 
-      expect { limiter.limit(key: :two) }.not_to be_overrated
-      expect { limiter.limit(key: :two) }.to be_overrated
+      expect(limiter_one).to be_overrated
+      expect(limiter_two).to be_overrated
     end
   end
 
   context 'with different keys, different limiters' do
-    let(:limiter_one) { described_class.new(1, :second, key: :one) }
-    let(:limiter_two) { described_class.new(2, :second, key: :two) }
+    let(:limiter_one) { described_class.new(:one, 1, :second) }
+    let(:limiter_two) { described_class.new(:two, 2, :second) }
 
     it 'works as expected' do
-      expect(limiter_one.limit).to eq 1
-      expect(limiter_two.limit).to eq 1
+      expect(limiter_one.limit).not_to be_overrated
+      expect(limiter_two.limit).not_to be_overrated
 
-      expect { limiter_one.limit }.to be_overrated
-      expect(limiter_two.limit).to eq 2
+      expect(limiter_one).to be_overrated
+      expect(limiter_two.limit).not_to be_overrated
 
-      expect { limiter_one.limit }.to be_overrated
-      expect { limiter_two.limit }.to be_overrated
+      expect(limiter_one).to be_overrated
+      expect(limiter_two).to be_overrated
     end
   end
 

data/spec/rate_lock_spec.rb

@@ -0,0 +1,20 @@
+describe Berater::Lock do
+  it_behaves_like 'a lock', Berater.new(:key, :rate, 3, :second)
+
+  let(:limiter) { Berater.new(:key, :rate, 3, :second) }
+
+  describe '#expired?' do
+    let!(:lock) { limiter.limit }
+
+    it 'never expires' do
+      expect(lock.locked?).to be true
+      expect(lock.expired?).to be false
+
+      Timecop.travel(1_000)
+
+      expect(lock.locked?).to be true
+      expect(lock.expired?).to be false
+    end
+  end
+
+end

data/spec/unlimiter_spec.rb

@@ -1,50 +1,28 @@
 describe Berater::Unlimiter do
-  before { Berater.mode = :unlimited }
-
   describe '.new' do
     it 'initializes without any arguments or options' do
       expect(described_class.new).to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
-      expect(described_class.new(:abc, x: 123)).to be_a described_class
+      expect(described_class.new(:abc, :def, x: 123)).to be_a described_class
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to eq described_class.to_s
+      expect(described_class.new.key).to be :unlimiter
       expect(described_class.new.redis).to be Berater.redis
     end
   end
 
-  describe '.limit' do
-    it 'works' do
-      expect(described_class.limit).to be_nil
-    end
-
-    it 'yields' do
-      expect {|b| described_class.limit(&b) }.to yield_control
-    end
-
-    it 'is never overloaded' do
-      10.times do
-        expect { described_class.limit }.not_to be_overloaded
-      end
-    end
-
-    it 'works with any arguments or options' do
-      expect(described_class.limit(:abc, x: 123)).to be_nil
-    end
-  end
-
   describe '#limit' do
     let(:limiter) { described_class.new }
 
     it 'works' do
-      expect(limiter.limit).to be_nil
+      expect {|b| limiter.limit(&b) }.to yield_control
     end
 
-    it 'yields' do
-      expect {|b| limiter.limit(&b) }.to yield_control
+    it 'works without a block' do
+      expect(limiter.limit).to be_a Berater::Lock
     end
 
     it 'is never overloaded' do
@@ -52,10 +30,8 @@ describe Berater::Unlimiter do
         expect { limiter.limit }.not_to be_overloaded
       end
     end
-
-    it 'works with any arguments or options' do
-      expect(limiter.limit(x: 123)).to be_nil
-    end
   end
 
+  it_behaves_like 'a lock', described_class.new
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-09 00:00:00.000000000 Z
+date: 2021-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -118,6 +118,7 @@ files:
 - lib/berater/base_limiter.rb
 - lib/berater/concurrency_limiter.rb
 - lib/berater/inhibitor.rb
+- lib/berater/lock.rb
 - lib/berater/rate_limiter.rb
 - lib/berater/unlimiter.rb
 - lib/berater/version.rb
@@ -127,6 +128,7 @@ files:
 - spec/inhibitor_spec.rb
 - spec/matcher_spec.rb
 - spec/rate_limiter_spec.rb
+- spec/rate_lock_spec.rb
 - spec/unlimiter_spec.rb
 homepage: https://github.com/dpep/berater_rb
 licenses:
@@ -154,6 +156,7 @@ summary: Berater
 test_files:
 - spec/rate_limiter_spec.rb
 - spec/matcher_spec.rb
+- spec/rate_lock_spec.rb
 - spec/concurrency_limiter_spec.rb
 - spec/concurrency_lock_spec.rb
 - spec/berater_spec.rb