pause 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/.pairs

@@ -0,0 +1,13 @@
+pairs:
+  ag: Atasay Gokkaya; atasay
+  km: Kaan Meralan; kaan
+  kg: Konstantin Gredeskoul; kig
+  ph: Paul Henry; paul
+  sf: Sean Flannagan; sean
+  es: Eric Saxby; sax
+  tn: Truong Nguyen; constantx
+  cc: Cihan Cimen; cihan
+  sc: Server Cimen; server
+email:
+  prefix: pair
+  domain: wanelo.com

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@pause --create

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pause.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#^syntax detection
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spanx\.gemspec}) { "spec"}
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# Pause
+
+Pause is a redis-backed rate-limiting client. Use it to track events, with
+rules around how often they are allowed to occur within configured time checks.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pause'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pause
+
+## Usage
+
+Configure Pause. This could be in a Rails initializer.
+
+  * resolution - The time resolution (in seconds) defining the minimum period into which action counts are
+                 aggregated. This defines the size of the persistent store. The higher the number, the less data needs
+                 to be persisted in Redis.
+  * history - The maximum amount of time (in seconds) that data is persisted
+
+```ruby
+Pause.configure do |config|
+  config.redis_host = "127.0.0.1"
+  config.redis_port = 6379
+  config.redis_db   = 1
+
+  config.resolution = 600
+  config.history    = 86400
+end
+```
+
+Define local actions for your application. These should define a scope, by
+which they are identified in the persistent store, and checks.
+
+Checks are configured with the following arguments:
+
+  * `period_seconds` - this is a period of time against which an action is tested
+  * `max_allowed` - the maximum number of times an action can be incremented during the time block determined by
+                  period seconds
+  * `block_ttl` - how long to mark an action as blocked if it goes over max-allowed
+
+Note that you should not configure a check with `period_seconds` less than the minimum resolution set in the
+Pause config. If you do so, you will actually be checking sums against the full time period.
+
+```ruby
+require 'pause'
+
+class FollowAction < Pause::Action
+  scope "ipn:follow"
+  check 600, 100, 300
+  check 3600, 200, 1200
+end
+```
+
+When an event occurs, you increment an instance of your action, optionally with a timestamp and count. This saves
+data into a redis store, so it can be checked later by other processes. Timestamps should be in unix epoch format.
+
+```ruby
+class FollowsController < ApplicationController
+  def create
+    action = FollowAction.new(user.id)
+    if action.ok?
+      # do stuff
+      action.increment!
+    else
+      # show errors
+    end
+  end
+end
+
+class OtherController < ApplicationController
+  def index
+    action = OtherAction.new(params[:thing])
+    if action.ok?
+      action.increment!(Time.now.to_i, params[:count].to_i)
+    end
+  end
+end
+```
+
+If more data is needed about why the action is blocked, the `analyze` can be called
+
+```ruby
+action = MyAction.new("thing")
+
+while true
+  action.increment!
+
+  blocked_action = action.analyze
+
+  if blocked_action
+    puts blocked_action.identifier
+    puts blocked_action.sum
+    puts blocked_action.timestamp
+
+    puts blocked_aciton.period_check.inspect
+  end
+
+  sleep 1
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/pause.rb

@@ -0,0 +1,34 @@
+require "pause/version"
+require "pause/configuration"
+require "pause/action"
+require "pause/analyzer"
+require "pause/redis/adapter"
+require 'pause/blocked_action'
+
+module Pause
+  class PeriodCheck < Struct.new(:period_seconds, :max_allowed, :block_ttl)
+    def <=>(other)
+      self.period_seconds <=> other.period_seconds
+    end
+  end
+
+  class SetElement < Struct.new(:ts, :count)
+    def <=>(other)
+      self.ts <=> other.ts
+    end
+  end
+
+  class << self
+    def analyzer
+      @analyzer ||= Pause::Analyzer.new
+    end
+
+    def configure(&block)
+      @configuration = Pause::Configuration.new.configure(&block)
+    end
+
+    def config
+      @configuration
+    end
+  end
+end

data/lib/pause/action.rb

@@ -0,0 +1,84 @@
+module Pause
+  class Action
+    attr_accessor :identifier
+
+    def initialize(identifier)
+      @identifier = identifier
+      self.class.checks = [] unless self.class.instance_variable_get(:@checks)
+    end
+
+    # Action subclasses should define their scope as follows
+    #
+    #     class MyAction < Pause::Action
+    #       scope "my:scope"
+    #     end
+    #
+    def scope
+      raise "Should implement scope. (Ex: ipn:follow)"
+    end
+
+    def self.scope(scope_identifier = nil)
+      class_variable_set(:@@class_scope, scope_identifier)
+      define_method(:scope) { scope_identifier }
+    end
+
+    # Action subclasses should define their checks as follows
+    #
+    #  period_seconds - compare all activity by an identifier within the time period
+    #  max_allowed - if the number of actions by an identifier exceeds max_allowed for the time period marked
+    #                by period_seconds, it is no longer ok.
+    #  ttl - time to mark identifier as not ok
+    #
+    #     class MyAction < Pause::Action
+    #       check 10, 20, 30 # period_seconds, max_allowed, ttl
+    #       check 20, 30, 40 # period_seconds, max_allowed, ttl
+    #     end
+    #
+    def self.check(period_seconds, max_allowed, block_ttl)
+      @checks ||= []
+      @checks << Pause::PeriodCheck.new(period_seconds, max_allowed, block_ttl)
+    end
+
+    def checks
+      self.class.instance_variable_get(:@checks)
+    end
+
+    def self.checks=(period_checks)
+      @checks = period_checks
+    end
+
+    def increment!(timestamp = Time.now.to_i, count = 1)
+      Pause.analyzer.increment(self, timestamp, count)
+    end
+
+    def ok?
+      Pause.analyzer.check(self).nil?
+    end
+
+    def analyze
+      Pause.analyzer.check(self)
+    end
+
+    def self.tracked_identifiers
+      Pause.analyzer.tracked_identifiers(self.class_scope)
+    end
+
+    def self.blocked_identifiers
+      Pause.analyzer.blocked_identifiers(self.class_scope)
+    end
+
+    def self.unblock_all
+      Pause.analyzer.adapter.delete_keys(self.class_scope)
+    end
+
+    def key
+      "#{self.scope}:#{@identifier}"
+    end
+
+    private
+
+    def self.class_scope
+      class_variable_get:@@class_scope if class_variable_defined?(:@@class_scope)
+    end
+  end
+end

data/lib/pause/analyzer.rb

@@ -0,0 +1,52 @@
+require 'pause/helper/timing'
+
+module Pause
+  class Analyzer
+    include Pause::Helper::Timing
+
+    attr_accessor :adapter
+
+    def initialize
+      @adapter ||= Pause::Redis::Adapter.new(Pause.config)
+    end
+
+    def increment(action, timestamp = Time.now.to_i, count = 1)
+      adapter.increment(action.key, timestamp, count)
+    end
+
+    def check(action)
+      analyze(action)
+    end
+
+    def tracked_identifiers(scope)
+      adapter.all_keys(scope)
+    end
+
+    def blocked_identifiers(scope)
+      adapter.blocked_keys(scope)
+    end
+
+    private
+
+    def analyze(action)
+      timestamp = period_marker(Pause.config.resolution, Time.now.to_i)
+      set = adapter.key_history(action.key)
+      action.checks.each do |period_check|
+        start_time = timestamp - period_check.period_seconds
+        set.reverse.inject(0) do |sum, element|
+          break if element.ts < start_time
+          sum += element.count
+          if sum >= period_check.max_allowed
+            adapter.block(action.key, period_check.block_ttl)
+            # Note that Time.now is different from period_marker(resolution, Time.now), which
+            # rounds down to the nearest (resolution) seconds
+            return Pause::BlockedAction.new(action, period_check, sum, Time.now.to_i)
+          end
+          sum
+        end
+      end
+      nil
+    end
+
+  end
+end

data/lib/pause/blocked_action.rb

@@ -0,0 +1,14 @@
+module Pause
+  class BlockedAction
+    attr_accessor :action, :identifier, :period_check, :sum, :timestamp
+
+    def initialize(action, period_check, sum, timestamp)
+      @action = action
+      @identifier = action.identifier
+      @period_check = period_check
+      @sum = sum
+      @timestamp = timestamp
+    end
+
+  end
+end

data/lib/pause/configuration.rb

@@ -0,0 +1,30 @@
+module Pause
+  class Configuration
+    attr_writer :redis_host, :redis_port, :redis_db, :resolution, :history
+
+    def configure
+      yield self
+      self
+    end
+
+    def redis_host
+      @redis_host || "127.0.0.1"
+    end
+
+    def redis_port
+      (@redis_port || 6379).to_i
+    end
+
+    def redis_db
+      @redis_db || '1'
+    end
+
+    def resolution
+      (@resolution || 600).to_i
+    end
+
+    def history
+      (@history || 86400).to_i
+    end
+  end
+end

data/lib/pause/helper/timing.rb

@@ -0,0 +1,9 @@
+module Pause
+  module Helper
+    module Timing
+      def period_marker(resolution, timestamp = Time.now)
+        timestamp.to_i / resolution * resolution
+      end
+    end
+  end
+end

data/lib/pause/redis/adapter.rb

@@ -0,0 +1,86 @@
+require 'pause/helper/timing'
+
+module Pause
+  module Redis
+    class Adapter
+
+      include Pause::Helper::Timing
+      attr_accessor :resolution, :time_blocks_to_keep, :history
+
+      def initialize(config)
+        @resolution = config.resolution
+        @time_blocks_to_keep = config.history / @resolution
+        @history = config.history
+      end
+
+      def increment(key, timestamp, count = 1)
+        k = white_key(key)
+        redis.multi do |redis|
+          redis.zincrby k, count, period_marker(resolution, timestamp)
+          redis.expire k, history
+        end
+
+        if redis.zcard(k) > time_blocks_to_keep
+          list = extract_set_elements(k)
+          to_remove = list.slice(0, (list.size - time_blocks_to_keep))
+          redis.zrem(k, to_remove.map(&:ts))
+        end
+      end
+
+      def key_history(key)
+        extract_set_elements(white_key(key))
+      end
+
+      def block(key, block_ttl)
+        redis.setex(blocked_key(key), block_ttl, nil)
+      end
+
+      def blocked?(key)
+        !!redis.get(blocked_key(key))
+      end
+
+      def all_keys(scope)
+        keys(white_key(scope))
+      end
+
+      def blocked_keys(scope)
+        keys(blocked_key(scope))
+      end
+
+      def delete_keys(scope)
+        ids = blocked_keys(scope)
+        increment_keys = ids.map{ |key| white_key(scope, key) }
+        blocked_keys = ids.map{ |key| blocked_key(scope, key) }
+        redis.del (increment_keys + blocked_keys)
+      end
+
+      private
+
+      def redis
+        @redis_conn ||= ::Redis.new(host: Pause.config.redis_host,
+                                    port: Pause.config.redis_port,
+                                    db:   Pause.config.redis_db)
+      end
+
+      def white_key(scope, key = nil)
+        ["i", scope, key].compact.join(':')
+      end
+
+      def blocked_key(scope, key = nil)
+        ["b", scope, key].compact.join(':')
+      end
+
+      def keys(key_scope)
+        redis.keys("#{key_scope}:*").map do |key|
+          key.gsub(/^#{key_scope}:/, "")
+        end
+      end
+
+      def extract_set_elements(key)
+        (redis.zrange key, 0, -1, :with_scores => true).map do |slice|
+          Pause::SetElement.new(slice[0].to_i, slice[1].to_i)
+        end.sort
+      end
+    end
+  end
+end

data/lib/pause/version.rb

@@ -0,0 +1,3 @@
+module Pause
+  VERSION = "0.0.1"
+end

data/pause.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pause/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pause"
+  gem.version       = Pause::VERSION
+  gem.authors       = ["Atasay Gokkaya", "Paul Henry"]
+  gem.email         = %w(atasay@wanelo.com paul@wanelo.com)
+  gem.description   = %q(Real time redis rate limiting)
+  gem.summary       = %q(Real time redis rate limiting)
+  gem.homepage      = "https://github.com/wanelo/pause"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'redis'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'fakeredis'
+  gem.add_development_dependency 'timecop'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rb-fsevent'
+end

data/spec/pause/action_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Pause::Action do
+  include Pause::Helper::Timing
+
+  class MyNotification < Pause::Action
+    scope "ipn:follow"
+    check 20, 5, 40
+    check 40, 7, 40
+  end
+
+  let(:resolution) { 10 }
+  let(:history) { 60 }
+  let(:configuration) { Pause::Configuration.new }
+
+  before do
+    Pause.stub(:config).and_return(configuration)
+    Pause.config.stub(:resolution).and_return(resolution)
+    Pause.config.stub(:history).and_return(history)
+  end
+
+  let(:action) { MyNotification.new("1237612") }
+  let(:other_action) { MyNotification.new("1237613") }
+
+  describe "#increment!" do
+    it "should increment" do
+      time = Time.now
+      Timecop.freeze time do
+        Pause.analyzer.should_receive(:increment).with(action, time.to_i, 1)
+        action.increment!
+      end
+    end
+  end
+
+  describe "#ok?" do
+    it "should successfully return if the action is blocked or not" do
+      time = Time.now
+      Timecop.freeze time do
+        4.times do
+          action.increment!
+          action.ok?.should be_true
+        end
+        action.increment!
+        action.ok?.should be_false
+      end
+    end
+
+    it "should successfully consider different period checks" do
+      time = Time.now
+      Timecop.freeze time do
+        4.times do
+          action.increment!
+          action.ok?.should be_true
+        end
+      end
+      Timecop.freeze Time.at(time.to_i + 30) do
+        2.times do
+          action.increment!
+          action.ok?.should be_true
+        end
+        action.increment!
+        action.ok?.should be_false
+      end
+    end
+  end
+
+  describe "#analyze" do
+    context "action should not be blocked" do
+      it "returns nil" do
+        action.analyze.should be_nil
+      end
+    end
+
+    context "action should be blocked" do
+      it "returns a BlockedAction object" do
+        time = Time.now
+        blocked_action = nil
+
+        Timecop.freeze time do
+          7.times { action.increment! }
+          blocked_action = action.analyze
+        end
+
+        expected_blocked_action = Pause::BlockedAction.new(action, action.checks[0], 7, time.to_i)
+
+        blocked_action.should be_a(Pause::BlockedAction)
+        blocked_action.identifier.should == expected_blocked_action.identifier
+        blocked_action.sum.should == expected_blocked_action.sum
+        blocked_action.period_check.should == expected_blocked_action.period_check
+        blocked_action.timestamp.should == expected_blocked_action.timestamp
+      end
+    end
+  end
+
+  describe "#tracked_identifiers" do
+    it "should return all the identifiers tracked (but not blocked) so far" do
+      action.increment!
+      other_action.increment!
+
+      action.ok?
+      other_action.ok?
+
+      MyNotification.tracked_identifiers.should include(action.identifier)
+      MyNotification.tracked_identifiers.should include(other_action.identifier)
+    end
+  end
+
+  describe "#blocked_identifiers" do
+    it "should return all the identifiers blocked" do
+      action.increment!(Time.now.to_i, 100)
+      other_action.increment!(Time.now.to_i, 100)
+
+      action.ok?
+      other_action.ok?
+
+      MyNotification.blocked_identifiers.should include(action.identifier)
+      MyNotification.blocked_identifiers.should include(other_action.identifier)
+    end
+  end
+
+  describe "#unblock_all" do
+    it "should unblock all the identifiers for a scope" do
+      10.times { action.increment! }
+      other_action.increment!
+
+      action.ok?
+      other_action.ok?
+
+      MyNotification.tracked_identifiers.should include(action.identifier, other_action.identifier)
+      MyNotification.blocked_identifiers.should == [action.identifier]
+
+      MyNotification.unblock_all
+
+      MyNotification.blocked_identifiers.should be_empty
+      MyNotification.tracked_identifiers.should == [other_action.identifier]
+    end
+  end
+end
+
+describe Pause::Action, ".check" do
+  class ActionWithCheck < Pause::Action
+    check 100, 150, 200
+  end
+
+  class ActionWithMultipleChecks < Pause::Action
+    check 100, 150, 200
+    check 200, 150, 200
+    check 300, 150, 200
+  end
+
+  it "should define a period check on new instances" do
+    ActionWithCheck.new("id").checks.should == [
+        Pause::PeriodCheck.new(100, 150, 200),
+    ]
+  end
+
+  it "should define a period check on new instances" do
+    ActionWithMultipleChecks.new("id").checks.should == [
+        Pause::PeriodCheck.new(100, 150, 200),
+        Pause::PeriodCheck.new(200, 150, 200),
+        Pause::PeriodCheck.new(300, 150, 200)
+    ]
+  end
+
+end
+
+describe Pause::Action, ".scope" do
+  class UndefinedScopeAction < Pause::Action
+  end
+
+  it "should raise if scope is not defined" do
+    lambda {
+      UndefinedScopeAction.new("1.2.3.4").scope
+    }.should raise_error("Should implement scope. (Ex: ipn:follow)")
+  end
+
+  class DefinedScopeAction < Pause::Action
+    scope "my:scope"
+  end
+
+  it "should set scope on class" do
+    DefinedScopeAction.new("1.2.3.4").scope.should == "my:scope"
+  end
+end

data/spec/pause/analyzer_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Pause::Analyzer do
+  include Pause::Helper::Timing
+
+  class FollowPushNotification < Pause::Action
+    scope "ipn:follow"
+    check 20, 5, 12
+    check 40, 7, 12
+  end
+
+  let(:resolution) { 10 }
+  let(:history) { 60 }
+  let(:configuration) { Pause::Configuration.new }
+
+  before do
+    Pause.stub(:config).and_return(configuration)
+    Pause.config.stub(:resolution).and_return(resolution)
+    Pause.config.stub(:history).and_return(history)
+  end
+
+  let(:analyzer) { Pause.analyzer }
+  let(:adapter) { Pause.analyzer.adapter }
+  let(:action) { FollowPushNotification.new("1243123") }
+
+  describe "#increment" do
+    it "should increment an action" do
+      time = Time.now
+      adapter.should_receive(:increment).with(action.key, time.to_i, 1)
+      Timecop.freeze time do
+        analyzer.increment(action)
+      end
+    end
+  end
+
+  describe "#analyze" do
+    it "checks and blocks if max_allowed is reached" do
+      time = Time.now
+      adapter.should_receive(:block).once.with(action.key, 12)
+      Timecop.freeze time do
+        5.times do
+          analyzer.increment(action)
+          analyzer.check(action)
+        end
+      end
+    end
+  end
+
+  describe "#check" do
+    it "should return nil if action is NOT blocked" do
+      analyzer.check(action).should be_nil
+    end
+
+    it "should return blocked action if action is blocked" do
+      Timecop.freeze Time.now do
+        5.times do
+          analyzer.increment(action)
+        end
+        analyzer.check(action).should be_a(Pause::BlockedAction)
+      end
+    end
+  end
+end

data/spec/pause/configuration_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Pause::Configuration, "#configure" do
+
+  subject { Pause::Configuration.new }
+
+  it "should allow configuration via block" do
+    subject.configure do |c|
+      c.redis_host = "128.23.12.8"
+      c.redis_port = "2134"
+      c.redis_db = "13"
+
+      c.resolution = 5000
+      c.history = 6000
+    end
+
+    subject.redis_host.should == "128.23.12.8"
+    subject.redis_port.should == 2134
+    subject.redis_db.should == "13"
+
+    subject.resolution.should == 5000
+    subject.history.should == 6000
+  end
+
+  it "should provide redis defaults" do
+    subject.configure do |config|
+      # do nothing
+    end
+
+    subject.redis_host.should == "127.0.0.1"
+    subject.redis_port.should == 6379
+    subject.redis_db.should == "1"
+    subject.resolution.should == 600 # 10 minutes
+    subject.history.should == 86400 # one day
+  end
+end

data/spec/pause/redis/adapter_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'date'
+require 'timecop'
+
+describe Pause::Redis::Adapter do
+
+  let(:resolution) { 10 }
+  let(:history) { 60 }
+  let(:configuration) { Pause::Configuration.new }
+
+  before do
+    Pause.stub(:config).and_return(configuration)
+    Pause.config.stub(:resolution).and_return(resolution)
+    Pause.config.stub(:history).and_return(history)
+  end
+
+  let(:adapter) { Pause::Redis::Adapter.new(Pause.config) }
+  let(:redis_conn) { adapter.send(:redis) }
+
+  describe '#increment' do
+    let(:key) { "213213" }
+
+    it "should add key to a redis set" do
+      adapter.increment(key, Time.now.to_i)
+      set = redis_conn.zrange(adapter.send(:white_key, key), 0, -1, :with_scores => true)
+      set.should_not be_empty
+      set.size.should eql(1)
+      set[0].size.should eql(2)
+    end
+
+    it "should remove old key from a redis set" do
+      time = Time.now
+      redis_conn.should_receive(:zrem).with(adapter.send(:white_key, key), [adapter.period_marker(resolution, time)])
+
+      adapter.time_blocks_to_keep = 1
+      Timecop.freeze time do
+        adapter.increment(key, Time.now.to_i)
+      end
+      Timecop.freeze time + (adapter.resolution + 1) do
+        adapter.increment(key, Time.now.to_i)
+      end
+    end
+
+    it "sets expiry on key" do
+      redis_conn.should_receive(:expire).with(adapter.send(:white_key, key), history)
+      adapter.increment(key, Time.now.to_i)
+    end
+  end
+
+  describe "#block" do
+    let(:key) { "ipn:follow:123461234" }
+    let(:blocked_key) { "b:#{key}" }
+    let(:ttl) { 110000 }
+
+    it "saves ip to redis with expiration" do
+      adapter.block(key, ttl)
+      redis_conn.get(blocked_key).should_not be_nil
+      redis_conn.ttl(blocked_key).should == ttl
+    end
+  end
+
+  describe "#blocked?" do
+    let(:key) { "ipn:follow:123461234" }
+    let(:blocked_key) { "b:#{key}" }
+    let(:ttl) { 110000 }
+
+    it "should return true if blocked" do
+      adapter.block(key, ttl)
+      (!!redis_conn.get(blocked_key).should) == adapter.blocked?(key)
+    end
+  end
+
+  describe "#white_key" do
+    it "prefixes key" do
+      adapter.send(:white_key, "abc").should == "i:abc"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'rubygems'
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
+require 'pause'
+
+Dir['spec/support/**/*.rb'].each { |filename| require_relative "../#{filename}" }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/fakeredis.rb

@@ -0,0 +1 @@
+require 'fakeredis/rspec'

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: pause
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Atasay Gokkaya
+- Paul Henry
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: fakeredis
+  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: timecop
+  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: guard-rspec
+  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: rb-fsevent
+  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: Real time redis rate limiting
+email:
+- atasay@wanelo.com
+- paul@wanelo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pairs
+- .rspec
+- .rvmrc
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pause.rb
+- lib/pause/action.rb
+- lib/pause/analyzer.rb
+- lib/pause/blocked_action.rb
+- lib/pause/configuration.rb
+- lib/pause/helper/timing.rb
+- lib/pause/redis/adapter.rb
+- lib/pause/version.rb
+- pause.gemspec
+- spec/pause/action_spec.rb
+- spec/pause/analyzer_spec.rb
+- spec/pause/configuration_spec.rb
+- spec/pause/redis/adapter_spec.rb
+- spec/spec_helper.rb
+- spec/support/fakeredis.rb
+homepage: https://github.com/wanelo/pause
+licenses: []
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Real time redis rate limiting
+test_files:
+- spec/pause/action_spec.rb
+- spec/pause/analyzer_spec.rb
+- spec/pause/configuration_spec.rb
+- spec/pause/redis/adapter_spec.rb
+- spec/spec_helper.rb
+- spec/support/fakeredis.rb
+has_rdoc: