allowed 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8e4af22af5347dd855c58679dcd9aed1720709ac
+  data.tar.gz: 97dec94a7a9d9cfa1476f232aa19fcd50548fc18
+SHA512:
+  metadata.gz: ab767b716ee8ce8d01565f2921e26726b6bec321d0ef4a875fad88c39a48bd43a010a0cb33b2c8df4c158114829b308c90d3f2e8e23b08aa91dd6f7ebdad0710
+  data.tar.gz: c3b654d80a5c00138b85e8d6a46f95b91a53fb92635ec416aab56c82945a5135ad43b31f7a2de29f275d795171d798535964f6089d0bbd73d304319343c84fb1

data/lib/allowed.rb

@@ -0,0 +1,9 @@
+require "active_record"
+require "active_support"
+
+require "allowed/limit"
+require "allowed/throttle"
+
+ActiveSupport.on_load(:active_record) do
+  include Allowed::Limit
+end

data/lib/allowed/limit.rb

@@ -0,0 +1,43 @@
+module Allowed
+  module Limit
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_throttles
+    end
+
+    module ClassMethods
+      def allow(limit, options = {}, &block)
+        if block_given?
+          options[:callback] = block
+        end
+
+        self._throttles ||= []
+        self._throttles  << Throttle.new(limit, options)
+
+        validate :validate_throttles, on: :create
+
+        after_rollback   :handle_throttles, on: :create
+        after_validation :handle_throttles, on: :create
+      end
+    end
+
+    def handle_throttles
+      @_throttle_failures.each do |throttle|
+        throttle.callback.call(self)
+      end
+    end
+    private :handle_throttles
+
+    def validate_throttles
+      throttles = self.class._throttles
+      throttles = throttles.reject { |throttle| throttle.valid?(self) }
+      throttles.each do |throttle|
+        errors.add(:base, throttle.message)
+      end
+
+      @_throttle_failures = throttles
+    end
+    private :validate_throttles
+  end
+end

data/lib/allowed/throttle.rb

@@ -0,0 +1,48 @@
+module Allowed
+  class Throttle
+    attr_reader :limit, :options
+
+    def initialize(limit, options = {})
+      @limit   = limit
+      @options = options
+    end
+
+    def callback
+      options.fetch(:callback, -> (record) { })
+    end
+
+    def message
+      options.fetch(:message, "Limit reached.")
+    end
+
+    def valid?(record)
+      return true if skip?(record)
+
+      scope_for(record).count < limit
+    end
+
+    private
+
+    def scope_for(record)
+      scope      = record.class.where("created_at >= ?", timeframe)
+      attributes = Array(options.fetch(:scope, []))
+      attributes.inject(scope) do |scope, attribute|
+        scope.where(attribute => record.__send__(attribute))
+      end
+    end
+
+    def skip?(record)
+      return unless method = options[:unless]
+
+      if method.is_a?(Symbol)
+        method = record.method(method).call
+      else
+        method.call(record)
+      end
+    end
+
+    def timeframe
+      options.fetch(:per, 1.day).ago
+    end
+  end
+end

