ball_gag 0.0.1 → 0.0.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ball_gag (0.0.1)
+    ball_gag (0.0.2)
 
 GEM
   remote: http://rubygems.org/

data/Readme.md

@@ -24,7 +24,7 @@ end
 Post.new('That was some damn good watermelon').body_gagged?
 # true
 
-Post.new('That was some fine watermelon.').body_gagged?
+Post.new('That was some fine watermelon').body_gagged?
 # false
 ````
 
@@ -40,12 +40,20 @@ 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 }
+  gag(:body) { |body| !/damn/.match body }
 
   validates :body, :not_gagged => true
 end
 ````
 
+````ruby
+Post.new(body: 'That was some damn good watermelon').valid?
+# false
+
+Post.new(body: 'That was some fine watermelon').valid?
+# true
+````
+
 ## 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.
 
@@ -102,10 +110,9 @@ class ModerationServiceEngine
       return call(options[:attr] => fields, options)
     end
 
-    gag_options = options[:options]
+    gag_options, instance = options.values_at(:options, :instance)
 
-    sender = gag_options[:sender].
-      bind(instance).call
+    sender = gag_options[:sender].bind(instance).call
 
     response = new(*MyApp::ApplicationConfig.moderation_service_credentials).
       get('/moderate', query: { fields: fields, user: sender })

data/lib/ball_gag.rb

@@ -2,6 +2,8 @@ require 'ball_gag/version'
 require 'ball_gag/gag'
 require 'ball_gag/engine'
 require 'ball_gag/errors'
+require 'ball_gag/cloak'
+require 'ball_gag/bowling_ball'
 
 begin
   require 'ball_gag/validations'

data/lib/ball_gag/bowling_ball.rb

@@ -0,0 +1,36 @@
+module BowlingBall
+  class << self
+    def included base
+      base.send(:include, BallGag)
+    end
+
+    def engine
+      BallGag.engine
+    end
+
+    def engine= engine
+      BallGag.engine = engine
+    end
+
+    def verb
+      BallGag.verb
+    end
+
+    def verb= verb
+      BallGag.verb= verb
+    end
+
+    def preterite
+      BallGag.preterite
+    end
+
+    def preterite= preterite
+      BallGag.preterite = preterite
+    end
+
+    def negative_preterite= preterite
+      BallGag.negative_preterite = preterite
+    end
+  end
+end
+

data/lib/ball_gag/cloak.rb

@@ -0,0 +1,74 @@
+module BallGag
+  module Cloak
+    def verb
+      @verb || 'gag'
+    end
+
+    def verb= verb
+      old_verb = @verb
+      @verb = verb
+
+      BallGag::ClassMethods.instance_eval do
+        if verb
+          define_method verb do |*args|
+            gag *args
+          end
+        elsif old_verb
+          remove_method old_verb
+        end
+      end
+    end
+
+    def preterite
+      @preterite || 'gagged'
+    end
+
+    def preterite= preterite
+      set_preterite preterite
+      @preterite_negative = false
+    end
+
+    def negative_preterite= preterite
+      set_preterite preterite
+      @preterite_negative = true
+    end
+
+    def preterite_negative?
+      @preterite_negative
+    end
+
+    private
+    def set_preterite preterite
+      undefine_old_preterite_validators @preterite
+      define_preterite_validators preterite
+      
+      @preterite = preterite
+    end
+
+    def define_preterite_validators preterite
+      return unless preterite
+
+      Kernel.const_set(validator_name(preterite), Class.new(GaggedValidator))
+      Kernel.const_set(not_validator_name(preterite), Class.new(NotGaggedValidator))
+    end
+
+    def undefine_old_preterite_validators preterite
+      return unless preterite
+
+      Kernel.send(:remove_const, validator_name(preterite))
+      Kernel.send(:remove_const, not_validator_name(preterite))
+    end
+
+    def validator_name preterite
+      "#{preterite.to_s.capitalize}Validator"
+    end
+
+    def not_validator_name preterite
+      "Not#{validator_name(preterite)}"
+    end
+
+  end
+
+  extend Cloak
+end
+

data/lib/ball_gag/gag.rb

@@ -64,19 +64,16 @@ module BallGag
       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
@@ -112,16 +109,23 @@ module BallGag
     end
 
     def gagged_attribute_interpellation_name attribute
-      "#{attribute}_gagged?"
+      gagged_attribute_preterite_interpellation_name(
+        attribute, !BallGag.preterite_negative?)
     end
 
     def gagged_attribute_negative_interpellation_name attribute
