throttling 0.1.0

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,9 @@
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - ree
+  - jruby
+
+notifications:
+  recipients:
+    - kpumuk@kpumuk.info

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', :version => 2, :cli => '--color --fail-fast --drb' do
+  watch(%r{^spec/.+_spec\.rb})
+  watch('lib/throttling.rb')          { 'spec'}
+  watch('spec/spec_helper.rb')        { 'spec'}
+  watch(%r{^lib/throttling/(.+)\.rb}) { |m| "spec/#{m[1]}_spec.rb" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Dmytro Shteflyuk
+
+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,113 @@
+# Throttling
+
+[![Travis-CI build status](https://secure.travis-ci.org/kpumuk/throttling.png)](http://travis-ci.org/kpumuk/throttling)
+
+Throttling gem provides basic, but very powerful way to throttle various user actions in your application. Basically you can specify how many times some action could be performed over a specified period(s) of time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'throttling'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install throttling
+
+## Configuration
+
+You can configure Throttling parameters by accessing attributes of `Throttling` module. Currently it supports only Memcached through `Rails.cache`.
+
+    Throttling.storage = Rails.cache
+    Throttling.logger = Rails.logger
+
+Throttling limits could be stored in a configuration file in `config/throttling.yml`. You can also specify another file to read limits from:
+
+    Throttling.limits_config = "#{Rails.root}/config/throttling.yml"
+
+The basic structure of the file is:
+
+    user_signup:
+      limit: 20
+      period: 3600
+
+    search_requests:
+      minutely:
+        limit: 300
+        period: 600
+      hourly:
+        limit: 1000
+        period: 3600
+      daily:
+        limit: 10000
+        period: 86400
+
+You can also specify limits as a Hash:
+
+    Throttling.limits = {
+      :user_signup => {
+        :limit  => 20,
+        :period => 3600
+      },
+      :search_requests => {
+        :minutely => {
+          :limit  => 20,
+          :period => 3600
+        },
+        :hourly => {
+          :limit  => 1000,
+          :period => 3600
+        },
+        :daily =>
+          :limit  => 10000,
+          :period => 86400
+        }
+      }
+    }
+
+You can completely disable throttling by setting `enabled` to `false`:
+
+    Throttling.enabled = false
+
+## Usage
+
+The basic usage of Throttling gem is following:
+
+    Throttling.for(:user_signup).check(:user_id, current_user.id) do
+      # Do your stuff here
+    end
+
+    if Throttling.for(:user_signup).check(:user_id, current_user.id)
+      # Action allowed
+    else
+      # Action denied
+    end
+
+For convenience, there are some simplified methods:
+
+    Throttling.for(:user_signup).check_ip(request.remote_ip)
+    Throttling.for(:user_signup).check_user_id(current_user.id)
+
+You can add more helpers like this:
+
+    Throttling::Base.class_eval do
+      def check_user_id_and_document_id(user_id, doc_id)
+        check("user_id:doc_id", "#{user_id}:#{doc_id}")
+      end
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Who are the authors?
+
+This plugin has been created in Scribd.com for our internal use and then the sources were opened for other people to use. Most of the code in this package has been developed by Oleksiy Kovyrin and Dmytro Shteflyuk for Scribd.com and is released under the MIT license. For more details, see the LICENSE file.

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec

data/lib/throttling.rb

@@ -0,0 +1,109 @@
+require 'logger'
+require 'yaml'
+
+# Simple throttling library to limit number of actions in time.
+module Throttling
+  class << self
+    # Gets current Throttling storage. By default returns Rails.cache
+    # (if it is a Rails application).
+    def storage
+      @@storage ||= (defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache) || nil
+      raise ArgumentError, 'Throttling.storage is not specified' unless @@storage
+      @@storage
+    end
+
+    # Sets a storage instance to store Throttling information in. Should implement to
+    # to methods:
+    #
+    #     def fetch(key, options = {}, &block)
+    #     def increment(key)
+    #
+    # Rails.cache is one of the storages conforming this interface.
+    def storage=(storage)
+      @@storage = storage
+    end
+
+    # Gets the logger used to output errors or warnings.
+    def logger
+      @@logger ||= (defined?(Rails) && Rails.respond_to(:logger) && Rails.logger) || Logger.new(STDOUT)
+    end
+
+    # Sets the logger used to output errors or warnings.
+    def logger=(logger)
+      @@logger = logger
+    end
+
+    # Gets a throttling limits config file path.
+    def limits_config
+      root = (defined?(Rails) && Rails.respond_to?(:root) && Rails.root) || Dir.pwd
+      @@limits_config ||= "#{root}/config/throttling.yml"
+    end
+
+    # Sets the configuration file path containing throttling limits.
+    def limits_config=(path)
+      @@limits = nil
+      @@limits_config = path
+    end
+
+    # Gets a Hash with current throttling limits.
+    def limits
+      @@limits ||= load_config(limits_config)
+    end
+
+    # Sets current throttling limits.
+    def limits=(limits)
+      @@limits = limits && limits.with_indifferent_access
+    end
+
+    # Get the value indicating whether throttling is enabled.
+    def enabled?
+      !!@@enabled
+    end
+    alias :enabled :enabled?
+
+    # Sets the value indicating whether throttling is enabled.
+    def enabled=(enabled)
+      @@enabled = !!enabled
+    end
+
+    # Enables throttling.
+    def enable!
+      @@enabled = true
+    end
+
+    # Disables throttling.
+    def disable!
+      @@enabled = false
+    end
+
+    # Returns a Throttling::Base instance for a given action.
+    def for(action)
+      @@instances[action.to_s] ||= Base.new(action.to_s)
+    end
+
+    # Resets all values to their default state (mostly for testing purpose).
+    def reset_defaults!
+      @@enabled       = true
+      @@logger        = nil
+      @@storage       = nil
+      @@limits_config = nil
+
+      # Internal variables
+      @@instances     = {}
+      @@config        = nil
+    end
+
+    private
+
+    def load_config(path)
+      return nil unless File.exists?(path)
+      YAML.load_file(path).with_indifferent_access
+    end
+  end
+
+  reset_defaults!
+end
+
+require 'throttling/indifferent_access'
+require 'throttling/base'
+require "throttling/version"

data/lib/throttling/base.rb

@@ -0,0 +1,60 @@
+module Throttling
+  # Class implements throttling for a single action.
+  class Base
+    attr_accessor :action, :limits
+
+    def initialize(action)
+      @action = action.to_s
+
+      raise ArgumentError, "No throttling limits specified" unless Throttling.limits
+      @limits = Throttling.limits[action]
+      raise ArgumentError, "No Throttling.limits[#{action}] section found" unless limits
+
+      # Convert simple limits to a hash
+      if @limits[:limit] && @limits[:period]
+        @limits = { 'global' => @limits }
+      end
+    end
+
+    def check_ip(ip)
+      check(:ip, ip)
+    end
+
+    def check_user_id(user_id)
+      check(:user_id, user_id)
+    end
+
+    def check(check_type, check_value, auto_increment = true)
+      # Disabled?
+      return true if !Throttling.enabled? || check_value.nil?
+
+      limits.each do |period_name, params|
+        raise ArgumentError, "Invalid or no 'period' parameter in the limits[#{period_name}] config" if params[:period].to_i < 1
+        raise ArgumentError, "Invalid or no 'limit' parameter in the limits[#{period_name}] config" if params[:limit].nil? || params[:limit].to_i < 0
+
+        period = params[:period].to_i
+        key = hits_store_key(check_type, check_value, period_name, period)
+
+        # Retrieve current value
+        hits = Throttling.storage.fetch(key, :expires_in => hits_store_ttl(period), :raw => true) { '0' }
+
+        # Over limit?
+        return false if hits.to_i > params[:limit].to_i
+
+        Throttling.storage.increment(key) if auto_increment
+      end
+
+      return true
+    end
+
+    private
+
+    def hits_store_key(check_type, check_value, period_name, period_value)
+      "throttle:#{action}:#{check_type}:#{check_value}:#{period_name}:#{Time.now.to_i / period_value}"
+    end
+
+    def hits_store_ttl(check_period)
+      check_period - Time.now.to_i % check_period
+    end
+  end
+end

data/lib/throttling/indifferent_access.rb

@@ -0,0 +1,152 @@
+module Throttling
+  begin
+    HashWithIndifferentAccess = ::HashWithIndifferentAccess
+  rescue NameError
+    # This class has dubious semantics and we only have it so that
+    # people can write params[:key] instead of params['key']
+    # and they get the same value for both keys.
+    #
+    # This is part of Rails' ActiveSupport project. If you are
+    # using Rails, this class will not be used.
+    #
+    class HashWithIndifferentAccess < Hash
+      def initialize(constructor = {})
+        if constructor.is_a?(Hash)
+          super()
+          update(constructor)
+        else
+          super(constructor)
+        end
+      end
+
+      def default(key = nil)
+        if key.is_a?(Symbol) && include?(key = key.to_s)
+          self[key]
+        else
+          super
+        end
+      end
+
+      alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+      alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+      # Assigns a new value to the hash:
+      #
+      #   hash = HashWithIndifferentAccess.new
+      #   hash[:key] = "value"
+      #
+      def []=(key, value)
+        regular_writer(convert_key(key), convert_value(value))
+      end
+
+      # Updates the instantized hash with values from the second:
+      #
+      #   hash_1 = HashWithIndifferentAccess.new
+      #   hash_1[:key] = "value"
+      #
+      #   hash_2 = HashWithIndifferentAccess.new
+      #   hash_2[:key] = "New Value!"
+      #
+      #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+      #
+      def update(other_hash)
+        other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+        self
+      end
+
+      alias_method :merge!, :update
+
+      # Checks the hash for a key matching the argument passed in:
+      #
+      #   hash = HashWithIndifferentAccess.new
+      #   hash["key"] = "value"
+      #   hash.key? :key  # => true
+      #   hash.key? "key" # => true
+      #
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      # Fetches the value for the specified key, same as doing hash[key]
+      def fetch(key, *extras)
+        super(convert_key(key), *extras)
+      end
+
+      # Returns an array of the values at the specified indices:
+      #
+      #   hash = HashWithIndifferentAccess.new
+      #   hash[:a] = "x"
+      #   hash[:b] = "y"
+      #   hash.values_at("a", "b") # => ["x", "y"]
+      #
+      def values_at(*indices)
+        indices.collect {|key| self[convert_key(key)]}
+      end
+
+      # Returns an exact copy of the hash.
+      def dup
+        HashWithIndifferentAccess.new(self)
+      end
+
+      # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+      # Does not overwrite the existing hash.
+      def merge(hash)
+        self.dup.update(hash)
+      end
+
+      # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+      # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+      def reverse_merge(other_hash)
+        super other_hash.with_indifferent_access
+      end
+
+      # Removes a specified key from the hash.
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def stringify_keys!; self end
+      def symbolize_keys!; self end
+      def to_options!; self end
+
+      # Convert to a Hash with String keys.
+      def to_hash
+        Hash.new(default).merge(self)
+      end
+
+      protected
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.to_s : key
+        end
+
+        def convert_value(value)
+          case value
+          when Hash
+            value.with_indifferent_access
+          when Array
+            value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+          else
+            value
+          end
+        end
+    end
+
+    module HashIndifferentAccess #:nodoc:
+      def with_indifferent_access
+        hash = HashWithIndifferentAccess.new(self)
+        hash.default = self.default
+        hash
+      end
+    end
+
+    class ::Hash #:nodoc:
+      unless respond_to?(:with_indifferent_access)
+        include Throttling::HashIndifferentAccess
+      end
+    end
+  end
+end

data/lib/throttling/version.rb

@@ -0,0 +1,3 @@
+module Throttling
+  VERSION = "0.1.0"
+end

data/spec/base_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Throttling do
+  before do
+    Throttling.reset_defaults!
+    @storage = Throttling.storage = TestStorage.new
+  end
+
+  describe 'instance methods' do
+    before do
+      Throttling.limits = { 'foo' => {'limit' => 5, 'period' => 2} }
+      @t = Throttling.for('foo')
+    end
+
+    { :check_ip => '127.0.0.1', :check_user_id => 123 }.each do |check_method, valid_value|
+      describe check_method do
+        it 'should return true for nil check_values' do
+          @t.send(check_method, nil).should be_true
+        end
+
+        it 'should raise an exception if no limit specified in configs' do
+          Throttling.limits['foo']['limit'] = nil
+          lambda { @t.send(check_method, valid_value) }.should raise_error(ArgumentError)
+        end
+
+        it 'should raise an exception if no period specified in configs' do
+          Throttling.limits['foo']['period'] = nil
+          lambda { @t.send(check_method, valid_value) }.should raise_error(ArgumentError)
+        end
+
+        it 'should raise an exception if invalid period specified in configs' do
+          Throttling.limits['foo']['period'] = -1
+          lambda { @t.send(check_method, valid_value) }.should raise_error(ArgumentError)
+
+          Throttling.limits['foo']['period'] = 'foo'
+          lambda { @t.send(check_method, valid_value) }.should raise_error(ArgumentError)
+        end
+
+        it 'should return true if throttling limit is not passed' do
+          @storage.should_receive(:fetch).and_return(1)
+          @t.send(check_method, valid_value).should be_true
+        end
+
+        it 'should return false if throttling limit is passed' do
+          @storage.should_receive(:fetch).and_return(Throttling.limits['foo']['limit'] + 1)
+          @t.send(check_method, valid_value).should be_false
+        end
+
+        context 'around limit' do
+          it 'should increase hit counter when values equals to limit - 1' do
+            @storage.should_receive(:fetch).and_return(Throttling.limits['foo']['limit'] - 1)
+            @storage.should_receive(:increment)
+            @t.send(check_method, valid_value)
+          end
+
+          it 'should increase hit counter when values equals to limit' do
+            @storage.should_receive(:fetch).and_return(Throttling.limits['foo']['limit'])
+            @storage.should_receive(:increment)
+            @t.send(check_method, valid_value)
+          end
+
+          it 'should increase hit counter when values equals to limit + 1' do
+            @storage.should_receive(:fetch).and_return(Throttling.limits['foo']['limit'] + 1)
+            @storage.should_not_receive(:increment)
+            @t.send(check_method, valid_value)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'with multi-level limits' do
+    before do
+      Throttling.limits = { 'foo' => { 'one' => { 'limit' => 5, 'period' => 2 }, 'two' => { 'limit' => 10, 'period' => 20 } } }
+    end
+
+    it "should return false if at least one limit is reached" do
+      @storage.should_receive(:fetch).and_return(1, 100)
+      Throttling.for('foo').check_ip('127.0.0.1').should be_false
+    end
+
+    it "should return true if none limits reached" do
+      @storage.should_receive(:fetch).and_return(1, 2)
+      Throttling.for('foo').check_ip('127.0.0.1').should be_true
+    end
+  end
+
+  context do
+    before do
+      Throttling.limits = { 'foo' => {'limit' => 5, 'period' => 86400} }
+      @timestamp = 1334261569
+    end
+
+    describe 'key name' do
+      it 'should include type, value, name, and period start' do
+        Timecop.freeze(Time.at(@timestamp)) do
+          Throttling.for('foo').check_ip('127.0.0.1')
+        end
+        @storage.values.keys.first.should == 'throttle:foo:ip:127.0.0.1:global:15442'
+      end
+    end
+
+    describe 'key expiration' do
+      it 'should calculate expiration time' do
+        Timecop.freeze(Time.at(@timestamp)) do
+          Throttling.for('foo').check_ip('127.0.0.1')
+        end
+        @storage.values.values.first[:expires_in].should == 13631
+      end
+    end
+  end
+end

data/spec/fixtures/throttling.yml

@@ -0,0 +1,14 @@
+user_signup:
+  limit: 20
+  period: 3600
+
+search_requests:
+  minutely:
+    limit: 300
+    period: 600
+  hourly:
+    limit: 1000
+    period: 3600
+  daily:
+    limit: 10000
+    period: 86400

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+require 'throttling'
+require 'timecop'
+
+class TestStorage
+  attr_reader :values
+
+  def fetch(key, options = {}, &block)
+    @values ||= {}
+    value = @values.fetch(key, &block)
+    @values[key] = options.merge(:value => value.to_s)
+    value
+  end
+
+  def increment(key)
+    @values ||= {}
+    @values[key] ||= { :value => 0 }
+    @values[key][:value] = (@values[key][:value].to_i + 1).to_s
+  end
+end

data/spec/throttling_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Throttling do
+  after :each do
+    Throttling.reset_defaults!
+  end
+
+  context 'with defaults' do
+    it 'should create logger' do
+      Throttling.logger.should be_a(Logger)
+    end
+
+    it 'should be enabled' do
+      Throttling.enabled?.should be_true
+      Throttling.enabled.should be_true
+    end
+
+    it 'should set config file path' do
+      Throttling.limits_config.should == "#{Dir.pwd}/config/throttling.yml"
+    end
+  end
+
+  context 'setters' do
+    it 'should allow to enabled and disable client' do
+      Throttling.enabled = false
+      Throttling.should_not be_enabled
+
+      Throttling.enable!
+      Throttling.should be_enabled
+
+      Throttling.disable!
+      Throttling.should_not be_enabled
+
+      Throttling.enabled = true
+      Throttling.should be_enabled
+    end
+
+    it 'should allow to change logger' do
+      mock = Throttling.logger = mock('Logger')
+      Throttling.logger.should be(mock)
+    end
+
+    it 'should allow to set limits' do
+      limits = { 'foo' => {'limit' => 5, 'period' => 2} }
+      Throttling.limits = limits
+      Throttling.limits.should == limits
+    end
+
+    it 'should allow to change config file path' do
+      path = File.expand_path('../fixtures/throttling.yml', __FILE__)
+      Throttling.limits_config = path
+      Throttling.limits_config.should == path
+    end
+  end
+
+  describe '.for' do
+    it "should return a throttling class instance" do
+      Throttling.limits = { 'foo' => {'limit' => 5, 'period' => 2} }
+      Throttling.for('foo').should be_instance_of(Throttling::Base)
+    end
+
+    it "should raise an exception if no throttling_limits found in config" do
+      Throttling.limits = nil
+      lambda { Throttling.for('foo') }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an exception if no throttling_limits[action] found in config" do
+      Throttling.limits = { 'foo' => nil }
+      lambda { Throttling.for('foo') }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe 'limits' do
+    context 'when set using .limits' do
+      it 'should convert Hash to HashWithIndifferentAccess' do
+        Throttling.limits = { 'foo' => {'limit' => 5, 'period' => 2} }
+        Throttling.limits.should have_key(:foo)
+        Throttling.limits.should have_key('foo')
+        Throttling.limits[:foo].should have_key(:limit)
+        Throttling.limits[:foo].should have_key('limit')
+      end
+    end
+
+    context 'when set using .limits_config' do
+      before do
+        Throttling.limits_config = File.expand_path('../fixtures/throttling.yml', __FILE__)
+      end
+
+      it 'should load limits from configuration file' do
+        Throttling.limits.should be_kind_of(Hash)
+        Throttling.limits.should have_key('search_requests')
+        Throttling.limits.should have_key('user_signup')
+      end
+
+      it 'should convert Hash to HashWithIndifferentAccess' do
+        Throttling.limits.should have_key(:search_requests)
+        Throttling.limits.should have_key('search_requests')
+        Throttling.limits[:search_requests].should have_key(:daily)
+        Throttling.limits[:search_requests].should have_key('daily')
+      end
+    end
+  end
+end

data/throttling.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/throttling/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Dmytro Shteflyuk", "Oleksiy Kovyrin"]
+  gem.email         = ["kpumuk@kpumuk.info"]
+  gem.description   = %q{Throttling gem provides basic, but very powerful way to throttle various user actions in your application}
+  gem.summary       = %q{Easy throttling for Ruby applications}
+  gem.homepage      = "https://github.com/kpumuk/throttling"
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'timecop'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rb-fsevent'
+  gem.add_development_dependency 'growl'
+
+  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.name          = "throttling"
+  gem.require_paths = ["lib"]
+  gem.version       = Throttling::VERSION
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: throttling
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dmytro Shteflyuk
+- Oleksiy Kovyrin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70193684278040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70193684278040
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70193684277620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70193684277620
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70193684277200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70193684277200
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70193684276780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70193684276780
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: &70193684276360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70193684276360
+- !ruby/object:Gem::Dependency
+  name: growl
+  requirement: &70193684275940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70193684275940
+description: Throttling gem provides basic, but very powerful way to throttle various
+  user actions in your application
+email:
+- kpumuk@kpumuk.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/throttling.rb
+- lib/throttling/base.rb
+- lib/throttling/indifferent_access.rb
+- lib/throttling/version.rb
+- spec/base_spec.rb
+- spec/fixtures/throttling.yml
+- spec/spec_helper.rb
+- spec/throttling_spec.rb
+- throttling.gemspec
+homepage: https://github.com/kpumuk/throttling
+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.15
+signing_key: 
+specification_version: 3
+summary: Easy throttling for Ruby applications
+test_files:
+- spec/base_spec.rb
+- spec/fixtures/throttling.yml
+- spec/spec_helper.rb
+- spec/throttling_spec.rb