prop 1.0.1 → 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c6876580ba3b335c884fbf9f549931b1a200f8be
+  data.tar.gz: 062fa3bf0d3f237e09ad258a1257559581bdfcf5
+SHA512:
+  metadata.gz: 75bf0a8a9c115a60e1ffaafa00aaf14c28837174a4a6efbb84183838963bc022c53dc5625bdfdb9ea71145b63a4edfd3127d6684744e5ad993c3b4d09d9231b2
+  data.tar.gz: ed67700ce432878bd7790145779f309d6a7b82192421cd5bbefe99133f6d99e3f385a5ec7a17360e79de8a05835cc60c5cda3bc0dacf0e5b8b15f47234ac7ebd

data/.travis.yml

@@ -1,4 +1,5 @@
 rvm:
+  - 2.0.0
   - 1.8.7
   - 1.9.3
   - jruby

data/lib/prop.rb

@@ -2,12 +2,12 @@ require "prop/limiter"
 require "forwardable"
 
 module Prop
-  VERSION = "0.7.8"
+  VERSION = "1.0.2"
 
   # Short hand for accessing Prop::Limiter methods
   class << self
     extend Forwardable
     def_delegators :"Prop::Limiter", :read, :write, :configure, :disabled, :before_throttle
-    def_delegators :"Prop::Limiter", :throttle!, :throttled?, :count, :query, :reset
+    def_delegators :"Prop::Limiter", :throttle, :throttle!, :throttled?, :count, :query, :reset
   end
 end

data/lib/prop/limiter.rb

@@ -49,11 +49,10 @@ module Prop
       # handle  - the registered handle associated with the action
       # key     - a custom request specific key, e.g. [ account.id, "download", request.remote_ip ]
       # options - request specific overrides to the defaults configured for this handle
-      # blk     - an optional block of code that this throttle is guarding
+      # (optional) a block of code that this throttle is guarding
       #
-      # Raises Prop::RateLimited if the number if the threshold for this handle has been reached
-      # Returns the value of the block if given a such, otherwise the current count of the throttle
-      def throttle!(handle, key = nil, options = {}, &blk)
+      # Returns true if the threshold for this handle has been reached, else returns false
+      def throttle(handle, key = nil, options = {})
         options, cache_key = prepare(handle, key, options)
         counter = reader.call(cache_key).to_i
 
@@ -63,18 +62,35 @@ module Prop
               before_throttle_callback.call(handle, key, options[:threshold], options[:interval])
             end
 
-            raise Prop::RateLimited.new(options.merge(:cache_key => cache_key, :handle => handle))
+            true
           else
             increment = options.key?(:increment) ? options[:increment].to_i : 1
-            counter   = writer.call(cache_key, counter + increment)
+            writer.call(cache_key, counter + increment)
+
+            yield if block_given?
+
+            false
           end
         end
+      end
+
+      # Public: Records a single action for the given handle/key combination.
+      #
+      # handle  - the registered handle associated with the action
+      # key     - a custom request specific key, e.g. [ account.id, "download", request.remote_ip ]
+      # options - request specific overrides to the defaults configured for this handle
+      # (optional) a block of code that this throttle is guarding
+      #
+      # Raises Prop::RateLimited if the number if the threshold for this handle has been reached
+      # Returns the value of the block if given a such, otherwise the current count of the throttle
+      def throttle!(handle, key = nil, options = {})
+        options, cache_key = prepare(handle, key, options)
 
-        if block_given?
-          yield
-        else
-          counter
+        if throttle(handle, key, options)
+          raise Prop::RateLimited.new(options.merge(:cache_key => cache_key, :handle => handle))
         end
+
+        block_given? ? yield : reader.call(cache_key).to_i
       end
 
       # Public: Allows to query whether the given handle/key combination is currently throttled

data/prop.gemspec

@@ -1,6 +1,6 @@
-Gem::Specification.new "prop", "1.0.1" do |s|
+Gem::Specification.new "prop", "1.0.2" do |s|
   s.name              = 'prop'
-  s.version           = '1.0.1'
+  s.version           = '1.0.2'
   s.date              = '2012-04-24'
   s.rubyforge_project = 'prop'
   s.license           = "Apache License Version 2.0"

data/test/helper.rb

@@ -1,7 +1,5 @@
 require 'rubygems'
 
-require "minitest/spec"
-require "minitest/mock"
 require "minitest/autorun"
 require 'mocha/setup'
 

data/test/test_limiter.rb

@@ -11,98 +11,142 @@ describe Prop::Limiter do
 
     @start = Time.now
     Time.stubs(:now).returns(@start)
+
+    Prop.reset(:something)
   end
 
-  describe "#throttle!" do
-    before do
-      Prop.reset(:something)
+  describe "#throttle" do
+    describe "when disabled" do
+      before { Prop::Limiter.stubs(:disabled?).returns(true) }
+
+      it "returns nil" do
+        assert_nil Prop.throttle(:something)
+      end
     end
 
-    describe "when disabled" do
-      before { Prop::Limiter.expects(:disabled?).returns(true) }
+    describe "when not disabled" do
+      before { Prop::Limiter.stubs(:disabled?).returns(false) }
 
-      [ true, false ].each do |threshold_reached|
-        describe "and threshold has #{"not " unless threshold_reached}been reached" do
-          before { Prop::Limiter.stubs(:at_threshold?).returns(threshold_reached) }
+      describe "and the threshold has been reached" do
+        before { Prop::Limiter.stubs(:at_threshold?).returns(true) }
 
