ball_gag 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.rvmrc
+

data/Gemfile

@@ -0,0 +1,18 @@
+source 'http://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rake', '>= 0.9.2'
+  gem 'rspec', '>=2.6.0'
+  gem 'spork', '~> 0.9.0.rc9'
+  gem 'guard'
+  gem 'rb-fsevent'
+  gem 'growl_notify'
+  gem 'guard-rspec'
+  gem 'guard-spork'
+  gem 'pry'
+  gem 'pry-remote'
+  gem 'activemodel'
+end
+

data/Gemfile.lock

@@ -0,0 +1,72 @@
+PATH
+  remote: .
+  specs:
+    ball_gag (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.1)
+      activesupport (= 3.1.1)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activesupport (3.1.1)
+      multi_json (~> 1.0)
+    builder (3.0.0)
+    coderay (0.9.8)
+    diff-lcs (1.1.3)
+    growl_notify (0.0.3)
+      rb-appscript
+    guard (0.8.4)
+      thor (~> 0.14.6)
+    guard-rspec (0.5.0)
+      guard (>= 0.8.4)
+    guard-spork (0.3.1)
+      guard (>= 0.8.4)
+      spork (>= 0.8.4)
+    i18n (0.6.0)
+    method_source (0.6.6)
+      ruby_parser (~> 2.0.5)
+    multi_json (1.0.3)
+    pry (0.9.6.2)
+      coderay (~> 0.9.8)
+      method_source (~> 0.6.5)
+      ruby_parser (~> 2.0.5)
+      slop (~> 2.1.0)
+    pry-remote (0.1.0)
+      pry (~> 0.9.6)
+      slop (~> 2.1)
+    rake (0.9.2)
+    rb-appscript (0.6.1)
+    rb-fsevent (0.4.3.1)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    ruby_parser (2.0.6)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.7)
+    slop (2.1.0)
+    spork (0.9.0.rc9)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel
+  ball_gag!
+  growl_notify
+  guard
+  guard-rspec
+  guard-spork
+  pry
+  pry-remote
+  rake (>= 0.9.2)
+  rb-fsevent
+  rspec (>= 2.6.0)
+  spork (~> 0.9.0.rc9)

data/Guardfile

@@ -0,0 +1,12 @@
+guard 'spork' do
+  watch('spec/spec_helper.rb')
+end
+
+guard 'rspec', version: 2, cli: '--drb --color --format nested', all_after_pass: false do
+  watch(/^spec\/.+_spec\.rb$/)
+  watch(/^lib\/ball_gag\/(.+)\.rb$/) { |m| "spec/#{m[1]}_spec.rb" }
+  watch(/^lib\/ball_gag\.rb$/)       { 'spec' }
+  watch('spec/spec_helper.rb')       { 'spec' }
+  watch(/spec\/support\/.+\.rb$/)    { 'spec' }
+end
+

data/License

@@ -0,0 +1,8 @@
+Copyright (c) 2011 Duncan Beevers - Dweebd LLC
+
+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/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new
+

data/Readme.md

