curbit 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Scott Sayles
+
+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/Manifest

@@ -0,0 +1,12 @@
+LICENSE
+Manifest
+README.rdoc
+Rakefile
+curbit.gemspec
+init.rb
+lib/curbit.rb
+test/custom_key_controller_test.rb
+test/custom_message_format_controller.rb
+test/standard_controller_test.rb
+test/test_helper.rb
+test/test_rails_helper.rb

data/README.rdoc

@@ -0,0 +1,162 @@
+= CurbIt
+CurbIt makes it easy to add application level rate limiting to your Rails
+app by using a controller macro. 
+
+CurbIt is NOT a replacement for properly configured rate limiting at
+fronting services.  Properly defending your app against DoS attacks or
+other malicious client behavior should always include configuring rate
+limiting and throttling at the services that sit in front of your app.
+This includes firewalls, load balancers, and reverse proxies.  But
+sometimes that just isn't enough.  Sometimes you want to rate limit
+requests from users based on application logic that is not practical
+to get to or replicate in those services.
+
+= Usage
+
+=== Minimal configuration
+
+Quick setup inside your Rails controller.  ActionController::Base is
+already extended to include Curbit.  This will add a rate_limit "macro" to
+your controllers.
+
+  class InvitesController < ApplicationController
+    def invite
+      # invite logic...
+    end
+
+    rate_limit :invite, :max_calls => 2, :time_limit => 30.seconds, :wait_time => 1.minute
+  end
+
+If a user calls the invite service from the same remote address more than
+2 times within 30 seconds, CurbIt will render a '503 Service Unavailable'
+response and the invite method is never called.  The user will then need
+to wait 1 minute before being allowed to make the request again.
+Default response messages for html, xml, and json formats are rendered as required.
+
+=== Custom client identifier
+
+If you don't want to use the remote address to identify the client,
+you can specify a method that CurbIt will call to get a key from.
+
+  class InvitesController < ApplicationController
+    def invite
+      # invite logic...
+    end
+
+    rate_limit :invite, :key => :userid, :max_calls => 2,
+                        :time_limit => 30.seconds, :wait_time => 1.minute
+    def userid
+      session[:user_id]
+    end
+  end
+
+CurbIt will call the :userid method and use the returned value to
+create a unique identifier.  This identifier is used to index cached
+information about the request.
+
+You can alternatively pass a Proc that will take the controller
+instance as an argument.  
+
+     rate_limit :invite, :key => proc {|c| c.session[:user_id]},
+                         :max_calls => 2,
+                         :time_limit => 30.seconds, :wait_time => 1.minute
+
+(If you're wondering why CurbIt passes the controller into the proc, it's
+because the Proc is not bound to the controller instance when it's
+defined.  This way, you can at least have access to stuff you might need.)
+
+=== Custom message
+
+You might like to customize the messages returned by CurbIt.
+
+  class InvitesController < ApplicationController
+    def invite
+      # invite logic...
+    end
+
+    rate_limit :invite, :max_calls => 2, :time_limit => 30.seconds, :wait_time => 1.minute,
+                        :message => "Hey! Slow down there cow polk.",
+                        :status => 200
+  end
+
+After reaching the maximum threshold of requests, CurbIt will render the
+message "Hey! Slow down there cow polk." with a response status of 200.
+If :status is not defined, CurbIt will set a 503 status on the response.
+CurbIt will also embed this message into some default json or xml
+containers based on the request format.
+
+=== Custom message rendering
+CurbIt does it's best to render a response based on the requested format,
+but you might have an obscure mime-type you're using or you might like to
+customize the response rendering.
+
+  class InvitesController < ApplicationController
+    def invite
+      # invite logic...
+    end
+
+    rate_limit :invite, :max_calls => 2, :time_limit => 30.seconds, :wait_time => 1.minute,
+                        :message => :limit_response
+
+    def limit_response(wait_time)
+      respond_to {|fmt|
+        fmt.csv {
+          render :text => "Plese wait #{wait_time} seconds before trying again",
+                 :status => 200
+        }
+      }
+    end
+
+  end
+
+Here, CurbIt will relinquish all control for response rendering to your
+method.  This will ignore any :status argument set in the cofig options.
+
+=== Default response bodies
+* xml: <error>message</error>
+* json: {"error":{"message"}}
+* html: message
+* text: message
+
+
+= Rails Installation
+
+== As a Gem
+
+=== Gem install
+
+  $ gem install curbit --source http://gems.github.com
+
+=== Rails dependency
+Specify the gem dependency in your config/environment.rb file:
+
+  Rails::Initializer.run do |config|
+    #...
+    config.gem "curbit", :source => "http://gems.github.com"
+    #...
+  end
+
+Then:
+
+  $ rake gems:install
+  $ rake gems:unpack
+
+== As a Plugin
+
+  $ script/plugin install git://github.com/ssayles/curbit.git
+
+= Requirements
+* Rails >= 2.0
+* memcached or other compatible caching support in Rails.  CurbIt has to store information about requests and assumes your cache implementation will be able to take calls like:
+
+  Rails.cache.write(key, value, :expires_in => wait_time)
+
+That's it!
+
+= Credits
+
+CurbIt is written and maintained by {Scott Sayles}[mailto:ssayles@users.sourceforge.net].  
+
+= Copyright
+
+Copyright (c) 2009 Scott Sayles. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "curbit"
+    gem.summary = %Q{Rails plugin for application level rate limiting}
+    gem.description = %Q{TODO: longer description of your gem}
+    gem.email = "ssayles@users.sourceforge.net"
+    gem.homepage = "http://github.com/ssayles/curbit"
+    gem.authors = ["Scott Sayles"]
+    gem.add_development_dependency "thoughtbot-shoulda"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Echoe.new('curbit', '0.1.0') do |p|
+  p.description = "Application level rate limiting for Rails"
+  p.url = "http://github.com/ssayles/curbit"
+  p.author = "Scott Sayles"
+  p.email = "ssayles@users.sourceforge.net"
+  p.ignore_pattern = ["tmp/*"]
+  #p.develoment_dependencies = []
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "curbit #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/curbit.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{curbit}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Scott Sayles"]
+  s.date = %q{2009-10-25}
+  s.description = %q{Application level rate limiting for Rails}
+  s.email = %q{ssayles@users.sourceforge.net}
+  s.extra_rdoc_files = ["LICENSE", "README.rdoc", "lib/curbit.rb"]
+  s.files = ["LICENSE", "README.rdoc", "Rakefile", "init.rb", "lib/curbit.rb", "test/custom_key_controller_test.rb", "test/custom_message_format_controller.rb", "test/standard_controller_test.rb", "test/test_helper.rb", "test/test_rails_helper.rb", "Manifest", "curbit.gemspec"]
+  s.homepage = %q{http://github.com/ssayles/curbit}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Curbit", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{curbit}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Application level rate limiting for Rails}
+  s.test_files = ["test/custom_key_controller_test.rb", "test/standard_controller_test.rb", "test/test_helper.rb", "test/test_rails_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+ActionController::Base.include(Curbit::Controller)

data/lib/curbit.rb

@@ -0,0 +1,206 @@
+module Curbit
+  module Controller
+
+    CacheKeyPrefix = "crl_key"
+
+    def self.included(controller)
+      controller.extend ClassMethods
+    end
+
+    module ClassMethods
+
+
+      # Establishes a before filter for the specified method that will limit
+      # calls to it based on the given options:
+      #
+      # ==== Options
+        # * +key+ - A symbol representing an instance method or Proc that will return the key used to identify calls. This is what is used to destinguish one call from another. If not specified, the client ip derived from the request will be used.  This will check for a HTTP_X_FORWARDED_FOR header first before using <tt>request.remote_addr</tt>.  The Proc will be passed the controller instance as it is out of scope when the Proc is initially created (so you can get at request, params, etc.).
+      # * +max_calls+ - maximum number of calls allowed. Required.
+      # * +time_limit+ - only :max_calls will be allowed within the specific time frame (in seconds).  If :max_calls is reached within this time, the call will be halted. Required.
+      # * +wait_time+ - The time to wait if :max_calls has been reached before being able to pass.
+      # * +message+ - The message to render to the client if the call is being limited.  The message will be rendered as a correspondingly formatted response with a default status if given a String.  If the argument is a symbol, a method with the same name will be invoked with the specified wait_time (in seconds).  The called method should take care of rendering the response.
+      # * +status+ - The response status to set when the call is being limited.
+      #
+      # ==== Examples
+      # 
+      # class InviteController < ApplicationController
+      #   
+      #   include Curbit::Controller
+      #
+      #   def validate
+      #     # validate code
+      #   end
+      #
+      #   rate_limit :validate, :max_calls => 10,
+      #                         :time_limit => 1.minute,
+      #                         :wait_time => 1.minute,
+      #                         :message => 'Too many attempts to validate your invitation code.  Please wait 1 minute before trying again.'
+      #
+      #
+      #   def invite
+      #     # invite code
+      #   end
+      #
+      #   rate_limit :invite, :key => proc {|c| c.session[:userid]},
+      #                        :max_calls => 2,
+      #                        :time_limit => 30.seconds,
+      #                        :wait_time => 1.minute
+      # end
+      #
+      def rate_limit(method, opts)
+
+        return unless rate_limit_opts_valid?(opts)
+
+        self.class_eval do
+          define_method "rate_limit_#{method}" do
+            rate_limit_filter(method, opts)
+          end
+        end
+        self.before_filter("rate_limit_#{method}", :only => method)
+      end
+
+      private 
+
+      def rate_limit_opts_valid?(opts = {})
+        new_opts = {:status => 503}.merge! opts
+        opts.merge! new_opts
+        if !opts.key?(:max_calls) or !opts.key?(:time_limit) or !opts.key?(:wait_time)
+          raise ":max_calls, :time_limit, and :wait_time are required parameters"
+        end
+        true
+      end
+    end
+
+
+    private 
+
+    def curbit_cache_key(key, method)
+      # TODO: this won't work if there are more than one controller with
+      # the same name in the same app
+      "#{CacheKeyPrefix}_#{self.class.name}_#{method}_#{key}"
+    end
+
+    def rate_limit_filter(method, opts)
+      key = get_key(opts[:key])
+      unless (key)
+        return true
+      end
+
+      cache_key = curbit_cache_key(key, method)
+
+      val = Rails.cache.read(cache_key)
+
+      if (val)
+        started_at = val[:started]
+        count = val[:count]
+        val[:count] = count + 1
+        started_waiting = val[:started_waiting]
+
+        if started_waiting
+          # did we exceed the wait time?
+          if Time.now.to_i > (started_waiting.to_i + opts[:wait_time])
+            Rails.cache.delete(cache_key)
+            return true
+          else
+            get_message(opts)
+            return false
+          end
+        elsif within_time_limit? started_at, opts[:time_limit]
+          # did we exceed max calls?
+          if val[:count] > opts[:max_calls]
+            # start waiting and render the message
+            val[:started_waiting] = Time.now
+            Rails.cache.write(cache_key, val, :expires_in => opts[:wait_time])
+
+            get_message(opts)
+
+            return false
+          else
+            # just update the count
+            Rails.cache.write(cache_key, val, :expires_in => opts[:wait_time])
+            return true
+          end
+        else
+          # we exceeded the time limit, so just reset
+          val = {:started => Time.now, :count => 1}
+          Rails.cache.write(cache_key, val, :expires_in => opts[:time_limit])
+          return true
+        end
+      else
+        val = {:started => Time.now, :count => 1}
+        Rails.cache.write(cache_key, val, :expires_in => opts[:time_limit])
+      end
+    end
+
+    def within_time_limit?(started_at, limit)
+      Time.now.to_i < (started_at.to_i + limit)
+    end
+
+    # attempts to get the key based on the given option or
+    # will attempt to use the remote address
+    def get_key(opt)
+      key = nil
+      if (opt)
+        if opt.is_a? Proc
+          key = opt.call(self) # passing it the controller instance
+        elsif opt.is_a? Symbol
+          key = self.send(opt) if self.respond_to? opt
+        end
+      else
+        if request.env['HTTP_X_FORWARDED_FOR'] 
+          key = request.env['HTTP_X_FORWARDED_FOR'] 
+        else
+          addr = request.remote_addr
+          if (addr == "0.0.0.0" or addr == "127.0.0.1")
+            Rails.logger.warn "attempting to rate limit with a localhost address.  Ignoring."
+            return nil
+          else
+            key = addr
+          end
+        end
+      end
+
+      key
+    end
+
+    def get_message(opts)
+      message = opts[:message]
+      if message
+        if message.is_a? Proc
+          respond_to do |format|
+            message.call(self, opts[:wait_time])
+          end
+        elsif message.is_a? Symbol
+          self.send(message, opts[:wait_time])
+        elsif message.is_a? String
+          render_curbit_message(message, opts)
+        end
+      else
+        message = "Too many requests within the allowed time.  Please wait #{opts[:wait_time]} before submitting your request again."
+        render_curbit_message(message, opts)
+      end
+    end
+
+    def render_curbit_message(message, opts)
+      rendered = false
+      respond_to {|format|
+          format.html {
+            render :text => message, :status => opts[:status]
+            rendered = true
+          }
+          format.json {
+            render :json => %[{"error":"#{message}"}], :status => opts[:status]
+            rendered = true
+          }
+          format.xml {
+            render :xml => "<error>#{message}</error>", :status => opts[:status]
+            rendered = true
+          }
+      }
+      if (!rendered)
+        render :text => message, :status => opts[:status]
+      end
+    end
+
+  end
+end

data/test/custom_key_controller_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require 'test_rails_helper'
+
+class MethodController < ActionController::Base
+
+  include Curbit::Controller
+
+  def index
+    render :text => 'index action'
+  end
+
+  rate_limit :index, :key => :username,
+                     :max_calls => 2,
+                     :time_limit => 30.seconds,
+                     :wait_time => 1.minute
+
+  def show
+    render :text => 'show action'
+  end
+
+  rate_limit :show, :key => proc {|c| "my_key"},
+                    :max_calls => 2,
+                    :time_limit => 30.seconds,
+                    :wait_time => 1.minute
+
+  protected
+
+  def username
+    "codemariner"
+  end
+
+end
+
+
+class MethodControllerTest < ActionController::TestCase
+  tests MethodController
+
+  context "When calling a rate_limited method with a key argument that is a symbol it" do
+    setup {
+      Rails.cache = mock()
+      @env = {'HTTP_X_FORWARDED_FOR' => '192.168.1.123'}
+      @request.stubs(:env).returns(@env)
+      Rails.cache.stubs(:write)
+    }
+    should "call the specified method to use as part of the cache key" do
+      Rails.cache.expects(:read).with(Curbit::Controller::CacheKeyPrefix + "_#{MethodController.name}_index_codemariner").at_least_once
+      get :index
+      assert_equal "index action", @response.body
+    end
+  end
+
+  context "When calling a rate_limited method with a key argument that is a Proc it" do
+    setup {
+      Rails.cache = mock()
+      @env = {'HTTP_X_FORWARDED_FOR' => '192.168.1.123'}
+      @request.stubs(:env).returns(@env)
+      Rails.cache.stubs(:write)
+    }
+    should "call the Proc to use the returned value as part of the cache key" do
+      Rails.cache.expects(:read).with(Curbit::Controller::CacheKeyPrefix + "_#{MethodController.name}_show_my_key").at_least_once
+      get :show
+      assert_equal "show action", @response.body
+    end
+  end
+end
+

data/test/custom_message_format_controller.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+require 'test_rails_helper'
+
+class MessageController < ActionController::Base
+
+  include Curbit::Controller
+
+  attr_accessor :rendered
+
+  def index
+    render :text => 'index action'
+  end
+
+  rate_limit :index, :max_calls => 2,
+                     :time_limit => 30.seconds,
+                     :wait_time => 2.minute,
+                     :message => :limit_message
+
+  protected
+
+  def limit_message(wait_time)
+    respond_to {|format|
+      message = "Please wait #{wait_time/60} minutes before trying again"
+      format.html {
+        render :text => message, :status => 103
+      }
+      format.json {
+        render :json => %[{"error":"#{message}"}], :status => 503
+      }
+    }
+  end
+
+end
+
+
+class MessageControllerTest < ActionController::TestCase
+  tests MessageController
+
+  context "When calling a rate limited method using a message value of a" do
+    setup {
+      @env = {'HTTP_X_FORWARDED_FOR' => '192.168.1.123'}
+      @request.stubs(:env).returns(@env)
+      cache_value = {:started => Time.now.to_i - 15.seconds,
+                     :count => 2
+                     }
+      Rails.cache.stubs(:read).returns(cache_value)
+      Rails.cache.stubs(:write)
+    }
+    context "symbol" do
+      context "for a json request format, it" do
+        should "call a method named by the symbol with the specified wait_time" do
+          get :index, :format => "json"
+          assert_equal true, @response.body.include?("error") 
+          assert_equal "503 Service Unavailable", @response.status
+        end
+      end
+
+      context "and an html request format, it" do
+        should "call a method named by the symbol with the specified wait_time" do
+          get :index
+          assert_equal true, @response.body.include?("wait") 
+          assert_equal "103", @response.status
+        end
+      end
+    end
+
+  end
+end
+

data/test/standard_controller_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+require 'test_rails_helper'
+
+class TestController < ActionController::Base
+
+  include Curbit::Controller
+
+  def index
+    render :text => 'index action'
+  end
+
+  rate_limit :index, :max_calls => 2,
+                     :time_limit => 30.seconds,
+                     :wait_time => 1.minute
+
+  def show
+    render :text => 'show action'
+  end
+
+  rate_limit :show, :max_calls => 2,
+                    :time_limit => 30.seconds,
+                    :wait_time => 1.minute,
+                    :status => 200
+end
+
+
+class CurbiControllerTest < ActionController::TestCase
+  tests TestController
+
+  context "A controller including Curbit" do
+    should "have a rate_limit class method" do
+      assert_equal true, TestController.respond_to?(:rate_limit)
+    end
+  end
+
+  context "When declaring a rate_limit method, there " do
+      should "be a new rate_limit_method method added to the instance" do
+          assert_equal true, @controller.respond_to?(:rate_limit_index)
+      end
+  end
+
+  context "When calling a rate_limited method" do
+    setup {
+      Rails.cache = mock()
+    }
+
+    context "without a designated key argument" do
+      context "and the remote client address is forwarded from a proxy, it" do
+        setup {
+          @env = {'HTTP_X_FORWARDED_FOR' => '192.168.1.123'}
+          @request.stubs(:env).returns(@env)
+          @cache_key = nil
+          Rails.cache.expects(:write).with() {|key, val, duration|
+            @cache_key = key
+            true
+          }
+          Rails.cache.expects(:read).returns(nil)
+        }
+
+        should "use a default key that is derived from request.env['HTTP_X_FORWARDED_FOR']" do
+          get :index
+          ip = @env['HTTP_X_FORWARDED_FOR']
+          pfx = Curbit::Controller::CacheKeyPrefix
+          assert_equal "#{pfx}_#{TestController.name}_index_#{ip}", @cache_key
+        end
+      end #context: and the remote client address is...
+
+
+      context "and the remote client address is a localhost address, it" do
+        setup {
+          @request.stubs(:remote_addr).returns("0.0.0.0")
+          Rails.cache.expects(:read).never()
+        }
+        should "ignore rate limiting" do
+          get :index
+          assert_equal "index action", @response.body
+        end
+      end
+
+    end #context: without a designated key argument...
+
+    context "from a remote client" do
+      setup {
+        @env = {'HTTP_X_FORWARDED_FOR' => '192.168.1.123'}
+        @request.stubs(:env).returns(@env)
+      }
+      context "and max calls has been exceeded for the current time limit" do
+        setup {
+          cache_value = {:started => Time.now.to_i - 15.seconds,
+                         :count => 1
+                         }
+          Rails.cache.stubs(:read).returns(cache_value)
+          Rails.cache.stubs(:write)
+        }
+        context ", the call" do
+          should "be blocked" do
+            get :index
+            assert_equal "index action", @response.body
+            get :index
+            assert_equal true, @response.body.include?("wait")
+            # default status on a limit
+            assert_equal "503 Service Unavailable", @response.status
+          end
+
+          should "be blocked and render a custom status when specified" do
+            get :show
+            assert_equal "show action", @response.body
+            get :show
+            assert_equal true, @response.body.include?("wait")
+            # default status on a limit
+            assert_equal "200 OK", @response.status
+          end
+        end
+      end
+    end
+
+  end #context: when calling a rate limited method...
+
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'curbit'
+

data/test/test_rails_helper.rb

@@ -0,0 +1,29 @@
+# rails setup
+ENV["RAILS_ENV"] = "test"
+RAILS_ROOT = "wherever"
+
+require 'active_support'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'action_controller/test_process'
+
+
+class ApplicationController < ActionController::Base; end
+
+
+# add curbit to load path and init
+ActiveSupport::Dependencies.load_paths << File.expand_path(File.dirname(__FILE__) + '/../lib')
+require_dependency 'curbit'
+
+
+ActionController::Base.view_paths = File.join(File.dirname(__FILE__), 'views')
+ActionController::Routing::Routes.draw do |map|
+    map.connect ':controller/:action/:id'
+end
+
+require 'ostruct'
+
+# stub out a rails cache object
+Rails = OpenStruct.new
+
+Rails.logger = Logger.new("/dev/null")

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: curbit
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Scott Sayles
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-25 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Application level rate limiting for Rails
+email: ssayles@users.sourceforge.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+- lib/curbit.rb
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/curbit.rb
+- test/custom_key_controller_test.rb
+- test/custom_message_format_controller.rb
+- test/standard_controller_test.rb
+- test/test_helper.rb
+- test/test_rails_helper.rb
+- Manifest
+- curbit.gemspec
+has_rdoc: true
+homepage: http://github.com/ssayles/curbit
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Curbit
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: curbit
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Application level rate limiting for Rails
+test_files: 
+- test/custom_key_controller_test.rb
+- test/standard_controller_test.rb
+- test/test_helper.rb
+- test/test_rails_helper.rb