berater 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c32c1de752ccc7a2a71e4628b99f3561db623374dabaf95af39aadcc3b1a2d16
-  data.tar.gz: 33019954de1d79522ed7105e9f0a7da3a204df74cacd25aa4b57e749a81047bb
+  metadata.gz: 476b59e3f1e27908f5c8a5097087e6c8c2384531e1284d79b9d89a73fbbb5840
+  data.tar.gz: de50fdcab6ea7dc9520fcf1aefdd07b1f8775c0ce96a30e3f1d45b6ccfb7b00f
 SHA512:
-  metadata.gz: 89460a9a81a8d384addb095c425da0eed4fdbe0e15ecd85ee97ffcf4292441deeb34c7e4cd4591adca06096a17f7c131b79c6474d9efb2b635fbe398ad68d00e
-  data.tar.gz: 0a331b939e4c19817c42a8aa8fc5be7fd59d63f6becd5fe6ed1c226690d1524ef040a28d8bcb625d75452ab2f5c8539ddf69093bbd30c4ba9e3353259a3e568d
+  metadata.gz: 2446e64f528a8ef1d37791922d37cddcebdf702f3c5beff2ef7ea9d611ce4cc6d6c40ac42e1ea826987a2eb2ceea3ddf97e420bb7369686b8239b260a1725c55
+  data.tar.gz: 23dccad7e02cc425631ceeb1dfbc6960b94ac92c523d840a991917af02caaf39a7befc5887fe45631f565ddb2eddb4850e557348ab29427d3cbae1db89124c3c

data/lib/berater.rb

@@ -1,8 +1,10 @@
 require 'berater/limiter'
+require 'berater/limiter_set'
 require 'berater/lock'
 require 'berater/lua_script'
 require 'berater/utils'
 require 'berater/version'
+require 'meddleware'
 
 module Berater
   extend self
@@ -15,8 +17,14 @@ module Berater
     yield self
   end
 
-  def reset
-    @redis = nil
+  def limiters
+    @limiters ||= LimiterSet.new
+  end
+
+  def middleware(&block)
+    (@middleware ||= Meddleware.new).tap do
+      @middleware.instance_eval(&block) if block_given?
+    end
   end
 
   def new(key, capacity, **opts)
@@ -48,6 +56,11 @@ module Berater
     end
   end
 
+  def reset
+    @redis = nil
+    limiters.clear
+    middleware.clear
+  end
 end
 
 # convenience method

data/lib/berater/limiter.rb

@@ -9,17 +9,12 @@ module Berater
 
     def limit(capacity: nil, cost: 1, &block)
       capacity ||= @capacity
+      lock = nil
 
-      unless capacity.is_a?(Numeric) && capacity >= 0
-        raise ArgumentError, "invalid capacity: #{capacity}"
+      Berater.middleware.call(self, capacity: capacity, cost: cost) do |limiter, **opts|
+        lock = limiter.inner_limit(**opts)
       end
 
-      unless cost.is_a?(Numeric) && cost >= 0 && cost < Float::INFINITY
-        raise ArgumentError, "invalid cost: #{cost}"
-      end
-
-      lock = acquire_lock(capacity, cost)
-
       if block_given?
         begin
           yield lock
@@ -31,6 +26,23 @@ module Berater
       end
     end
 
+    protected def inner_limit(capacity:, cost:)
+      unless capacity.is_a?(Numeric) && capacity >= 0
+        raise ArgumentError, "invalid capacity: #{capacity}"
+      end
+
+      unless cost.is_a?(Numeric) && cost >= 0 && cost < Float::INFINITY
+        raise ArgumentError, "invalid cost: #{cost}"
+      end
+
+      acquire_lock(capacity, cost)
+    rescue NoMethodError => e
+      raise unless e.message.include?("undefined method `evalsha' for")
+
+      # repackage error so it's easier to understand
+      raise RuntimeError, "invalid redis connection: #{redis}"
+    end
+
     def utilization
       lock = limit(cost: 0)
 
@@ -52,13 +64,6 @@ module Berater
       self.redis.connection == other.redis.connection
     end
 
-    def self.new(*)
-      # can only call via subclass
-      raise NoMethodError if self == Berater::Limiter
-
-      super
-    end
-
     protected
 
     attr_reader :args
@@ -93,16 +98,27 @@ module Berater
       self.class.cache_key(instance_key)
     end
 