-      "#{attribute}_not_gagged?"
+      gagged_attribute_preterite_interpellation_name(
+        attribute, BallGag.preterite_negative?)
+    end
+
+    def gagged_attribute_preterite_interpellation_name attribute, negative
+      negative ?
+        "#{attribute}_#{BallGag.preterite}?" :
+        "#{attribute}_not_#{BallGag.preterite}?"
     end
 
     def undefine_gagged_attributes_methods
       @gagged_attributes.keys.each do |attribute|
-
         @gagged_attributes_methods.send(:remove_method,
           gagged_attribute_interpellation_name(attribute))
 

data/lib/ball_gag/validations.rb

@@ -1,8 +1,28 @@
-class NotGaggedValidator < ActiveModel::EachValidator
+class GaggedValidator < ActiveModel::EachValidator
   def validate_each object, attribute, value
-    if object.method("#{attribute}_gagged?").call
-      object.errors[attribute] << (options[:message] || 'is gagged')
+    unless object.method(condition_method_name(attribute)).call
+      object.errors[attribute] << (options[:message] || default_message)
     end
   end
+
+  private
+  def condition_method_name attribute
+    "#{attribute}_#{BallGag.preterite}?"
+  end
+
+  def default_message
+    "is not #{BallGag.preterite}"
+  end
+end
+
+class NotGaggedValidator < GaggedValidator
+  private
+  def condition_method_name attribute
+    "#{attribute}_not_#{BallGag.preterite}?"
+  end
+
+  def default_message
+    "is #{BallGag.preterite}"
+  end
 end
 

data/lib/ball_gag/version.rb

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

data/spec/bowling_ball_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe BowlingBall do
+  after { Kernel.send(:remove_const, :BowlingBallIncluder) }
+
+  context 'when included' do
+    it 'should include BallGag' do
+      class Kernel::BowlingBallIncluder
+        include BowlingBall
+      end
+
+      BowlingBallIncluder.included_modules.should include BallGag
+    end
+  end
+end
+

data/spec/cloak_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe 'BallGag cloaking' do
+  before do
+    ExampleModel.clear_gagged_attributes
+    ExampleActiveModel.reset_callbacks :validate
+    ExampleActiveModel.clear_gagged_attributes
+    BallGag.verb = nil
+    BallGag.preterite = nil
+  end
+
+  after do
+    ExampleModel.clear_gagged_attributes
+    ExampleActiveModel.clear_gagged_attributes
+    BallGag.verb = nil
+    BallGag.preterite = nil
+  end
+
+  it 'should have default verb' do
+    BallGag.verb.should eq 'gag'
+  end
+
+  it 'should accept new verb' do
+    BallGag.verb = 'censor'
+    BallGag.verb.should eq 'censor'
+  end
+
+  it 'should provide verb as class method' do
+    BallGag.verb = 'censor'
+    ExampleModel.should respond_to :censor
+  end
+
+  it 'should gag attribute when custom verb is used' do
+    BallGag.verb = 'censor'
+    ExampleModel.censor :words
+    ExampleModel.gagged_attributes.should include :words
+  end
+
+  it 'should remove custom verb method when verb is cleared' do
+    BallGag.verb = 'censor'
+    BallGag.verb = nil
+    ExampleModel.should_not respond_to :censor
+  end
+
+  it 'should have preterite' do
+    BallGag.preterite.should eq 'gagged'
+  end
+
+  it 'should accept new preterite' do
+    BallGag.preterite = 'censored'
+    BallGag.preterite.should eq 'censored'
+  end
+
+  it 'should define #{attribute}_#{preterite}? method on instance' do
+    BallGag.preterite = 'censored'
+    ExampleModel.gag :words
+    ExampleModel.new.should respond_to :words_censored?
+  end
+
+  it 'should define #{attribute}_not_#{preterite}? method on instance' do
+    BallGag.preterite = 'censored'
+    ExampleModel.gag :words
+    ExampleModel.new.should respond_to :words_not_censored?
+  end
+
+  it 'should have non-negative preterite' do
+    BallGag.preterite_negative?.should be_false
+  end
+
+  it 'should accept negative preterite' do
+    BallGag.negative_preterite = 'acceptable'
+    BallGag.preterite_negative?.should be_true
+  end
+
+  context 'when preterite is negative' do
+    it 'should invert meaning of #{attribute}_#{preterite}?' do
+      BallGag.negative_preterite = 'acceptable'
+      ExampleModel.gag(:words) { |words| true }
+      ExampleModel.new.words_acceptable?.should be_true
+    end
+
+    it 'should invert meaning of #{attribute}_not_#{preterite}?' do
+      BallGag.negative_preterite = 'acceptable'
+      ExampleModel.gag(:words) { |words| true }
+      ExampleModel.new.words_not_acceptable?.should be_false
+    end
+  end
+
+  describe 'validators' do
+    specify 'custom preterite should create validator' do
+      BallGag.preterite = 'censored'
+      ExampleActiveModel.gag(:words) { |words| true }
+      ExampleActiveModel.validates :words, censored: true
+      instance = ExampleActiveModel.new
+      instance.valid?
+      instance.errors[:words].should include 'is not censored'
+    end
+
+    specify 'custom preterite should create Not validator' do
+      BallGag.preterite = 'censored'
+      ExampleActiveModel.gag(:words) { |words| false }
+      ExampleActiveModel.validates :words, not_censored: true
+      instance = ExampleActiveModel.new
+      instance.valid?
+      instance.errors[:words].should include 'is censored'
+    end
+  end
+
+  describe BowlingBall do
+    it 'should set verb' do
+      BowlingBall.verb = 'censor'
+      BallGag.verb.should eq 'censor'
+    end
+
+    it 'should set preterite' do
+      BowlingBall.preterite = 'censored'
+      BallGag.preterite.should eq 'censored'
+    end
+
+    it 'should set negative preterite' do
+      BowlingBall.negative_preterite = 'acceptable'
+      BallGag.preterite.should eq 'acceptable'
+      BallGag.preterite_negative?.should be_true
+    end
+
+    it 'should set engine' do
+      mock_engine = mock('engine')
+      BowlingBall.engine = mock_engine
+      BallGag.engine.should eq mock_engine
+    end
+  end
+end
+