@@ -0,0 +1,122 @@
+# BallGag Pluggable User-Content Validation
+
+Validate user-generated content against acceptable content rules.  BallGag provides a convenient interface for describing the acceptability of the attributes of Ruby objects.
+
+When an attribute is gagged, <tt>#{method}_gagged?</tt> and <tt>#{method}_not_gagged?</tt> methods are added to the class.
+
+## Example
+Here's a simple example demonstrating gagging of a single attribute.
+
+````ruby
+class Post
+  include BallGag
+  attr_accessor :body
+
+  gag(:body) { |body| !/damn/.match body }
+
+  def initialize body
+    self.body = body
+  end
+end
+````
+
+````ruby
+Post.new('That was some damn good watermelon').body_gagged?
+# true
+
+Post.new('That was some fine watermelon.').body_gagged?
+# false
+````
+
+## Using it with Rails
+BallGag integrates easily into your Rails app, allowing you validate that <tt>ActiveModel</tt> attributes are acceptable. First, add the gem to your <tt>Gemfile</tt>
+
+````ruby
+gem 'ball_gag'
+````
+
+Now a <tt>NotGaggedValidator</tt> is available which you can use like this.
+
+````ruby
+class Post < ActiveRecord::Base
+  include BallGag
+  gag :body { |body| !/damn/.match body }
+
+  validates :body, :not_gagged => true
+end
+````
+
+## Engines / Global configuration
+Each gagged attribute can be provided its own block to call when checking acceptability, or a global engine can be provided. Set a global engine like this.
+
+````ruby
+BallGag.engine = lambda { |content| !/damn/.match content }
+````
+
+Any object that responds to <tt>call</tt> can be used as an engine.
+
+## Signature
+
+The first argument to <tt>call</tt> is the value, or hash of values to be checked for acceptability.
+
+If a single attribute is gagged, the <tt>call</tt> method is invoked with the value of the attribute. If multiple attributes are gagged, the <tt>call</tt> method is invoked with a hash whose keys are the gagged attribute names and whose values are the attributes' values.
+
+The second argument to <tt>call</tt> is a hash of options. This hash has the following entries:
+<table>
+  <tbody>
+    <tr>
+      <td><tt><strong>:instance</strong></tt></td>
+      <td>The instance on which the attribute checked was invoked.</td>
+    </tr>
+    <tr>
+      <td><tt><strong>:options</strong></tt></td>
+      <td>The options supplied to the specific <tt>gag</tt> call.</td>
+    </tr>
+    <tr>
+      <td><tt><strong>:single</strong></tt></td>
+      <td>A boolean indicating whether the <tt>gag</tt> method was invoked with only one attribute.</td>
+    </tr>
+    <tr>
+      <td><tt><strong>:attr</strong></tt></td>
+      <td>The name of the attribute being checked. This is only useful for single-attribute gags.</td>
+    </tr>
+  </tbody>
+</table>
+
+Since options provided to the <tt>gag</tt> method are passed through to your back-end, you can use them when building up a request to send to a 3rd-party.
+
+## Integration with 3rd-party tools
+The real power of BallGag is in how it integrates with 3rd-party moderation services. BallGag helps you thread model-specific information through to a remote back-end.
+
+An advanced engine may need to handle accepability of single and multiple attributes. The handler can differentiate between the two types of calls by inspecting the <tt>:single</tt> key of the options it's called with.
+
+Here's an example engine that accepts single and multi-attribute calls and validates against a made-up RESTful moderation service.
+
+````ruby
+class ModerationServiceEngine
+  include HTTParty
+  base_uri MyApp::Application.config.moderation_service_uri
+
+  def self.call fields, options
+    if options.delete(:single)
+      return call(options[:attr] => fields, options)
+    end
+
+    gag_options = options[:options]
+
+    sender = gag_options[:sender].
+      bind(instance).call
+
+    response = new(*MyApp::ApplicationConfig.moderation_service_credentials).
+      get('/moderate', query: { fields: fields, user: sender })
+
+    response['fields']
+  end
+end
+
+BallGag.engine = ModerationServiceEngine
+````
+
+## License
+
+MIT License

data/ball_gag.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'ball_gag/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ball_gag'
+  s.version     = BallGag::VERSION
+  s.authors     = ['Duncan Beevers']
+  s.email       = ['duncan@dweebd.com']
+  s.homepage    = ''
+  s.summary     = 'Pluggable User-Content Validation'
+  s.description = 'Validate user input using pluggable back-ends'
+
+  s.rubyforge_project = 'ball_gag'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency 'rspec'
+end

data/lib/ball_gag.rb

@@ -0,0 +1,10 @@
+require 'ball_gag/version'
+require 'ball_gag/gag'
+require 'ball_gag/engine'
+require 'ball_gag/errors'
+
+begin
+  require 'ball_gag/validations'
+rescue NameError # No dice
+end
+

data/lib/ball_gag/engine.rb