-    def self.cache_key(key)
-      klass = to_s.split(':')[-1]
-      "Berater:#{klass}:#{key}"
-    end
+    class << self
+      def new(*)
+        # can only call via subclass
+        raise NoMethodError if self == Berater::Limiter
+
+        super
+      end
 
-    def self.inherited(subclass)
-      # automagically create convenience method
-      name = subclass.to_s.split(':')[-1]
-      Berater.define_singleton_method(name) do |*args, **opts, &block|
-        Berater::Utils.convenience_fn(subclass, *args, **opts, &block)
+      def cache_key(key)
+        klass = to_s.split(':')[-1]
+        "Berater:#{klass}:#{key}"
+      end
+
+      protected
+
+      def inherited(subclass)
+        # automagically create convenience method
+        name = subclass.to_s.split(':')[-1]
+        Berater.define_singleton_method(name) do |*args, **opts, &block|
+          Berater::Utils.convenience_fn(subclass, *args, **opts, &block)
+        end
       end
     end
 

data/lib/berater/limiter_set.rb

@@ -0,0 +1,66 @@
+module Berater
+  private
+
+  class LimiterSet
+    include Enumerable
+
+    def initialize
+      @limiters = {}
+    end
+
+    def each(&block)
+      @limiters.each_value(&block)
+    end
+
+    def <<(limiter)
+      key = limiter.key if limiter.respond_to?(:key)
+      send(:[]=, key, limiter)
+    end
+
+    def []=(key, limiter)
+      unless limiter.is_a? Berater::Limiter
+        raise ArgumentError, "expected Berater::Limiter, found: #{limiter}"
+      end
+
+      @limiters[key] = limiter
+    end
+
+    def [](key)
+      @limiters[key]
+    end
+
+    def fetch(key, val = default = true, &block)
+      args = default ? [ key ] : [ key, val ]
+      @limiters.fetch(*args, &block)
+    end
+
+    def include?(key)
+      if key.is_a? Berater::Limiter
+        @limiters.value?(key)
+      else
+        @limiters.key?(key)
+      end
+    end
+
+    def clear
+      @limiters.clear
+    end
+
+    def count
+      @limiters.count
+    end
+
+    def delete(key)
+      if key.is_a? Berater::Limiter
+        @limiters.delete(key.key)
+      else
+        @limiters.delete(key)
+      end
+    end
+    alias remove delete
+
+    def empty?
+      @limiters.empty?
+    end
+  end
+end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

data/spec/berater_spec.rb

@@ -24,6 +24,24 @@ describe Berater do
     end
   end
 
+  describe '.limiters' do
+    subject { Berater.limiters }
+
+    let(:limiter) { Berater(:key, 1) }
+
+    it 'provides access to predefined limiters' do
+      expect(Berater.limiters).to be_a Berater::LimiterSet
+    end
+
+    it 'resets with Berater' do
+      subject << limiter
+      is_expected.not_to be_empty
+
+      Berater.reset
+      is_expected.to be_empty
+    end
+  end
+
   shared_examples 'a Berater' do |klass, capacity, **opts|
     describe '.new' do
       let(:limiter) { Berater.new(:key, capacity, **opts) }

data/spec/limiter_set_spec.rb