data/spec/lib/allowed/limit_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Allowed::Limit do
+  subject { ExampleRecord }
+
+  it "defines a class variable for throttles" do
+    expect(subject).to respond_to(:_throttles)
+  end
+end
+
+describe Allowed::Limit, "#allow" do
+  subject { ExampleRecord }
+
+  let(:limit)   { 100 }
+  let(:block)   { -> { } }
+  let(:options) { { message: "Over limit." } }
+
+  it "adds throttle to the record" do
+    subject.allow(limit, options)
+
+    expect(subject).to have_throttle(limit, options)
+  end
+
+  it "assigns block to callback" do
+    subject.allow(limit, options, &block)
+
+    expect(subject).to have_throttle(limit, options.merge(callback: block))
+  end
+
+  it "adds validation callback" do
+    subject.allow(limit, options)
+
+    expect(subject).to have_callback(:validate, :validate_throttles, on: :create)
+  end
+
+  it "adds after rollback callback" do
+    subject.allow(limit, options)
+
+    expect(subject).to have_callback(:rollback, :handle_throttles, kind: :after, on: :create)
+  end
+
+  it "adds after validation callback" do
+    subject.allow(limit, options)
+
+    expect(subject).to have_callback(:validation, :handle_throttles, kind: :after, on: :create)
+  end
+end
+
+describe Allowed::Limit, "#handle_throttles" do
+  subject { ExampleRecord.new }
+
+  let(:callback)         { mock(call: true) }
+  let(:invalid_throttle) { mock(callback: callback) }
+
+  before do
+    subject.instance_variable_set("@_throttle_failures", [invalid_throttle])
+  end
+
+  it "calls callback for throttle failures" do
+    subject.__send__(:handle_throttles)
+
+    expect(callback).to have_received(:call).with(subject).once
+  end
+end
+
+describe Allowed::Limit, "#validate_throttles" do
+  subject { ExampleRecord.new }
+
+  let(:message)          { "Over limit." }
+  let(:valid_throttle)   { mock(valid?: true) }
+  let(:invalid_throttle) { mock(valid?: false, message: message) }
+
+  before do
+    subject.class._throttles = [valid_throttle, invalid_throttle]
+  end
+
+  it "adds error messages to base" do
+    subject.__send__(:validate_throttles)
+
+    expect(subject.errors[:base].size).to eq(1)
+    expect(subject.errors[:base]).to include(message)
+  end
+
+  it "stores throttle failures" do
+    subject.__send__(:validate_throttles)
+
+    expect(subject.instance_variable_get("@_throttle_failures")).to eq([invalid_throttle])
+  end
+end

data/spec/lib/allowed/throttle_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+describe Allowed::Throttle, ".new" do
+  subject { Allowed::Throttle.new(limit, options) }
+
+  let(:limit)   { 100 }
+  let(:options) { { message: "Over limit." } }
+
+  it "sets limit" do
+    expect(subject.limit).to eq(limit)
+  end
+
+  it "sets options" do
+    expect(subject.options).to eq(options)
+  end
+end
+
+describe Allowed::Throttle, "#message" do
+  it "returns message if provided" do
+    message  = "The message."
+    throttle = Allowed::Throttle.new(1, message: message)
+
+    expect(throttle.message).to eq(message)
+  end
+
+  it "returns default message if not provided" do
+    throttle = Allowed::Throttle.new(1)
+
+    expect(throttle.message).to eq("Limit reached.")
+  end
+end
+
+describe Allowed::Throttle, "#valid?, with an unless block" do
+  let(:record) { ExampleRecord.new }
+
+  before do
+    2.times { ExampleRecord.create }
+  end
+
+  it "returns true when skipped" do
+    throttle = Allowed::Throttle.new(1, unless: -> (record) { true })
+
+    expect(throttle).to be_valid(record)
+  end
+
+  it "returns false when not skipped" do
+    throttle = Allowed::Throttle.new(1)
+
+    expect(throttle).to_not be_valid(record)
+  end
+end
+
+describe Allowed::Throttle, "#valid?, with an unless method symbol" do
+  let(:record) { ExampleRecord.new }
+
+  before do
+    2.times { ExampleRecord.create }
+  end
+
+  it "returns true when skipped" do
+    ExampleRecord.class_eval do
+      def custom_method
+        true
+      end
+    end
+
+    throttle = Allowed::Throttle.new(1, unless: :custom_method)
+
+    expect(throttle).to be_valid(record)
+  end
+
+  it "returns false when not skipped" do
+    ExampleRecord.class_eval do
+      def custom_method
+        false
+      end
+    end
+
+    throttle = Allowed::Throttle.new(1, unless: :custom_method)
+
+    expect(throttle).to_not be_valid(record)
+  end
+end
+
+describe Allowed::Throttle, "#valid?, within limit" do
+  subject { Allowed::Throttle.new(1) }
+
+  it "returns true" do
+    expect(subject).to be_valid(ExampleRecord.new)
+  end
+end
+
+describe Allowed::Throttle, "#valid?, above limit" do
+  subject { Allowed::Throttle.new(1) }
+
+  before do
+    2.times { ExampleRecord.create }
+  end
+
+  it "returns false" do
+    expect(subject).to_not be_valid(ExampleRecord.new)
+  end
+end
+
+describe Allowed::Throttle, "#valid?, with custom timeframe" do
+  subject { Allowed::Throttle.new(1, per: 5.minutes) }
+
+  before do
+    2.times { ExampleRecord.create(created_at: 6.minutes.ago) }
+  end
+
+  it "uses timeframe for count" do
+    expect(subject).to be_valid(ExampleRecord.new)
+  end
+end
+
+describe Allowed::Throttle, "#valid?, with custom scope attributes" do
+  subject { Allowed::Throttle.new(1, scope: :user_id) }
+
+  before do
+    ExampleRecord.create(user_id: 2)
+    ExampleRecord.create(user_id: 2)
+  end
+
+  it "uses scope attributes for count" do
+    expect(subject).to be_valid(ExampleRecord.new(user_id: 1))
+    expect(subject).to_not be_valid(ExampleRecord.new(user_id: 2))
+  end
+end