data/spec/gag_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 describe ExampleModel do
   before do
     BallGag.engine = nil
+    BallGag.verb = nil
+    BallGag.preterite = nil
     ExampleModel.clear_gagged_attributes
   end
 

data/spec/validations_spec.rb

@@ -3,31 +3,44 @@ require 'spec_helper'
 describe 'ActiveModel::Validations integration' do
   before do
     ExampleActiveModel.reset_callbacks :validate
+    ExampleActiveModel.clear_gagged_attributes
   end
 
-  it 'should call #{attribute}_gagged?' do
-    ExampleActiveModel.validates :words, not_gagged: true
+  describe NotGaggedValidator do
+    it 'should call #{attribute}_gagged?' do
+      ExampleActiveModel.validates :words, not_gagged: true
 
-    instance = ExampleActiveModel.new
-    instance.should_receive(:words_gagged?)
-    instance.valid?
-  end
+      instance = ExampleActiveModel.new
+      instance.should_receive(:words_not_gagged?)
+      instance.valid?
+    end
+
+    it 'should add default error message' do
+      ExampleActiveModel.validates :words, not_gagged: true
+      instance = ExampleActiveModel.new
+      instance.stub!(words_not_gagged?: false)
+      instance.valid?
+      instance.errors[:words].should include 'is gagged'
+    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'
+    it 'should respect custom error message' do
+      ExampleActiveModel.validates :words,
+        not_gagged: { message: 'is not acceptable' }
+      instance = ExampleActiveModel.new
+      instance.stub!(words_not_gagged?: false)
+      instance.valid?
+      instance.errors[:words].should include 'is not acceptable'
+    end
   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'
+  describe GaggedValidator do
+    it 'should add default error message' do
+      ExampleActiveModel.validates :words, gagged: true
+      instance = ExampleActiveModel.new
+      instance.stub!(words_gagged?: false)
+      instance.valid?
+      instance.errors[:words].should include 'is not gagged'
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ball_gag
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-07 00:00:00.000000000 Z
+date: 2011-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70285274103000 !ruby/object:Gem::Requirement
+  requirement: &70299098639740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70285274103000
+  version_requirements: *70299098639740
 description: Validate user input using pluggable back-ends
 email:
 - duncan@dweebd.com
@@ -38,11 +38,15 @@ files:
 - Readme.md
 - ball_gag.gemspec
 - lib/ball_gag.rb
+- lib/ball_gag/bowling_ball.rb
+- lib/ball_gag/cloak.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/bowling_ball_spec.rb
+- spec/cloak_spec.rb
 - spec/engine_spec.rb
 - spec/gag_spec.rb
 - spec/spec_helper.rb
@@ -73,6 +77,8 @@ signing_key:
 specification_version: 3
 summary: Pluggable User-Content Validation
 test_files:
+- spec/bowling_ball_spec.rb
+- spec/cloak_spec.rb
 - spec/engine_spec.rb
 - spec/gag_spec.rb
 - spec/spec_helper.rb