@@ -0,0 +1,16 @@
+module BallGag
+  module Engine
+    module ClassMethods
+      def engine
+        @engine
+      end
+
+      def engine= new_engine
+        @engine = new_engine
+      end
+    end
+  end
+
+  extend Engine::ClassMethods
+end
+

data/lib/ball_gag/errors.rb

@@ -0,0 +1,8 @@
+module BallGag
+  class NoEngineConfiguredError < StandardError
+  end
+
+  class BadResultsMappingError < StandardError
+  end
+end
+

data/lib/ball_gag/gag.rb

@@ -0,0 +1,139 @@
+module BallGag
+  def self.included base
+    @gagged_inclusions ||= {}
+    if !@gagged_inclusions[base]
+      @gagged_inclusions[base] = true
+      base.extend ClassMethods
+    end
+  end
+
+  module ClassMethods
+    def gagged_attributes
+      clear_gagged_attributes unless @gagged_attributes
+      @gagged_attributes.keys
+    end
+
+    def gag *arguments, &block
+      define_and_mixin_gagged_attributes_methods
+
+      callable = arguments.pop if arguments.last.respond_to? :call
+      options = arguments.pop if arguments.last.kind_of? Hash
+
+      to_call = callable || block || BallGag.engine ||
+        lambda { |*| raise NoEngineConfiguredError }
+
+      define_not_gagged_interpellations(arguments, to_call, options)
+
+      arguments.each do |attribute|
+        @gagged_attributes[attribute] = to_call
+        define_gagged_interpellation attribute
+      end
+
+      arguments
+    end
+
+    def clear_gagged_attributes
+      undefine_gagged_attributes_methods
+    end
+
+    private
+    def define_and_mixin_gagged_attributes_methods
+      return if @gagged_attributes_methods
+
+      undefine_gagged_attributes_methods
+    end
+
+    def define_not_gagged_interpellations attributes, callable, gag_options = nil
+      one_attribute = 1 == attributes.length
+      unsanitized_values = lambda { |it|
+        attributes.inject({}) do |a, attribute|
+          a[attribute] = it.send(attribute)
+          a
+        end
+      }
+
+      output = one_attribute ?
+        lambda { |it, attr| unsanitized_values.call(it)[attr] } :
+        lambda { |it, attr| unsanitized_values.call(it) }
+
+      arity = callable.respond_to?(:arity) ?
+        callable.arity :
+        callable.method(:call).arity.abs
+
+      fn = nil
+      if 1 == arity
+        fn = lambda { |it, attr| callable.call(output.call(it, attr)) }
+      else
+        options = {}
+        fn = lambda do |it, attr|
+          callable.call(output.call(it, attr),
+            { options: gag_options,
+              instance: it,
+              attr: attr,
+              single: one_attribute
+            }
+          )
+          end
+      end
+
+
+      attributes.each do |attr|
+        @gagged_attributes_methods.send(:define_method,
+          gagged_attribute_negative_interpellation_name(attr)) do
+            @gagged_attribute_results ||= {}
+
+            # Have we performed this call already?
+            unless @gagged_attribute_results.has_key?(attributes)
+              @gagged_attribute_results[attributes] = fn.call(self, attr)
+            end
+
+            call_result = @gagged_attribute_results[attributes]
+
+            if one_attribute
+              # If only one attribute was supplied, a simple
+              # boolean response is sufficient
+              return false unless call_result
+              return true unless call_result.respond_to?(:[])
+            else
+              raise BadResultsMappingError unless call_result.respond_to?(:[])
+            end
+
+            @gagged_attribute_results[attributes][attr]
+          end
+      end
+    end
+
+    def define_gagged_interpellation attribute
+      neg_method = gagged_attribute_negative_interpellation_name(attribute)
+      @gagged_attributes_methods.send(:define_method,
+        gagged_attribute_interpellation_name(attribute)) do
+          !method(neg_method).call
+        end
+    end
+
+    def gagged_attribute_interpellation_name attribute
+      "#{attribute}_gagged?"
+    end
+
+    def gagged_attribute_negative_interpellation_name attribute
+      "#{attribute}_not_gagged?"
+    end
+
+    def undefine_gagged_attributes_methods
+      @gagged_attributes.keys.each do |attribute|
+
+        @gagged_attributes_methods.send(:remove_method,
+          gagged_attribute_interpellation_name(attribute))
+
+        @gagged_attributes_methods.send(:remove_method,
+          gagged_attribute_negative_interpellation_name(attribute))
+
+      end if @gagged_attributes
+
+      @gagged_attributes_methods = Module.new
+      include @gagged_attributes_methods
+      @gagged_attributes = {}
+    end
+  end
+end
+

