bellmyer-validates_blacklist 0.1.1

data/README

@@ -0,0 +1,148 @@
+validates_blacklist
+===================
+
+The ridiculously paranoid don't want anything getting past them.  Wouldn't you
+feel the same if everyone was out to get you?  How do you know they're not?
+
+When it comes to validations, paranoia is pricey.  You need a tool to simplify
+the process. Time is of the essence, and those aluminum foil hats aren't going to
+fashion themselves.
+
+In all seriousness, validations are great for general rules that describe what type
+of data is or isn't acceptable.  What they're not good for is muddying up your
+model with lists, possibly large lists, of specifically blacklisted data.
+
+You may not want chunkeymonkey47@aol.com joining your online forum because you know
+they're just going to spam your users with viagra ads.  Maybe there are dozens of
+chunkymonkeys out there, as it were, and that sort of config data is just
+hideous in your model, if you care anything about beautiful code.  I say one
+chunkymonkey is too much.
+
+
+What can be done?
+=================
+
+What if we create a list *outside* the model, that can be validated against? What 
+if we gave each model its own blacklist file in the config folder so you knew 
+exactly where to find them?  Maybe a yaml file would make it easy to blacklist at
+the attribute level. And what if I wrote a nify little mixin for you, so calling
+"validates_blacklist" inside a model would automatically read this list and handle
+the validation for you?
+
+Well, I'd be a swell guy.  And as it turns out, I kind of am.
+
+
+Installation
+============
+
+Stick this little line in your environment.rb:
+
+  config.gem 'bellmyer-validates_blacklist', :lib => 'validates_blacklist', :source => 'http://gems.github.com'
+
+Then, for fun, run these two rake tasks:
+
+  rake gems:install
+  rake gems:unpack
+  
+
+Usage
+=====
+
+Run this command to create blacklist files for all your models in the config/blacklists/ folder:
+
+  script/generate blacklists
+  
+Don't worry, it won't overwrite your existing blacklist files, only create the ones
+you're missing. This means you can run it after every new model is added, no worries.
+
+Now, call this in your models:
+
+  validates_blacklist
+  
+And populate the yaml files using the example below to guide you. Have fun!
+
+
+Example
+=======
+
+As an example, we'll imagine a high school girl named Heather. Although she has
+mad Ruby skillz (perhaps BECAUSE) she's a snob.  All her potential friends must 
+submit applications for friendship via her Rails website. She uses 
+validates_blacklist to weed out the "undesireables".
+
+# config/blacklists/user_blacklist.yml
+    email:
+     - greasy_pete@yahoo.com # We kissed once when we were 5. Get over it already.
+     - /@aol.com$/           # Like, yeah right, AOL is for losers!
+
+    age:
+     - <14    # Junior high?  Need not apply.
+     - >25    # Gross, you perv!
+
+    parents_salary:
+     - 50_000..150_000    # Poor kids are gullible. Rich kids have money. Middle class is so passe.
+
+# app/models/user.rb
+    class User < ActiveRecord::Base
+      validates_blacklist
+    end
+
+
+Explanation
+===========
+
+Basically, under each attribute (email, age, parents_salary, etc) you can list 
+as many blacklisted values as you like. They can be a simple strings:
+
+    greasy_pete@aol.com
+    
+or regular expressions, if you wrap them in forward slashes:
+
+    /aol.com$/
+    
+or numbers (not very exciting):
+
+    5
+
+or ranges of numbers:
+
+    5..15
+    
+or any other conditionals you can think of:
+
+    != 'sadness'
+    =~ /happiness/
+    !~ /sad/
+    > 12
+    < 99
+    
+The only limits are your imagination, and my forethought.  You can even specify
+the error message that is generated:
+
+  email:
+   - [greasy_pete@aol.com, cannot be greasy pete from biology]
+  
+  age:
+   - [>25, cannot be a pervert]
+   
+  parents_salary
+   - [50_000..150_000, cannot be middle class]
+  
+Otherwise, the user will receive a generic message like:
+
+  Email is not allowed
+  
+Of course, you can change that for an entire model with the mixin call:
+
+  validates_blacklist :message => 'is not valid'
+  
+or per attribute:
+
+  validates_blacklist :message => "is not valid',
+    :attributes => { :email => 'has been banned', :age => 'is not allowed' }
+
+For the record, I think even a 21 year old hitting on high school girls is a
+pervert, but I'm trying to approach this thing from Heather's point of view.
+
+
+Copyright (c) 2009 Jaime Bellmyer, released under the MIT license

