splam 0.1.0

data.tar.gz.sig

@@ -0,0 +1,2 @@
+;��'��b��3���L���ݯ����36Uw%p�!~�4R.b>^ƶ`�� #��]�dV�,)m>��qGu�Z$Z��񦚼D��Q���Е�SK��_����~N��w5xM/��%m��ϳrP�\����UQ���׊e��S1]���-��:���;p'��jc�<L9�~�8꿘Q��#Ι��z�.�%���h�~
b��B�q`uҝ��M������j�i�Vj
+�N�$��X\�ɺ�

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+gemspec
+
+gem 'bump'
+gem 'rake'
+gem 'activesupport'

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    splam (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    bump (0.3.9)
+    i18n (0.6.1)
+    multi_json (1.6.0)
+    rake (10.0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bump
+  rake
+  splam!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+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/README

@@ -0,0 +1,53 @@
+Splam
+=====
+
+Splam is a simple spam scoring plugin.  It contains a set of rules that are run on a field
+to help you determine the likelihood of that field being spam.  It doesn't do anything
+other than give a field a score.  It's up to you to act on that score.
+
+Check out the tests for instructions on how to use: you'll want to integrate this into
+your application's workflow.
+
+It's heavily biased towards the spam I've been seeing in the past two or three hours.
+This includes lots of crap with
+- bbcode [url=
+- lots of links (http://)
+- russian text
+- links to russian or chinese websites
+
+You can write your own plugins to Splam: simply subclass Splam::Rule. Splam is clever enough
+to iterate over all Rule's subclasses and run the 'run' method on the field to be checked.
+The other way to do this would be to define Rule.add_rule do ... end but I think the class
+form is easier for rubyists to understand and modify.
+
+Splam aggregates the scores from all the rules.  From the brief testing I've done, anything over
+about 40 is likely to be spam.  Real spam will blow out of the scoring stratosphere with over 1,000.
+
+Recommended serving directions:
+
+    class Comment
+      include Splam
+      
+      splammable :body
+    end
+    
+    comment = Comment.new :body => "This is spam!!!1"
+    comment.splam? # => false
+    comment.splam_score # => 2
+    comment.splam_reasons # => []
+
+Add this to a model, check the score, and determine (based on other factors such as logged-in
+user, time spent on the page, validity of request headers, length of user's membership on the 
+site) whether to ban the post or not. 
+
+We recommend showing the post to the user (spambox them in) but hide it from everyone else.
+
+TODO
+
+- Integrate bayesian or other clever algorithm, so that scores aren't hardcoded.
+- Switch to using a percentage (0.994) rather than a score (250)
+- Write more plugins!
+- Test against a larger Ham corpus
+- Fix that nasty autoloading code in splam.rb
+
+Copyright (c) 2008 ENTP, released under the MIT license

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'bump/tasks'
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the splam gem.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/gem-public_cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDMjCCAhqgAwIBAgIBADANBgkqhkiG9w0BAQUFADA/MRAwDgYDVQQDDAdtaWNo
+YWVsMRcwFQYKCZImiZPyLGQBGRYHZ3Jvc3NlcjESMBAGCgmSJomT8ixkARkWAml0
+MB4XDTEzMDIwMzE4MTMxMVoXDTE0MDIwMzE4MTMxMVowPzEQMA4GA1UEAwwHbWlj
+aGFlbDEXMBUGCgmSJomT8ixkARkWB2dyb3NzZXIxEjAQBgoJkiaJk/IsZAEZFgJp
+dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMorXo/hgbUq97+kII9H
+MsQcLdC/7wQ1ZP2OshVHPkeP0qH8MBHGg6eYisOX2ubNagF9YTCZWnhrdKrwpLOO
+cPLaZbjUjljJ3cQR3B8Yn1veV5IhG86QseTBjymzJWsLpqJ1UZGpfB9tXcsFtuxO
+6vHvcIHdzvc/OUkICttLbH+1qb6rsHUceqh+JrH4GrsJ5H4hAfIdyS2XMK7YRKbh
+h+IBu6dFWJJByzFsYmV1PDXln3UBmgAt65cmCu4qPfThioCGDzbSJrGDGLmw/pFX
+FPpVCm1zgYSb1v6Qnf3cgXa2f2wYGm17+zAVyIDpwryFru9yF/jJxE38z/DRsd9R
+/88CAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUsiNnXHtKeMYYcr4yJVmQ
+WONL+IwwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQAlyN7kKo/NQCQ0
+AOzZLZ3WAePvStkCFIJ53tsv5Kyo4pMAllv+BgPzzBt7qi605mFSL6zBd9uLou+W
+Co3s48p1dy7CjjAfVQdmVNHF3MwXtfC2OEyvSQPi4xKR8iba8wa3xp9LVo1PuLpw
+/6DsrChWw74HfsJN6qJOK684hJeT8lBYAUfiC3wD0owoPSg+XtyAAddisR+KV5Y1
+NmVHuLtQcNTZy+gRht3ahJRMuC6QyLmkTsf+6MaenwAMkAgHdswGsJztOnNnBa3F
+y0kCSWmK6D+x/SbfS6r7Ke07MRqziJdB9GuE1+0cIRuFh8EQ+LN6HXCKM5pon/GU
+ycwMXfl0
+-----END CERTIFICATE-----

data/lib/splam.rb

@@ -0,0 +1,124 @@
+# Splam
+#require File.dirname(__FILE__) + "/splam/rule"
+#require File.dirname(__FILE__) + "/splam/rules"
+#require File.dirname(__FILE__) + "/splam/rules/russian"
+
+require 'rubygems'
+gem 'activesupport'
+require 'active_support/inflector'
+
+module Splam
+  class Suite < Struct.new(:body, :rules, :threshold, :conditions)
+    # Should be a Rack::Request, in case you want to inspect user agents and whatnot
+    # unimplemented, cry about it fanboy!
+    attr_accessor :request
+
+    attr_reader :score
+    attr_reader :reasons
+
+    def initialize(body, rules, threshold, conditions, &block)
+      super(body, rules, threshold, conditions)
+      block.call(self) if block
+      self.rules = self.rules.inject({}) do |memo, (rule, weight)|
+        if (rule.is_a?(Class) && rule.superclass == Splam::Rule) || rule = Splam::Rule.rules[rule]
+          memo[rule] = weight || 1.0
+        else
+          raise ArgumentError, "Invalid rule: #{rule.inspect}"
+        end
+        memo
+      end
+    end
+
+    def run(record)
+      score, reasons = 0, []
+      rules.each do |rule_class, weight|
+        weight ||= 1
+        worker   = rule_class.run(self, record, weight)
+        score   += worker.score
+        reasons << worker.reasons
+      end
+      [score, reasons]
+    end
+
+    def splam?(score)
+      score >= threshold
+    end
+  end
+
+  def self.included(base)
+    # Autoload all files in rules
+    # This is bad, mkay
+    Dir["#{File.dirname(__FILE__)}/splam/rules/*.rb"].each do |f|
+      require f
+    end
+    base.send :extend, ClassMethods
+  end
+  
+  module ClassMethods
+    def splam_suite; @splam_suite; end
+    # Set #body attribute as splammable with default threshold of 100
+    #   splammable :body
+    # 
+    # Set #body attribute as splammable with custom threshold
+    #   splammable :body, 50
+    #
+    # Set #body splammable with threshold and a conditions block?
+    #   splamamble :body, 50, lambda { |record| record.skip_splam_check }
+    #
+    # Set any Splam::Suite options
+    #   splammable :body do |splam|
+    #     splam.threshold  = 150
+    #     splam.conditions = lambda { |r| r.body.size.zero? }
+    #     # Set rules with #splam_key value
+    #     splam.rules     = [:chinese, :html]
+    #     # Set rules with Class instances
+    #     splam.rules     = [Splam::Rules::Chinese]
+    #     # Mix and match, we're all friends here
+    #     splam.rules     = [Splam::Rules::Chinese, :html]
+    #     # Specify optional weights
+    #     splam.rules     = {Splam::Rules::Chinese => 1.2, :html => 5.0}
+    #
+    def splammable(fieldname, threshold=100, conditions=nil, &block)
+      # todo: run only certain rules
+      #  e.g. splammable :body, 100, [ :chinese, :html ]
+      # todo: define some weighting on the model level
+      #  e.g. splammable :body, 50, { :russian => 2.0 }
+      @splam_suite = Suite.new(fieldname, Splam::Rule.default_rules, threshold, conditions, &block)
+    end
+  end
+
+  attr_accessor :skip_splam_check
+  attr_reader   :splam_score, :splam_reasons
+
+  def splam_score
+    @splam_score || run_splam_suite(:score) || 0
+  end
+
+  def splam_reasons
+    @splam_reasons || run_splam_suite(:reasons) || []
+  end
+
+  def splam?
+    # run_splam_suite # ask yourself, do you want this to be cached for each record instance or not?
+    self.class.splam_suite.splam?(splam_score)
+  end
+
+  def validates_as_spam
+    errors.add(self.class.splam_suite.body, "looks like spam.") if (!skip_splam_check? && splam?)
+  end
+
+protected
+  def run_splam_suite(attr_suffix = nil)
+    splam_suite = self.class.splam_suite || raise("Splam::Suite is not initialized")
+    return false if (splam_suite.conditions && !splam_suite.conditions.call(self)) || 
+                    skip_splam_check ||
+                    send(splam_suite.body).nil?
+    @splam_score, @splam_reasons = splam_suite.run(self)
+    instance_variable_get("@splam_#{attr_suffix}") if attr_suffix
+  end
+  
+  def skip_splam_check?
+    # This enables us to use a checkbox
+    skip_splam_check.to_i > 0
+  end
+end

data/lib/splam/rule.rb

@@ -0,0 +1,73 @@
+class Splam::Rule
+  class << self
+    attr_writer   :splam_key
+
+    # Global set of rules for all splammable classes.  By default it is an array of all Splam::Rule subclasses.
+    # It can be set to a subset of all rules, or even a hash with specified weights.
+    #   self.default_rules = [:bad_words, :bbcode]
+    #   self.default_rules = {:bad_words => 0.5, :bbcode => 7}
+    #
+    attr_accessor :default_rules
+
+    # Index linking all splam_keys to the rule classes.  This is populated automatically.
+    attr_reader   :rules
+
+    def splam_key
+      @splam_key || (self.splam_key = name.demodulize.underscore.to_sym)
+    end
+
+    def splam_key=(value)
+      Splam::Rule.rules.delete(@splam_key) if @splam_key
+      Splam::Rule.rules[value] = self
+      @splam_key               = value
+      value
+    end
+
+    def run(*args)
+      rule = new(*args)
+      rule.run
+      rule
+    end
+  end
+
+  def initialize(suite, record, weight = 1.0)
+    @suite, @weight, @score, @reasons, @body = suite, weight, 0, [], record.send(suite.body)
+  end
+  
+  def name
+    self.class.splam_key
+  end
+
+  def self.inherited(_subclass)
+    @rules      ||= {}
+    @default_rules ||= []
+    @default_rules << _subclass
+    _subclass.splam_key
+    super
+  end
+
+  attr_reader   :suite, :body, :weight
+  attr_accessor :reasons, :score
+
+  # Overload this method to run your rule.  Call #add_score to modify the suite's splam score.
+  #
+  #   def run
+  #     add_score -5, 'water'
+  #     add_score  5, 'PBR'
+  #     add_score 10, 'black butte'
+  #     add_score 30, 'red wine'
+  #     add_score 95, 'everclear'
+  #   end
+  #
+  def run
+  end
+  
+  def add_score(points, reason)
+    @score ||= 0
+    if points != 0
+      @reasons << "#{name}: [#{points}#{" * #{weight}" if weight != 1}] #{reason}"
+      points = points * weight.to_i
+      @score += points
+    end
+  end
+end

data/lib/splam/rules.rb

@@ -0,0 +1,2 @@
+module Splam::Rules
+end

data/lib/splam/rules/arms_race.rb

@@ -0,0 +1,24 @@
+class Splam::Rules::ArmsRace < Splam::Rule
+  class << self
+    attr_accessor :bad_word_score
+  end
+
+  self.bad_word_score = 40
+
+  # This is where you put banned domain names or otherwise
+  def run
+    shitty_sites = ["inquisitr"]    
+    shitty_sites.each do |word|
+      results = @body.downcase.scan(word) 
+      if results && results.size > 0
+        add_score((self.class.bad_word_score ** results.size), "stupid site: '#{word}'")
+        @body.scan(/<a[^>]+>(.*?)<\/a>/).each do |match|
+          add_score self.class.bad_word_score * 4 * match[0].scan(word).size, "nasty word inside a link: #{word}"
+        end
+        @body.scan(/<a(.*?)>/).each do |match|
+          add_score self.class.bad_word_score * 4 * match[0].scan(word).size, "nasty word inside a URL: #{word}"
+        end
+      end
+    end
+  end
+end

data/lib/splam/rules/bad_words.rb

@@ -0,0 +1,46 @@
+class Splam::Rules::BadWords < Splam::Rule
+  class << self
+    attr_accessor :bad_word_score, :suspicious_word_score
+  end
+  
+  self.bad_word_score       = 10
+  self.suspicious_word_score = 4
+
+  def run
+    bad_words = %w( sex sexy porn gay erotica viagra erotismo porno porn lesbian amateur tit\b)
+    bad_words |= %w( gratis erotismo porno torrent bittorrent adulto )
+    bad_words |= %w( cialis viagra payday loan jihad )
+    bad_words |= %w( webcam  free-web-host rapidshare muslim)
+    bad_words << /pel?cula/ << /pornogr?fica/ << "portal porno" # srsly, spamming in spanish?
+
+    suspicious_words =  %w( free buy galleries dating gallery hard hardcore video homemade celebrity ) << "credit card" << "my friend" << "friend sent me"
+    suspicious_words |= %w( adult pharmacy overnight shipping free hot movie nylon arab ?????? xxx) << "sent me a link"
+    suspicious_words << "forums/member.php?u=" << "chat room" << "free chat" << "yahoo chat" << "page.php"
+    bad_words.each do |word|
+      results = @body.downcase.scan(word) 
+      if results && results.size > 0
+        add_score((self.class.bad_word_score ** results.size), "nasty word: '#{word}'")
+        # Add more points if the bad word is INSIDE a link
+        @body.scan(/<a[^>]+>(.*?)<\/a>/).each do |match|
+          add_score self.class.bad_word_score * 4 * match[0].scan(word).size, "nasty word inside a link: #{word}"
+        end
+        @body.scan(/\nhttp:\/\/(.*?#{word})/).each do |match|
+          add_score self.class.bad_word_score ** 4 * match[0].scan(word).size, "nasty word inside a straight-up link: #{word}"
+        end
+        @body.scan(/<a(.*?)>/).each do |match|
+          add_score self.class.bad_word_score * 4 * match[0].scan(word).size, "nasty word inside a URL: #{word}"
+        end
+      end
+    end
+    suspicious_words.each do |word|
+      results = @body.downcase.scan(word) 
+      if results && results.size > 0
+        add_score (self.class.suspicious_word_score * results.size), "suspicious word: #{word}"
+        # Add more points if the bad word is INSIDE a link
+        @body.scan(/<a[^>]+>(.*?)<\/a>/).each do |match|
+          add_score((self.class.suspicious_word_score * match[0].scan(word).size), "suspicious word inside a link: #{word}")
+        end
+      end
+    end
+  end
+end

data/lib/splam/rules/bbcode.rb

@@ -0,0 +1,12 @@
+class Splam::Rules::Bbcode < Splam::Rule
+
+  def run
+    add_score 10 * @body.scan("showpost.php?p=").size, "Linking to a shitty forum"
+    # add_score 10 * @body.scan("\r\n").size, "Poorly formed POST (\\r\\n)"
+    add_score 40 * @body.scan("[url=").size, "URL" # no URLS for you!!
+    add_score 40 * @body.scan("[URL=").size, "URL" # no URLS for you!!
+    add_score 40 * @body.scan("[url=http").size, "Shitty URL/html" # another 10 points for shitty bbcode html
+    add_score 40 * @body.scan("[URL=http").size, "Shitty URL/html" # another 10 points for shitty bbcode html
+    add_score 10 * @body.scan(/\[[bai]/).size, "b/a/i tag"
+  end
+end

data/lib/splam/rules/chinese.rb

@@ -0,0 +1,26 @@
+class Splam::Rules::Chinese < Splam::Rule
+  class << self
+    attr_accessor :base_score
+  end
+  self.base_score = 3
+
+  def run
+    banned_words =[ # various chinese characters
+      "\350\263\207",
+      "\351\207\221",
+      "\357\274\222", # number 2 in weird unicode
+      "\357\274\224", # number 4 
+      "\357\274\225", # number 5
+      "\357\274\231", # number 9
+      "\357\274\215", # hyphen
+      /\\357\2\d\d\\\d{3}/,
+      # "\357", # ugh, these don't work .. because they're only part of a character.
+      # "\351",
+      "\35"
+    ]
+    banned_words.each do |word|
+      hits = (self.class.base_score * @body.scan(word).size) # 1 point for every banned word
+      add_score hits, "Banned character: #{word}"
+    end
+  end
+end