@@ -0,0 +1,173 @@
+describe Berater::LimiterSet do
+  subject { described_class.new }
+
+  let(:unlimiter) { Berater::Unlimiter.new }
+  let(:inhibitor) { Berater::Inhibitor.new }
+
+  describe '#each' do
+    it 'returns an Enumerator' do
+      expect(subject.each).to be_a Enumerator
+    end
+
+    it 'works with an empty set' do
+      expect(subject.each.to_a).to eq []
+    end
+
+    it 'returns elements' do
+      subject << unlimiter
+      expect(subject.each.to_a).to eq [ unlimiter ]
+    end
+  end
+
+  describe '#<<' do
+    it 'adds a limiter' do
+      subject << unlimiter
+      expect(subject.each.to_a).to eq [ unlimiter ]
+    end
+
+    it 'rejects things that are not limiters' do
+      expect {
+        subject << :foo
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'updates existing keys' do
+      limiter = Berater::Unlimiter.new
+      expect(limiter).to eq unlimiter
+      expect(limiter).not_to be unlimiter
+
+      subject << unlimiter
+      subject << limiter
+
+      expect(subject.each.to_a).to eq [ limiter ]
+    end
+  end
+
+  describe '[]=' do
+    it 'adds a limiter' do
+      subject[:key] = unlimiter
+
+      expect(subject.each.to_a).to eq [ unlimiter ]
+      is_expected.to include :key
+      is_expected.to include unlimiter
+    end
+
+    it 'rejects things that are not limiters' do
+      expect {
+        subject[:key] = :foo
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#[]' do
+    it 'returns nil for missing keys' do
+      expect(subject[:key]).to be nil
+      expect(subject[nil]).to be nil
+    end
+
+    it 'retreives limiters' do
+      subject << unlimiter
+      expect(subject[unlimiter.key]).to be unlimiter
+    end
+  end
+
+  describe '#fetch' do
+    it 'raises for missing keys' do
+      expect {
+        subject.fetch(:key)
+      }.to raise_error(KeyError)
+
+      expect {
+        subject.fetch(nil)
+      }.to raise_error(KeyError)
+    end
+
+    it 'returns the default if provided' do
+      expect(subject.fetch(:key, unlimiter)).to be unlimiter
+    end
+
+    it 'calls the default proc if provided' do
+      expect {|block| subject.fetch(:key, &block) }.to yield_control
+    end
+
+    it 'retreives limiters' do
+      subject << unlimiter
+      expect(subject.fetch(unlimiter.key)).to be unlimiter
+      expect(subject.fetch(unlimiter.key, :default)).to be unlimiter
+    end
+  end
+
+  describe '#include?' do
+    before do
+      subject << unlimiter
+    end
+
+    it 'works with keys' do
+      is_expected.to include unlimiter.key
+    end
+
+    it 'works with limiters' do
+      is_expected.to include unlimiter
+    end
+
+    it 'works when target is missing' do
+      is_expected.not_to include inhibitor.key
+      is_expected.not_to include inhibitor
+    end
+  end
+
+  describe '#clear' do
+    it 'works when empty' do
+      subject.clear
+    end
+
+    it 'clears limiters' do
+      subject << unlimiter
+      is_expected.to include unlimiter
+
+      subject.clear
+      is_expected.not_to include unlimiter
+    end
+  end
+
+  describe '#count' do
+    it 'counts' do
+      expect(subject.count).to be 0
+
+      subject << unlimiter
+      expect(subject.count).to be 1
+    end
+  end
+
+  describe '#delete' do
+    it 'works when the target is missing' do
+      subject.delete(unlimiter)
+      subject.delete(unlimiter.key)
+    end
+
+    it 'works with keys' do
+      subject << unlimiter
+      is_expected.to include unlimiter
+
+      subject.delete(unlimiter.key)
+      is_expected.not_to include unlimiter
+    end
+
+    it 'works with limiters' do
+      subject << unlimiter
+      is_expected.to include unlimiter
+
+      subject.delete(unlimiter)
+      is_expected.not_to include unlimiter
+    end
+  end
+
+  describe '#empty?' do
+    it 'works' do
+      is_expected.to be_empty
+
+      subject << unlimiter
+      is_expected.not_to be_empty
+    end
+  end
+end

data/spec/limiter_spec.rb

@@ -1,6 +1,8 @@
 describe Berater::Limiter do
-  it 'can not be initialized' do
-    expect { described_class.new }.to raise_error(NoMethodError)
+  describe '.new' do
+    it 'can only be called on subclasses' do
+      expect { described_class.new }.to raise_error(NoMethodError)
+    end
   end
 
   describe 'abstract methods' do
@@ -50,6 +52,33 @@ describe Berater::Limiter do
         }.to raise_error(ArgumentError)
       end
     end
+
+    context 'when Berater.redis is nil' do
+      let!(:redis) { Berater.redis }
+
+      before { Berater.redis = nil }
+
+      it 'works with Unlimiter since redis is not used' do
+        expect(subject.redis).to be nil
+        expect {|b| subject.limit(&b) }.to yield_control
+      end
+
+      it 'raises when redis is needed' do
+        limiter = Berater::RateLimiter.new(:key, 1, :second)
+        expect(limiter.redis).to be nil
+        expect { limiter.limit }.to raise_error(RuntimeError)
+      end
+
+      it 'works when redis is passed in' do
+        limiter = Berater::RateLimiter.new(:key, 1, :second, redis: redis)
+        expect {|b| limiter.limit(&b) }.to yield_control
+      end
+
+      it 'raises when redis is bogus' do
+        limiter = Berater::RateLimiter.new(:key, 1, :second, redis: :stub)
+        expect { limiter.limit }.to raise_error(RuntimeError)
+      end
+    end
   end
 
   describe '#==' do

data/spec/middleware_spec.rb

@@ -0,0 +1,110 @@
+class Meddler
+  def call(*)
+    yield
+  end
+end
+
+describe 'Berater.middleware' do
+  subject { Berater.middleware }
+
+  describe 'adding middleware' do
+    after { is_expected.to include Meddler }
+
+    it 'can be done inline' do
+      Berater.middleware.use Meddler
+    end
+
+    it 'can be done with a block' do
+      Berater.middleware do
+        use Meddler
+      end
+    end
+  end
+
+  it 'resets along with Berater' do
+    Berater.middleware.use Meddler
+    is_expected.to include Meddler
+
+    Berater.reset
+    is_expected.to be_empty
+  end
+
+  describe 'Berater::Limiter#limit' do
+    let(:middleware) { Meddler.new }
+    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 1) }
+
+    before do
+      expect(Meddler).to receive(:new).and_return(middleware).at_least(1)
+      Berater.middleware.use Meddler
+    end
+
+    it 'calls the middleware' do
+      expect(middleware).to receive(:call)
+      limiter.limit
+    end
+
+    it 'calls the middleware, passing the limiter and options' do
+      expect(middleware).to receive(:call).with(
+        limiter,
+        hash_including(:capacity, :cost)
+      )
+
+      limiter.limit
+    end
+
+    context 'when used per ususual' do
+      before do
+        expect(middleware).to receive(:call).and_call_original.at_least(1)
+      end
+
+      it 'still works inline' do
+        expect(limiter.limit).to be_a Berater::Lock
+      end
+
+      it 'still works in block mode' do
+        expect(limiter.limit { 123 }).to be 123
+      end
+
+      it 'still has limits' do
+        limiter.limit
+        expect(limiter).to be_overloaded
+      end
+    end
+
+    context 'when middleware meddles' do
+      it 'can change the capacity' do
+        expect(middleware).to receive(:call) do |limiter, opts, &block|
+          opts[:capacity] = 0
+          block.call
+        end
+
+        expect { limiter.limit }.to be_overloaded
+      end
+
+      it 'can change the cost' do
+        expect(middleware).to receive(:call) do |limiter, opts, &block|
+          opts[:cost] = 2
+          block.call
+        end
+
+        expect { limiter.limit }.to be_overloaded
+      end
+
+      it 'can change the limiter' do
+        other_limiter = Berater::Inhibitor.new
+
+        expect(middleware).to receive(:call) do |limiter, opts, &block|
+          block.call other_limiter, opts
+        end
+        expect(other_limiter).to receive(:acquire_lock).and_call_original
+
+        expect { limiter.limit }.to be_overloaded
+      end
+
+      it 'can abort by not yielding' do
+        expect(middleware).to receive(:call)
+        expect(limiter.limit).to be nil
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-22 00:00:00.000000000 Z
+date: 2021-04-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: meddleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -133,6 +147,7 @@ files:
 - lib/berater/dsl.rb
 - lib/berater/inhibitor.rb
 - lib/berater/limiter.rb
+- lib/berater/limiter_set.rb
 - lib/berater/lock.rb
 - lib/berater/lua_script.rb
 - lib/berater/rate_limiter.rb
@@ -148,9 +163,11 @@ files:
 - spec/dsl_refinement_spec.rb
 - spec/dsl_spec.rb
 - spec/inhibitor_spec.rb
+- spec/limiter_set_spec.rb
 - spec/limiter_spec.rb
 - spec/lua_script_spec.rb
 - spec/matchers_spec.rb
+- spec/middleware_spec.rb
 - spec/rate_limiter_spec.rb
 - spec/riddle_spec.rb
 - spec/static_limiter_spec.rb
@@ -185,10 +202,12 @@ test_files:
 - spec/matchers_spec.rb
 - spec/dsl_refinement_spec.rb
 - spec/test_mode_spec.rb
+- spec/middleware_spec.rb
 - spec/dsl_spec.rb
 - spec/lua_script_spec.rb
 - spec/concurrency_limiter_spec.rb
 - spec/riddle_spec.rb
+- spec/limiter_set_spec.rb
 - spec/utils_spec.rb
 - spec/berater_spec.rb
 - spec/limiter_spec.rb