data/lib/active_record/validates/blacklist.rb

@@ -0,0 +1,27 @@
+module ActiveRecord
+  module Validates #:nodoc:
+    module Blacklist #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        validates_blacklist(options = {})
+          options.reverse_merge!(:message => 'is not allowed')
+          
+          include ActiveRecord::Validates::Blacklist::InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+        def blacklist(attribute, value, message = nil)
+          puts "blacklisted!"
+        end
+        
+        def unblacklist(attribute, value)
+          puts "unblacklisted!"
+        end
+      end 
+    end
+  end
+end

data/lib/bellmyer-validates_blacklist.rb

@@ -0,0 +1,2 @@
+require 'active_record/validates/blacklist'
+ActiveRecord::Base.class_eval { include ActiveRecord::Validates::Blacklist }

data/test/blacklist_test.rb

@@ -0,0 +1,332 @@
+require 'test/unit'
+
+require 'rubygems'
+gem 'activerecord', '>= 1.15.4.7794'
+require 'active_record'
+
+require "#{File.dirname(__FILE__)}/../init"
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :mixins do |t|
+      t.column :pos, :integer
+      t.column :parent_id, :integer
+      t.column :created_at, :datetime      
+      t.column :updated_at, :datetime
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class Mixin < ActiveRecord::Base
+end
+
+class ListMixin < Mixin
+  acts_as_list :column => "pos", :scope => :parent
+
+  def self.table_name() "mixins" end
+end
+
+class ListMixinSub1 < ListMixin
+end
+
+class ListMixinSub2 < ListMixin
+end
+
+class ListWithStringScopeMixin < ActiveRecord::Base
+  acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'
+
+  def self.table_name() "mixins" end
+end
+
+
+class ListTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_reordering
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).move_lower
+    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).move_higher
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    ListMixin.find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    ListMixin.find(1).move_to_top
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    ListMixin.find(4).move_to_top
+    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+    ListMixin.find(3).move_to_bottom
+    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  end
+
+  def test_next_prev
+    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
+    assert_nil ListMixin.find(1).higher_item
+    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
+    assert_nil ListMixin.find(4).lower_item
+  end
+
+  def test_injection
+    item = ListMixin.new(:parent_id => 1)
+    assert_equal "parent_id = 1", item.scope_condition
+    assert_equal "pos", item.position_column
+  end
+
+  def test_insert
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 2, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 3, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListMixin.create(:parent_id => 0)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_insert_at
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 1, new.pos
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 2, new.pos
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 3, new.pos
+
+    new4 = ListMixin.create(:parent_id => 20)
+    assert_equal 4, new4.pos
+
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+
+    new.reload
+    assert_equal 4, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+
+    new5 = ListMixin.create(:parent_id => 20)
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).destroy
+
+    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    assert_equal 1, ListMixin.find(1).pos
+    assert_equal 2, ListMixin.find(3).pos
+    assert_equal 3, ListMixin.find(4).pos
+
+    ListMixin.find(1).destroy
+
+    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+
+    assert_equal 1, ListMixin.find(3).pos
+    assert_equal 2, ListMixin.find(4).pos
+  end
+
+  def test_with_string_based_scope
+    new = ListWithStringScopeMixin.create(:parent_id => 500)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_nil_scope
+    new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
+    new2.move_higher
+    assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')
+  end
+  
+  
+  def test_remove_from_list_should_then_fail_in_list? 
+    assert_equal true, ListMixin.find(1).in_list?
+    ListMixin.find(1).remove_from_list
+    assert_equal false, ListMixin.find(1).in_list?
+  end 
+  
+  def test_remove_from_list_should_set_position_to_nil 
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  
+    ListMixin.find(2).remove_from_list 
+  
+    assert_equal [2, 1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  
+    assert_equal 1,   ListMixin.find(1).pos
+    assert_equal nil, ListMixin.find(2).pos
+    assert_equal 2,   ListMixin.find(3).pos
+    assert_equal 3,   ListMixin.find(4).pos
+  end 
+  
+  def test_remove_before_destroy_does_not_shift_lower_items_twice 
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  
+    ListMixin.find(2).remove_from_list 
+    ListMixin.find(2).destroy 
+  
+    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)
+  
+    assert_equal 1, ListMixin.find(1).pos
+    assert_equal 2, ListMixin.find(3).pos
+    assert_equal 3, ListMixin.find(4).pos
+  end 
+  
+end
+
+class ListSubTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    (1..4).each { |i| ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).create! :pos => i, :parent_id => 5000 }
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_reordering
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).move_lower
+    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).move_higher
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    ListMixin.find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    ListMixin.find(1).move_to_top
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    ListMixin.find(4).move_to_top
+    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+    ListMixin.find(3).move_to_bottom
+    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+  end
+
+  def test_next_prev
+    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
+    assert_nil ListMixin.find(1).higher_item
+    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
+    assert_nil ListMixin.find(4).lower_item
+  end
+
+  def test_injection
+    item = ListMixin.new("parent_id"=>1)
+    assert_equal "parent_id = 1", item.scope_condition
+    assert_equal "pos", item.position_column
+  end
+
+  def test_insert_at
+    new = ListMixin.create("parent_id" => 20)
+    assert_equal 1, new.pos
+
+    new = ListMixinSub1.create("parent_id" => 20)
+    assert_equal 2, new.pos
+
+    new = ListMixinSub2.create("parent_id" => 20)
+    assert_equal 3, new.pos
+
+    new4 = ListMixin.create("parent_id" => 20)
+    assert_equal 4, new4.pos
+
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+
+    new.reload
+    assert_equal 4, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+
+    new5 = ListMixinSub1.create("parent_id" => 20)
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    ListMixin.find(2).destroy
+
+    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    assert_equal 1, ListMixin.find(1).pos
+    assert_equal 2, ListMixin.find(3).pos
+    assert_equal 3, ListMixin.find(4).pos
+
+    ListMixin.find(1).destroy
+
+    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)
+
+    assert_equal 1, ListMixin.find(3).pos
+    assert_equal 2, ListMixin.find(4).pos
+  end
+
+end

data/validates_blacklist.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name = 'validates_blacklist'
+  s.version = '0.1.1'
+  s.date = '2009-08-26'
+  
+  s.summary = "Allows models to be validated against yaml-based blacklists"
+  s.description = ""
+  
+  s.authors = ['Jaime Bellmyer']
+  s.email = 'ruby@bellmyer.com'
+  s.homepage = 'http://github.com/bellmyer/validates_blacklist'
+  
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+
+  s.add_dependency 'rails', ['>= 2.1']
+  
+   s.files = [
+    "README",
+    "validates_blacklist.gemspec",
+    "lib/bellmyer-validates_blacklist.rb",
+    "lib/active_record/validates/blacklist.rb",
+  ]
+  
+  s.test_files = ["test/blacklist_test.rb"]
+
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: bellmyer-validates_blacklist
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jaime Bellmyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-26 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.1"
+    version: 
+description: ""
+email: ruby@bellmyer.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- validates_blacklist.gemspec
+- lib/bellmyer-validates_blacklist.rb
+- lib/active_record/validates/blacklist.rb
+has_rdoc: true
+homepage: http://github.com/bellmyer/validates_blacklist
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Allows models to be validated against yaml-based blacklists
+test_files: 
+- test/blacklist_test.rb