-          describe "given a block" do
-            it "execute that block" do
-              assert_equal "wibble", Prop.throttle!(:something) { "wibble" }
-            end
+        it "returns true" do
+          assert Prop.throttle(:something)
+        end
+
+        it "does not increment the throttle count" do
+          Prop.throttle(:something)
+
+          assert_equal 0, Prop.count(:something)
+        end
+
+        describe "when given a block" do
+          before { @test_block_executed = false }
+
+          it "does not execute the block" do
+            Prop.throttle(:something) { @test_block_executed = true }
+
+            refute @test_block_executed
           end
+        end
 
-          describe "not given a block" do
-            it "return the current throttle count" do
-              assert_equal Prop.count(:something), Prop.throttle!(:something)
+        describe "when a before_throttle callback has been specified" do
+          before do
+            Prop.before_throttle do |handle, key, threshold, interval|
+              @handle    = handle
+              @key       = key
+              @threshold = threshold
+              @interval  = interval
             end
+
+            Prop.throttle(:something, [:extra])
+          end
+
+          it "invokes callback with expected parameters" do
+            assert_equal @handle, :something
+            assert_equal @key, [:extra]
+            assert_equal @threshold, 10
+            assert_equal @interval, 10
           end
         end
       end
-    end
 
-    describe "when not disabled" do
-      before { Prop::Limiter.expects(:disabled?).returns(false) }
+      describe "and the threshold has not been reached" do
+        before { Prop::Limiter.stubs(:at_threshold?).returns(false) }
 
-      describe "and threshold has been reached" do
-        before { Prop::Limiter.expects(:at_threshold?).returns(true) }
+        it "returns false" do
+          refute Prop.throttle(:something)
+        end
 
-        describe "given a block" do
-          it "raise Prop::RateLimited" do
-            assert_raises(Prop::RateLimited) { Prop.throttle!(:something) { "wibble" }}
-          end
+        it "increments the throttle count by one" do
+          Prop.throttle(:something)
 
-          it "raise even if given :increment => 0" do
-            value = Prop.count(:something)
-            assert_raises(Prop::RateLimited) { Prop.throttle!(:something, nil, :increment => 0) { "wibble" }}
-            assert_equal value, Prop.count(:something)
-          end
+          assert_equal 1, Prop.count(:something)
+        end
 
-          describe "and given a before_throttle callback" do
-            before do
-              Prop.before_throttle do |handle, key, threshold, interval|
-                @handle = handle
-                @key = key
-                @threshold = threshold
-                @interval = interval
-              end
-            end
+        it "increments the throttle count by the specified number when provided" do
+          Prop.throttle(:something, nil, :increment => 5)
 
-            it "invoke callback with expected parameters" do
-              assert_raises(Prop::RateLimited) { Prop.throttle!(:something, [:extra]) }
-              assert_equal @handle, :something
-              assert_equal @key, [:extra]
-              assert_equal @threshold, 10
-              assert_equal @interval, 10
-            end
-          end
+          assert_equal 5, Prop.count(:something)
         end
 
-        describe "not given a block" do
-          it "raise Prop::RateLimited" do
-            assert_raises(Prop::RateLimited) { Prop.throttle!(:something) }
+        describe "when given a block" do
+          before { @test_block_executed = false }
+
+          it "executes the block" do
+            Prop.throttle(:something) { @test_block_executed = true }
+
+            assert @test_block_executed
           end
         end
       end
+    end
+  end
 
-      describe "and threshold has not been reached" do
-        before do
-          Prop::Limiter.expects(:at_threshold?).returns(false)
-        end
+  describe "#throttle!" do
+    it "throttles the given handle/key combination" do
+      Prop::Limiter.expects(:throttle).with(
+        :something,
+        :key,
+        {
+          :threshold => 10,
+          :interval  => 10,
+          :key       => 'key',
+          :options   => true
+        }
+      )
+
+      Prop.throttle!(:something, :key, :options => true)
+    end
+
+    describe "when the threshold has been reached" do
+      before { Prop::Limiter.stubs(:throttle).returns(true) }
+
+      it "raises a rate-limited exception" do
+        assert_raises(Prop::RateLimited) { Prop.throttle!(:something) }
+      end
+
+      describe "when given a block" do
+        before { @test_block_executed = false }
 
-        describe "given a block" do
-          it "execute that block" do
-            assert_equal "wibble", Prop.throttle!(:something) { "wibble" }
+        it "does not executes the block" do
+          begin
+            Prop.throttle!(:something) { @test_block_executed = true }
+          rescue Prop::RateLimited
+            refute @test_block_executed
           end
         end
+      end
+    end
 
-        describe "not given a block" do
-          it "return the updated throttle count" do
-            assert_equal Prop.count(:something) + 1, Prop.throttle!(:something)
-          end
+    describe "when the threshold has not been reached" do
+      it "returns the counter value" do
+        assert_equal Prop.count(:something) + 1, Prop.throttle!(:something)
+      end
 
-          it "not update count if passed an increment of 0" do
-            assert_equal Prop.count(:something), Prop.throttle!(:something, nil, :increment => 0)
-          end
+      describe "when given a block" do
+        it "returns the return value of the block" do
+          assert_equal 'block_value', Prop.throttle!(:something) { 'block_value' }
         end
       end
     end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prop
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.0.2
 platform: ruby
 authors:
 - Morten Primdahl
@@ -14,65 +13,57 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Gem for implementing rate limits.
@@ -106,27 +97,26 @@ files:
 homepage: http://github.com/zendesk/prop
 licenses:
 - Apache License Version 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: prop
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Gem for implementing rate limits.
 test_files:
 - test/test_key.rb