data/spec/lib/allowed_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe Allowed do
+  it "includes Limit in ActiveRecord::Base" do
+    expect(ActiveRecord::Base.ancestors).to include(Allowed::Limit)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require "bundler/setup"
+
+Bundler.require(:default, :development)
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  # Use mocha as the mocking framework.
+  config.mock_with :mocha
+
+  # Enforce expect syntax.
+  config.expect_with :rspec do |rspec|
+    rspec.syntax = :expect
+  end
+end

data/spec/support/active_record.rb

@@ -0,0 +1,28 @@
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: "spec/test.db")
+
+class ExampleRecord < ActiveRecord::Base
+end
+
+RSpec.configure do |config|
+  config.around do |example|
+    ExampleRecord._throttles = []
+
+    ActiveRecord::Base.transaction do
+      ActiveRecord::Migration.verbose = false
+      ActiveRecord::Migration.create_table(:example_records) do |table|
+        table.integer :user_id
+        table.timestamps
+      end
+
+      example.run
+
+      raise ActiveRecord::Rollback
+    end
+  end
+
+  config.after(:suite) do
+    ActiveRecord::Base.connection.instance_variable_get("@config").tap do |configuration|
+      File.delete(configuration[:database])
+    end
+  end
+end

data/spec/support/have_callback.rb

@@ -0,0 +1,10 @@
+RSpec::Matchers.define :have_callback do |type, name, options|
+  match do |record|
+    callbacks = record.__send__(:"_#{type}_callbacks")
+    callbacks.any? do |callback|
+      callback.raw_filter == name &&
+        (options[:kind].nil? || callback.kind == options[:kind]) &&
+        (options[:on].nil? || callback.options[:on] == options[:on])
+    end
+  end
+end

data/spec/support/have_throttle.rb

@@ -0,0 +1,7 @@
+RSpec::Matchers.define :have_throttle do |limit, options|
+  match do |record|
+    record._throttles.any? do |throttle|
+      throttle.limit == limit && throttle.options == options
+    end
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: allowed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tristan Dunn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+- !ruby/object:Gem::Dependency
+  name: bourne
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Throttling of ActiveRecord model creations.
+email: support@dribbble.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/allowed.rb
+- lib/allowed/limit.rb
+- lib/allowed/throttle.rb
+- spec/lib/allowed/limit_spec.rb
+- spec/lib/allowed/throttle_spec.rb
+- spec/lib/allowed_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/have_callback.rb
+- spec/support/have_throttle.rb
+homepage: https://github.com/dribbble/allowed
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Throttling of ActiveRecord model creations.
+test_files:
+- spec/lib/allowed/limit_spec.rb
+- spec/lib/allowed/throttle_spec.rb
+- spec/lib/allowed_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/have_callback.rb
+- spec/support/have_throttle.rb