data/lib/ball_gag/validations.rb

@@ -0,0 +1,8 @@
+class NotGaggedValidator < ActiveModel::EachValidator
+  def validate_each object, attribute, value
+    if object.method("#{attribute}_gagged?").call
+      object.errors[attribute] << (options[:message] || 'is gagged')
+    end
+  end
+end
+

data/lib/ball_gag/version.rb

@@ -0,0 +1,4 @@
+module BallGag
+  VERSION = '0.0.1'
+end
+

data/spec/engine_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe BallGag do
+  before { BallGag.engine = nil }
+
+  it 'should have no engine' do
+    BallGag.engine.should be_nil
+  end
+
+  it 'should have configurable engine' do
+    mock_engine = mock('engine')
+    BallGag.engine = mock_engine
+    BallGag.engine.should eq mock_engine
+  end
+
+  it 'should use engine' do
+    BallGag.engine = ExampleEngine
+    ExampleModel.gag :words, { strict: true }
+    ExampleModel.new.words_gagged?.should be_false
+  end
+end
+

data/spec/gag_spec.rb

@@ -0,0 +1,267 @@
+require 'spec_helper'
+
+describe ExampleModel do
+  before do
+    BallGag.engine = nil
+    ExampleModel.clear_gagged_attributes
+  end
+
+  describe '#gag' do
+    it 'should add #{attribute}_gagged? method' do
+      ExampleModel.gag :words
+      ExampleModel.new.should respond_to :words_gagged?
+    end
+
+    it 'should add #{attribute}_not_gagged? method' do
+      ExampleModel.gag :words
+      ExampleModel.new.should respond_to :words_not_gagged?
+    end
+  end
+
+  describe '#gagged_attributes' do
+    it 'should have no gagged attributes' do
+      ExampleModel.gagged_attributes.should be_empty
+    end
+
+    it 'should gag attribute' do
+      ExampleModel.gag :words
+      ExampleModel.gagged_attributes.should include :words
+    end
+
+    it 'should gag multiple attributes' do
+      ExampleModel.gag :words, :email
+      ExampleModel.gagged_attributes.should include :words
+      ExampleModel.gagged_attributes.should include :email
+    end
+  end
+
+  describe '#clear_gagged_attributes' do
+    it 'should clear gagged attributes' do
+      ExampleModel.gag :words
+      ExampleModel.clear_gagged_attributes
+      ExampleModel.gagged_attributes.should be_empty
+    end
+
+    it 'should remove #{attribute}_not_gagged? method' do
+      ExampleModel.gag :words
+      ExampleModel.new.should respond_to(:words_not_gagged?)
+      ExampleModel.clear_gagged_attributes
+      ExampleModel.new.should_not respond_to(:words_not_gagged?)
+    end
+
+    it 'should remove #{attribute}_gagged? method' do
+      ExampleModel.gag :words
+      ExampleModel.new.should respond_to(:words_gagged?)
+      ExampleModel.clear_gagged_attributes
+      ExampleModel.new.should_not respond_to(:words_gagged?)
+    end
+  end
+
+  describe 'single attribute gagged' do
+    describe 'return values' do
+      context 'when callable returns' do
+        context 'true' do
+          before do
+            ExampleModel.gag :words, lambda { |*| true }
+          end
+
+          it '#{attribute}_gagged? should be false' do
+            ExampleModel.new.words_gagged?.should be_false
+          end
+          it '#{attribute}_not_gagged? should be true' do
+            ExampleModel.new.words_not_gagged?.should be_true
+          end
+        end
+
+        context 'false' do
+          before do
+            ExampleModel.gag :words, lambda { |*| false }
+          end
+
+          it '#{attribute}_gagged? should be true' do
+            ExampleModel.new.words_gagged?.should be_true
+          end
+          it '#{attribute}_not_gagged? should be false' do
+            ExampleModel.new.words_not_gagged?.should be_false
+          end
+        end
+      end
+    end
+
+    specify 'callable is called with attribute value' do
+      callable = lambda { |words| }
+      ExampleModel.gag :words, callable
+
+      mock_words = mock('words')
+
+      callable.should_receive(:call).
+        with(mock_words)
+
+      instance = ExampleModel.new
+      instance.stub!(words: mock_words)
+
+      instance.words_gagged?
+    end
+
+    specify 'callable is called with single: true in options' do
+      callable = lambda { |words, options| }
+      ExampleModel.gag :words, callable
+      callable.should_receive(:call).
+        with(anything, hash_including(single: true))
+      ExampleModel.new.words_gagged?
+    end
+  end
+
+  describe 'multiple attributes gagged' do
+    describe 'return values' do
+      context 'when results map returns true for attribute' do
+        before { ExampleModel.gag :words, :email do |*| { words: true } end }
+
+        it 'should return false for #{attribute}_gagged?' do
+          ExampleModel.new.words_gagged?.should be_false
+        end
+
+        it 'should return true for #{attribute}_not_gagged?' do
+          ExampleModel.new.words_not_gagged?.should be_true
+        end
+      end
+    end
+
+    specify 'callable is called with map of attributes' do
+      callable = lambda { |map, options| }
+      mock_words = mock('words')
+      mock_email = mock('email')
+
+      ExampleModel.gag :words, :email, callable
+      callable.should_receive(:call).
+        with(
+          hash_including(words: mock_words, email: mock_email), anything).
+        and_return({})
+
+      instance = ExampleModel.new
+      instance.stub!(words: mock_words, email: mock_email)
+      instance.words_gagged?
+    end
+
+    specify 'callable is called with attr in options' do
+      callable = lambda { |map, options| }
+      ExampleModel.gag :words, :email, callable
+
+      callable.should_receive(:call).
+        with(anything, hash_including(attr: :words)).
+        and_return({})
+      ExampleModel.new.words_gagged?
+
+      callable.should_receive(:call).
+        with(anything, hash_including(attr: :email)).
+        and_return({})
+      ExampleModel.new.email_gagged?
+    end
+
+    specify 'callable is called with single: false in options' do
+      callable = lambda { |map, options| }
+      ExampleModel.gag :words, :email, callable
+      callable.should_receive(:call).
+        with(anything, hash_including(single: false)).
+        and_return({})
+      ExampleModel.new.words_gagged?
+    end
+  end
+
+  describe 'callable options' do
+    specify 'instance is in options' do
+      callable = lambda { |words, options| }
+      ExampleModel.gag :words, callable
+
+      instance = ExampleModel.new
+      callable.should_receive(:call).
+        with(anything, hash_including(instance: instance))
+
+      instance.words_gagged?
+    end
+
+    specify 'attr is in options' do
+      callable = lambda { |words, options| }
+      ExampleModel.gag :words, callable
+      callable.should_receive(:call).
+        with(anything, hash_including(attr: :words))
+
+      ExampleModel.new.words_gagged?
+    end
+
+    specify 'gag options are in options' do
+      callable = lambda { |words, options| }
+      mock_options = mock('options')
+      mock_options.stub(:kind_of?).
+        with(Hash).and_return(true)
+
+      ExampleModel.gag :words, mock_options, callable
+      callable.should_receive(:call).
+        with(anything, hash_including(options: mock_options))
+
+      ExampleModel.new.words_gagged?
+    end
+  end
+
+  describe 'callable result caching' do
+    it 'should cache the result of the callable' do
+      callable = lambda {}
+      ExampleModel.gag :words, callable
+
+      callable.should_receive(:call).once
+
+      instance = ExampleModel.new
+      2.times { instance.words_gagged? }
+    end
+
+    it 'should separate invocations and cache results' do
+      callable = lambda { |words, instance| }
+      mock_words = mock('words')
+      mock_email = mock('email')
+
+      ExampleModel.gag :words, callable
+      ExampleModel.gag :email, callable
+
+      instance = ExampleModel.new
+      instance.stub!(words: mock_words, email: mock_email)
+
+      callable.should_receive(:call).
+        with(mock_words, anything).
+        once
+
+      callable.should_receive(:call).
+        with(mock_email, anything).
+        once
+
+      2.times { instance.words_gagged? }
+      2.times { instance.email_gagged? }
+    end
+  end
+
+  describe 'error cases' do
+    context 'when gagged with no callable and no engine is configured' do
+      it 'should raise when gag is checekd' do
+        ExampleModel.gag :words
+
+        -> { ExampleModel.new.words_gagged? }.
+          should raise_error(BallGag::NoEngineConfiguredError)
+      end
+    end
+
+    context 'when multiple attributes are gagged' do
+      it 'should raise if callable returns non-map result' do
+        mock_result = mock('result')
+
+        mock_result.should_receive(:respond_to?).
+          with(:[]).and_return(false)
+
+        callable = lambda { |*| mock_result }
+        ExampleModel.gag :words, :email, callable
+
+        -> { ExampleModel.new.words_gagged? }.
+          should raise_error(BallGag::BadResultsMappingError)
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'spork'
+
+Spork.prefork do
+  require 'rspec'
+  require 'active_model'
+  require 'pry-remote'
+end
+
+Spork.each_run do
+  require 'ball_gag'
+  require File.join(File.dirname(__FILE__), 'support/models')
+end
+

data/spec/support/models.rb

@@ -0,0 +1,29 @@
+class ExampleModel
+  include BallGag
+
+  def words
+    'Never has one man rocked so many.'
+  end
+
+  def email
+    'theodore@example.com'
+  end
+end
+
+class ExampleActiveModel
+  include ActiveModel::Validations
+  include BallGag
+
+  def words
+    'Welcome to the place where all the creatures meet.'
+  end
+end
+
+class ExampleEngine
+  class << self
+    def call value, options = {}
+      true
+    end
+  end
+end
+

data/spec/validations_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'ActiveModel::Validations integration' do
+  before do
+    ExampleActiveModel.reset_callbacks :validate
+  end
+
+  it 'should call #{attribute}_gagged?' do
+    ExampleActiveModel.validates :words, not_gagged: true
+
+    instance = ExampleActiveModel.new
+    instance.should_receive(:words_gagged?)
+    instance.valid?
+  end
+
+  it 'should add default error message' do
+    ExampleActiveModel.validates :words, not_gagged: true
+    instance = ExampleActiveModel.new
+    instance.stub!(words_gagged?: true)
+    instance.valid?
+    instance.errors[:words].should include 'is gagged'
+  end
+
+  it 'should respect custom error message' do
+    ExampleActiveModel.validates :words,
+      not_gagged: { message: 'is not acceptable' }
+    instance = ExampleActiveModel.new
+    instance.stub!(words_gagged?: true)
+    instance.valid?
+    instance.errors[:words].should include 'is not acceptable'
+  end
+end
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: ball_gag
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Duncan Beevers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70285274103000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70285274103000
+description: Validate user input using pluggable back-ends
+email:
+- duncan@dweebd.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- License
+- Rakefile
+- Readme.md
+- ball_gag.gemspec
+- lib/ball_gag.rb
+- lib/ball_gag/engine.rb
+- lib/ball_gag/errors.rb
+- lib/ball_gag/gag.rb
+- lib/ball_gag/validations.rb
+- lib/ball_gag/version.rb
+- spec/engine_spec.rb
+- spec/gag_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/validations_spec.rb
+homepage: ''
+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: ball_gag
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Pluggable User-Content Validation
+test_files:
+- spec/engine_spec.rb
+- spec/gag_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/validations_spec.rb