defender 1.0.3 → 2.0.0beta1

data/.document

@@ -0,0 +1,5 @@
+README.md
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+doc
+.yardoc
+
+## PROJECT::SPECIFIC
+
+.bundle

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+gemspec
+
+gem 'watchr', '~> 0.7'
+gem 'rspec', '~> 2.1.0'
+gem 'yard', '~> 0.6.3'

data/README.md

@@ -22,54 +22,107 @@ spam and malicious content in the documents.
 A document contains content to be analyzed by Defensio, or that has been
 analyzed.
 
-Before starting to use Defender, you need to retrieve an API key from
-[Defensio][4]. After getting an API key, you need to let Defender know
-what it is by doing something like this somewhere in your code (before
-doing anything like saving documents):
-
-    Defender.api_key = 'my-api-key'
-
-Submitting documents to Defensio is really easy. Here's a barebones
-example:
-
-    require 'defender'
-    document = Defender::Document.new
-    document.data[:content] = 'Hello World!'
-    document.data[:type] = 'comment'
-    document.data[:platform] = 'defender'
-    document.save
-
-The `document.data` hash can contain a lot of data. The ones you see
-here are the only required ones, but you should submit as much data as
-you can. Look at the [Defensio API docs][3] for information on the
-different data you can submit. Oh, and the keys can be symbols, and you
-can use underscores instead of dashes.
-
-After saving the document, Defender will set the `document.allow?`,
-`document.spaminess` and
-`document.signature` attributes. The first one tells you if you should
-display the document or not on your website. The second is a float which
-tells you just how spammy the document is. This could be useful for
-sorting the documents in an admin panel. The lower the spaminess is, the
-less chance is it for it being spam. The last attribute is an unique
-identifier you should save with your document in the database. This can
-be used for retrieving the status of your document again, and for
-retraining purposes.
-
-Did I say retraining? Oh yes, you can retrain Defensio! If some spam
-went through the filters, or some legit documents were marked as spam,
-tell Defensio by setting the `document.allow` attribute and save the
-document again:
-
-    document.allow = true
-    document.save
-
-This tells Defensio that the document should've been allowed. Don't have
-access to the `document` instance any more you say? No problem, just
-retrieve it again using the signature. You did save the signature,
-didn't you?
-
-    document = Defender::Document.find(signature)
+To use Defender, you need to retrieve an API key from
+[Defensio][4]. Then add Defender (`gem 'defender'`) to your Gemfile and run
+`bundle install`. To set up Defender, open your Comment class and include
+Defender::Spammable, and configure it by adding your API key. Your comment
+class should look something like this:
+
+    class Comment < ActiveRecord::Base
+      include Defender::Spammable
+      configure_defender :api_key => '0123456789abcdef'
+    end
+
+Now you need to add a few fields to your model. Defender requires a boolean
+field named "spam" (this will be `true` for comments marked as spam, and
+`false otherwise`), and a string field named "defensio_sig" (this will include
+a unique identifier so you can later mark false positives and negatives).
+Defender will also set the spaminess field if it exists (the spaminess field
+should be a float that can range between 0.00 and 1.00, where 0.00 is the
+least spammy and 1.00 is the most spammy). After you've done this, you're
+probably done setting up Defender, although you should read on as there's some
+more things you should know.
+
+Defender will automatically get the comment body, author name, email, IP and
+URL if you have them in your comment class with "standard names". Defender
+will look for fields named "body", "content" and "comment" (in that order) for
+the comment content, "author_name", "author" for the author name,
+"author_email", "email" for the author email, "author_ip", "ip" for the author
+IP, "author_url", "url" for the author URL. Only the comment content is the
+required one of these. If you're not using those attribute names, look further
+down in the readme under "Defining your own attribute names".
+
+Not using ActiveRecord? No problem, Defender supports all libraries that
+support ActiveModel, including Mongoid, MongoMapper and DataMapper. The syntax
+is the exact same, just use the method your library uses to set up the fields
+needed.
+
+
+Defining your own attribute names
+---------------------------------
+
+Defensio supports a large amount of attributes you can send to it, and the 
+more you send the more accurately it can determine whether it's spam or not.
+For some of these attributes, Defender will use conventions and try to find
+the attribute, but not all are set up (look at 
+Defender::Spammable::DEFENSIO_KEYS for the exact keys it uses). If you are 
+using other attribute names, or want to add more to get more accurate spam
+evaluation, you do that in the `configure_defender` method. Pass in another
+option called `:keys`, which should be a hash of defensio key names and
+attribute names. The list of defensio key names are after the code example,
+and the attribute name is just a symbol. So if your comment content field is
+called "the_comment_itself", your comment class should look like this:
+
+    class Comment
+      include Defender::Spammable
+      configure_defender :api_key => '0123456789abcdef', :keys => { 'content' => :the_comment_itself }
+    end
+
+If you don't want to store all the information in the database, you can also
+use the `defensio_data` method. In the model, before saving, call
+`defensio_data` with a hash containing the data you want to send. The keys
+should be strings, you can see all the possible values listed below. The
+`defensio_data` method can be called several times with more data.
+
+These are the keys defensio supports (at the time of writing, see
+http://defensio.com/api for a completely up-to-date list):
+
+* **author-email**: The email address of the author of the document.
+* **author-ip**: The IP address of the author of the document.
+* **author-logged-in**: Whether or not the user posting the document is logged
+    onto your Web site, either through your own authentication method or
+    through OpenID.
+* **author-name**: The name of the author of the document.
+* **author-openid**: The OpenID URL of the logged-on user. Must be used in
+    conjunction with user-logged-in=true.
+* **author-trusted**: Whether or not the user is an administrator, moderator,
+    or editor of your Web site. Pass true only if you can guarantee that the
+    user has been authenticated, has a role of responsibility, and can be
+    trusted as a good Web citizen.
+* **author-url**: The URL of the person posting the document.
+* **browser-cookies**: Whether or not the Web browser used to post the
+    document (ie. the comment) has cookies enabled. If no such detection has
+    been made, leave this value empty.
+* **browser-javascript**: Whether or not the Web browser used to post the
+    document (ie. the comment) has JavaScript enabled. If no such detection
+    has been made, leave this value empty.
+* **document-permalink**: The URL to the document being posted.
+* **http-headers**: Contains the HTTP headers sent with the request. You can
+    send a few values or all values. Because this information helps Defensio
+    determine if a document is innocent or not, the more headers you send, the
+    better. The format of this value is one key/value pair per line, each line
+    starting with the key followed by a colon and then the value.
+* **parent-document-date**: The date the parent document was posted. For
+    example, on a blog, this would be the date the article related to the
+    comment (document) was posted. If you're using threaded comments, send the
+    date the article was posted, not the date the parent comment was posted.
+* **parent-document-permalink**: The URL of the parent document. For example,
+    on a blog, this would be the URL the article related to the comment
+    (document) was posted.
+* **referrer**: Provide the value of the HTTP_REFERER (note spelling) in this
+    field.
+* **title**: Provide the title of the document being sent. For example, this
+    might be the title of a blog article.
 
 
 Development
@@ -81,7 +134,6 @@ First, you should clone the repo and run the features and specs:
 
     git clone git://github.com/dvyjones/defender.git
     cd defender
-    rake features
     rake spec
 
 Feel free to ping the mailing list if you have any problems and we'll
@@ -121,7 +173,7 @@ Meta
 * Docs: <http://yardoc.org/docs/dvyjones-defender/>
 * Bugs: <http://github.com/dvyjones/defender/issues>
 * List: <defender@librelist.com>
-* Gems: <http://gemcutter.org/gems/defender>
+* Gems: <http://rubygems.org/gems/defender>
 
 This project uses [Semantic Versioning][sv].
 

data/ROADMAP.md

@@ -0,0 +1,12 @@
+Roadmap
+=======
+
+v1.1.0
+------
+
+* Statistics
+
+v1.2.0
+------
+
+* Asynchronous calls

data/Rakefile

@@ -0,0 +1,25 @@
+# coding:utf-8
+$:.unshift File.expand_path('../lib', __FILE__)
+
+require 'bundler'
+require 'rubygems'
+require 'rubygems/specification'
+require 'defender'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w{-fs --color}
+end
+
+begin
+  require 'yard'
+rescue LoadError
+  raise 'Run `gem install yard` to generate docs'
+else
+  YARD::Rake::YardocTask.new do |conf|
+    conf.options = ['-mmarkdown', '-rREADME.md']
+    conf.files = ['lib/**/*.rb', '-', 'LICENSE']
+  end
+end

data/defender.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/defender/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "defender"
+  s.version     = Defender::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Henrik Hodne']
+  s.email       = ['dvyjones@dvyjones.com']
+  s.homepage    = 'http://rubygems.org/gems/dvyjones'
+  s.summary     = 'ActiveModel plugin for Defensio.'
+  s.description = 'An ActiveModel plugin for Defensio.'
+
+  s.required_rubygems_version = ">= 1.3.6"
+  
+  s.add_dependency('defensio', '~> 0.9.1')
+  s.add_dependency('activemodel', '~> 3.0.0')
+  s.add_development_dependency('bundler', '~> 1.0.0')
+  
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/defender.rb

@@ -1,18 +1,36 @@
-require 'defender/version'
-require 'defender/document'
-
+##
+# Main Defender module. Everything should be under this module.
 module Defender
+  autoload :VERSION, 'defender/version'
+  autoload :Version, 'defender/version'
+  autoload :Spammable, 'defender/spammable'
+  autoload :DefenderError, 'defender/defender_error'
+  
   ##
   # Set this to your Defensio API key. Get one at http://defensio.com.
+  #
+  # @see Defender::Spammable::ClassMethods.configure_defender
+  #
+  # @param [String] api_key The Defensio API key.
   def self.api_key=(api_key)
     @api_key = api_key.to_s
   end
+  
+  ##
+  # Returns the Defensio API key set with {Defender.api_key=}.
+  #
+  # @see Defender.api_key=
+  # @return [String] The API key if set.
+  # @return [nil] If no API key has been set.
+  def self.api_key
+    @api_key
+  end
 
   ##
   # You most probably don't need to set this.  It is used to replace the backend
   # when running the tests.  If you for any reason need to use another backend
   # than the defensio gem, set this.  The object needs to respond to the same
-  # methods as the {Defensio} object does.
+  # methods as the Defensio object does.
   #
   # @param [Defensio] defensio The Defensio backend
   def self.defensio=(defensio)
@@ -22,6 +40,8 @@ module Defender
   ##
   # The Defensio backend. If no backend has been set yet, this will create one
   # with the api key set with {Defender.api_key}.
+  #
+  # @return [Defensio] The Defensio backend
   def self.defensio
     return @defensio  if defined?(@defensio)
     require 'defensio'

data/lib/defender/defender_error.rb

@@ -0,0 +1,7 @@
+module Defender
+  ##
+  # Defender exception class. This will be thrown on errors returned by
+  # Defensio.
+  class DefenderError < StandardError
+  end
+end

data/lib/defender/spammable.rb

@@ -0,0 +1,182 @@
+module Defender
+  ##
+  # Include this in your ActiveModel-supporting model to enable spam
+  # filtering.
+  #
+  # Defender will try to autodetect details about your rails setup, but you
+  # need to do some configuration yourself. If you already have an application
+  # config file that loads into a constant named APP_CONFIG, and your
+  # comment model has an attribute named 'body', 'content' or 'comment'
+  # including the comment body, then you are almost ready to go. Create the
+  # 'spam' and 'defensio_sig' attribute in the database (a boolean and a
+  # string, respectively) and then include {Defender::Spammable} in your
+  # model. You can now call #spam? on your model after saving it.
+  # Congratulations!
+  #
+  # Defender requires the model to have callbacks, more exactly, the
+  # before_save callback. Most ActiveModel-libraries should have that, so you
+  # should only need to worry if you're making your own models. Just look at
+  # {Defender::Test::Comment} for an example comment model.
+  module Spammable
+    # These are the default attribute names Defender will pull information
+    # from if no other names are configured. So the content of the comment
+    # will be pulled from 'body', if that attribute exists. Otherwise, it will
+    # pull from 'content'. If that doesn't exist either, it will pull from
+    # 'comment'. If that doesn't exist either, you should configure your own
+    # name in {Defender::Spammable::ClassMethods.configure_defender}.
+    DEFENSIO_KEYS = {
+      'content' => [:body, :content, :comment],
+      'author-name' => [:author_name, :author],
+      'author-email' => [:author_email, :email],
+      'author-ip' => [:author_ip, :ip],
+      'author-url' => [:author_url, :url]
+    }
+    
+    ##
+    # These methods will be pulled in as class methods in your model when
+    # including {Defender::Spammable}.
+    module ClassMethods
+      ##
+      # Configure Defender by passing a set of options.
+      #
+      # @param [Hash] options Options for configuring Defender.
+      # @option options [Hash] :keys Mapping between field names in the
+      #   database and in defensio.
+      # @option options [String] :api_key Your Defensio API key. Get one at
+      #   defensio.com.
+      # 
+      def configure_defender(options)
+        keys = options.delete(:keys)
+        _defensio_keys.merge!(keys) unless keys.nil?
+        api_key = options.delete(:api_key)
+        Defender.api_key = api_key unless api_key.nil?
+      end
+      
+      ##
+      # Returns the key-attribute mapping used.
+      #
+      # Will automatically set it to the defaults in {DEFENSIO_KEYS} if
+      # nothing else has been set before.
+      def _defensio_keys
+        @_defensio_keys ||= DEFENSIO_KEYS.dup
+      end
+    end
+    
+    ##
+    # These methods will be pulled in as instance methods in your model when
+    # including {Defender::Spammable}.
+    module InstanceMethods
+      ##
+      # Returns true if the comment is recognized as spam or malicious.
+      #
+      # If the value is stored in the database that value will be returned.
+      # If nil is returned, the comment has not yet been submitted to
+      # Defensio.
+      #
+      # @raise [Defender::DefenderError] Raised if there is no spam attribute
+      #   in the model.
+      # @return [Boolean] Whether the comment is spam or not.
+      def spam?
+        if self.new_record?
+          nil
+        elsif self.respond_to?(:spam) && !self.spam.nil?
+          return self.spam
+        else
+          raise Defender::DefenderError, 'You need to add a spam attribute to the model'
+        end
+      end
+      
+      ##
+      # Pass in some data to be sent to defensio. You can use this method to
+      # pass in more data that you don't want to save in the model.
+      #
+      # This can be called several times if you want to add more data or
+      # update data already added (using the same key twice will overwrite).
+      #
+      # Returns the data to be sent. Pass without a parameter to not modify
+      # the data.
+      #
+      # @param [Hash<String => Object>] data The data to send to defensio. See
+      #   the README for the possible key values.
+      def defensio_data(data={})
+        @_defensio_data ||= {}
+        @_defensio_data.merge!(data)
+        @_defensio_data
+      end
+      
+      private
+      
+      ##
+      # The callback that will be run before a document is saved.
+      #
+      # This will gather all the data and send it off to Defensio, and then
+      # set the spam and defensio_sig attributes (and spaminess if it's
+      # defined) before the model will be saved.
+      #
+      # @raise Defender::DefenderError If Defensio returns an error.
+      def _defender_before_save
+        data = {}
+        _defensio_keys.each do |key, names|
+          next if names.nil?
+          data[key] = _pick_attribute(names)
+        end
+        data.merge!({
+          'platform' => 'ruby',
+          'type' => 'comment'
+        })
+        data.merge!(defensio_data) if defined?(@_defensio_data)
+        document = Defender.defensio.post_document(data).last
+        if document['status'] == 'failed'
+          raise DefenderError, document['message']
+        end
+        self.spam = !document['allow'] 
+        self.defensio_sig = document['signature'].to_s
+        self.spaminess = document['spaminess'] if self.respond_to?(:spaminess=)
+      end
+      
+      ##
+      # Return the first attribute value from a list of attribute names/
+      #
+      # @param [Array<Symbol>, Symbol] names A list of attribute names
+      # @return [] The attribute value of the first existing attribute
+      # @return [nil] If no attribute was found (or if attribute value is nil)
+      def _pick_attribute(names)
+        [names].flatten.each do |name|
+          return self.send(name) if self.respond_to?(name)
+        end
+        return nil
+      end
+      
+      ##
+      # Retrieves the Defensio document from the server if it hasn't been
+      # retrieved before or if the first parameter is true.
+      #
+      # @param [Boolean] force Pass true to force a refetch, otherwise it will
+      #   get the cached document (if one is cached).
+      # @return [Hash] The document retrieved from the server.
+      def _get_defensio_document(force=false)
+        if force || @_defensio_document.nil?
+          @_defensio_document = Defender.defensio.get_document(self.defensio_sig).last
+        end
+        @_defensio_document
+      end
+      
+      ##
+      # Wrapper for {Defender::Spammable::ClassMethods._defensio_keys}.
+      #
+      # @see Defender::Spammable::ClassMethods._defensio_keys
+      def _defensio_keys
+        self.class._defensio_keys
+      end
+    end
+    
+    ##
+    # Includes {Defender::Spammable::ClassMethods} and
+    # {Defender::Spammable::InstanceMethods} and sets up save callback.
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+      receiver.send :before_save, :_defender_before_save
+    end
+  end
+end

data/lib/defender/test/comment.rb

@@ -0,0 +1,36 @@
+require 'active_model'
+
+##
+# Stuff to test Defender. You probably shouldn't use this in your application,
+# but it is included as an example of the minimum needed for a valid setup.
+module Defender::Test
+  ##
+  # A fake Comment class to use. No need to require ActiveRecord and set up an
+  # actual database. We will use ActiveModel for callbacks though.
+  class Comment
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    define_model_callbacks :save
+  
+    # We now have a "valid" model, let's bring in Defender.
+    include Defender::Spammable
+  
+    attr_accessor :body, :author, :author_ip, :created_at, :spam, :defensio_sig
+  
+    ##
+    # Returns true if save has been called, false otherwise.
+    def new_record?
+      !@saved ||= false
+    end
+  
+    ##
+    # Run save callback and make {Defender::Test::Comment.new_record?} return false.
+    def save
+      _run_save_callbacks do
+        # We're not actually saving anything, just letting Defender know we
+        # would be.
+        @saved = true
+      end
+    end
+  end
+end

data/lib/defender/version.rb

@@ -1,3 +1,4 @@
 module Defender
-  VERSION = '1.0.3'
+  # Current Defender version
+  VERSION = '2.0.0beta1'
 end

data/spec/defender/spammable_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+module Defender
+  describe Spammable do
+    describe '.configure_defender' do
+      it 'sets the attribute-data key mappers' do
+        Comment.configure_defender(:keys => {'foo' => :bar, 'foobar' => :baz})
+        Comment._defensio_keys.should include({'foo' => :bar, 'foobar' => :baz})
+      end
+      
+      it 'sets the API key' do
+        Comment.configure_defender(:api_key => 'foobar')
+        Defender.api_key.should == 'foobar'
+      end
+    end
+    
+    describe '#spam?' do
+      it 'returns the "spam" attribute unless it is nil' do
+        comment_class = Class.new
+        comment_class.instance_eval { attr_accessor :spam }
+        def comment_class.before_save(*args, &block); end
+        comment_class.send(:define_method, :new_record?) { false }
+        comment_class.send(:include, Defender::Spammable)
+        comment = comment_class.new
+        comment.spam = true
+        comment.spam?.should be_true
+      end
+      
+      it 'returns nil for a new record' do
+        comment_class = Class.new
+        comment_class.instance_eval { attr_accessor :spam }
+        def comment_class.before_save(*args, &block); end
+        comment_class.send(:define_method, :new_record?) { true }
+        comment_class.send(:include, Defender::Spammable)
+        comment = comment_class.new
+        comment.spam?.should be_nil
+      end
+      
+      it 'raises a DefenderError if no spam attribute exists' do
+        comment_class = Class.new
+        def comment_class.before_save(*args, &block); end
+        comment_class.send(:define_method, :new_record?) { false }
+        comment_class.send(:include, Defender::Spammable)
+        comment = comment_class.new
+        expect { comment.spam? }.to raise_error(Defender::DefenderError)
+      end
+    end
+    
+    describe '#defensio_data' do
+      it 'merges in more data to be sent to Defensio' do
+        comment = Comment.new
+        comment.defensio_data({'foo' => 'FOOBAR', 'foobar' => 'baz'})
+        comment.defensio_data.should include({'foo' => 'FOOBAR', 'foobar' => 'baz'})
+      end
+      
+      it 'overwrites values repassed' do
+        comment = Comment.new
+        comment.defensio_data({'foo' => 'FOOBAR'})
+        comment.defensio_data({'foo' => 'baz'})
+        comment.defensio_data['foo'].should == 'baz'
+      end
+      
+      it 'leaves values that aren\'t modified' do
+        comment = Comment.new
+        comment.defensio_data({'foo' => 'baz'})
+        comment.defensio_data({'bar' => 'foobar'})
+        comment.defensio_data['foo'].should == 'baz'
+      end
+    end
+    
+    describe '#_defender_before_save' do
+      it 'sets the attributes returned from defensio' do
+        comment = Comment.new
+        comment.body = '[innocent,0.9]'
+        comment.save
+        comment.spam.should be_false
+        comment.defensio_sig.should_not be_nil
+      end
+      
+      it 'sends the information off to Defensio' do
+        old_defensio = Defender.defensio
+        defensio = double('defensio')
+        defensio.should_receive(:post_document) { [200, {'signature' => 1234567890, 'spaminess' => 0.9, 'allow' => true}] }
+        Defender.defensio = defensio
+        comment = Comment.new
+        comment.body = 'Hello, world!'
+        comment.save
+        Defender.defensio = old_defensio
+      end
+    end
+    
+    describe '#_pick_attribute' do
+      it 'returns the value of the attribute passed if it exists' do
+        comment = Comment.new
+        comment.body = 'Foobar!'
+        comment.send(:_pick_attribute, :body).should == 'Foobar!'
+      end
+      
+      it 'returns the value for the first attribute that exists in a list of attributes' do
+        comment = Comment.new
+        comment.body = 'Foobar!'
+        comment.send(:_pick_attribute, [:content, :body]).should == 'Foobar!'
+      end
+      
+      it 'returns nil if no attribute with the given names exists' do
+        comment = Comment.new
+        comment.send(:_pick_attribute, :bogus_attribute).should be_nil 
+      end
+    end
+    
+    describe '#_get_defensio_document' do
+      it 'retrieves the document from Defensio' do
+        old_defensio = Defender.defensio
+        defensio = double('defensio')
+        defensio.should_receive(:get_document) { [200, {'status' => 'succeed'}] }
+        Defender.defensio = defensio
+        comment = Comment.new
+        comment.defensio_sig = '0123456789abcdef'
+        comment.send(:_get_defensio_document)
+        Defender.defensio = old_defensio
+      end
+    end
+  end
+end

data/spec/fake_defensio.rb

@@ -0,0 +1,36 @@
+class FakeDefensio
+  def initialize
+    @documents = {}
+  end
+
+  def post_document(data)
+    content = data[:content] || data['content']
+    classification, spaminess = content[1..-2].split(',')
+    signature = "#{rand}#{content}".hash
+
+    @documents[signature] = {
+      'api-version' => '2.0',
+      'status' => 'success',
+      'message' => '',
+      'signature' => signature,
+      'allow' => (classification == 'innocent'),
+      'classification' => classification,
+      'spaminess' => spaminess.to_f,
+      'profanity-match' => false
+    }
+
+    [200, @documents[signature]]
+  end
+
+  def get_document(signature)
+    if @documents.has_key?(signature)
+      [200, @documents[signature]]
+    else
+      [404,
+        'api-version' => '2.0',
+        'status' => 'failure',
+        'message' => 'document not found'
+      ]
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format nested

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'defender'
+require 'defender/test/comment'
+require 'fake_defensio'
+
+Comment = Defender::Test::Comment
+
+Defender.defensio = FakeDefensio.new

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: defender
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
-  - 1
+  - 2
   - 0
-  - 3
-  version: 1.0.3
+  - 0beta1
+  version: 2.0.0beta1
 platform: ruby
 authors: 
 - Henrik Hodne
@@ -14,13 +14,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-28 00:00:00 +02:00
+date: 2010-12-20 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: defensio
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
@@ -32,50 +33,38 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: activemodel
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
         - 3
         - 0
-        version: 1.3.0
-  type: :development
+        - 0
+        version: 3.0.0
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: yard
+  name: bundler
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
         segments: 
+        - 1
         - 0
-        - 5
         - 0
-        version: 0.5.0
+        version: 1.0.0
   type: :development
   version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: cucumber
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 6
-        - 0
-        version: 0.6.0
-  type: :development
-  version_requirements: *id004
-description: A wrapper of the Defensio spam filtering service.
+description: An ActiveModel plugin for Defensio.
 email: 
-- henrik.hodne@binaryhex.com
+- dvyjones@dvyjones.com
 executables: []
 
 extensions: []
@@ -83,15 +72,25 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/generators/defender/defender_generator.rb
-- lib/generators/defender/USAGE
-- lib/defender.rb
-- lib/defender/document.rb
-- lib/defender/version.rb
+- .document
+- .gitignore
+- Gemfile
 - LICENSE
 - README.md
+- ROADMAP.md
+- Rakefile
+- defender.gemspec
+- lib/defender.rb
+- lib/defender/defender_error.rb
+- lib/defender/spammable.rb
+- lib/defender/test/comment.rb
+- lib/defender/version.rb
+- spec/defender/spammable_spec.rb
+- spec/fake_defensio.rb
+- spec/spec.opts
+- spec/spec_helper.rb
 has_rdoc: true
-homepage: http://github.com/dvyjones/defender
+homepage: http://rubygems.org/gems/dvyjones
 licenses: []
 
 post_install_message: 
@@ -100,6 +99,7 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -107,6 +107,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -118,9 +119,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Ruby API wrapper for Defensio
+summary: ActiveModel plugin for Defensio.
 test_files: []
 

data/lib/defender/document.rb

@@ -1,126 +0,0 @@
-module Defender
-  ##
-  # A document contains data to be analyzed by Defensio, or that has been
-  # analyzed.
-  class Document
-    ##
-    # Whether the document should be published on your Web site or not.
-    #
-    # For example, spam and malicious content are not allowed.
-    #
-    # @return [Boolean]
-    attr_accessor :allow
-    alias_method :allow?, :allow
-
-    ##
-    # The information about the document. This hash accepts so many parameters
-    # I won't list them here. Go look at the [Defensio API docs]
-    # (http://defensio.com/api) instead.
-    #
-    # Defender will replace all underscores in keys with dashes, so you can use
-    # `:author_email` instead of `'author-email'`.
-    #
-    # @return [Hash{#to_s => #to_s}]
-    attr_accessor :data
-
-    ##
-    # A unique identifier for the document.
-    #
-    # This is needed to retrieve the status back from Defensio and to submit
-    # false negatives/positives to Defensio. Signatures should be kept private
-    # and never shared with your users.
-    #
-    # @return [String]
-    attr_reader :signature
-
-    ##
-    # A float denoting how spammy a document is.
-    #
-    # This could be useful for sorting document in an admin interface.
-    #
-    # @return[Float<0.0,1.0>]
-    attr_reader :spaminess
-
-    ##
-    # Retrieves the status of a document back from Defensio.
-    #
-    # Please note that this only retrieves the status of the document (like
-    # it's spaminess, whether it should be allowed or not, etc.) and not the
-    # content of the request (all of the data in the {#data} hash).
-    #
-    # @param [String] signature The signature of the document to retrieve
-    # @return [Document,nil] The document to retrieve, or nil
-    def self.find(signature)
-      document = new
-      ret = Defender.call(:get_document, signature)
-      if ret
-        document.instance_variable_set(:@saved, true)
-        document.instance_variable_set(:@allow, ret.last['allow'])
-        document.instance_variable_set(:@signature, signature)
-        document.instance_variable_set(:@spaminess, ret.last['spaminess'])
-
-        document
-      else
-        nil
-      end
-    end
-
-    ##
-    # Initializes a new document
-    def initialize
-      @data = {}
-      @saved = false
-    end
-
-    ##
-    # @return [Boolean] Has the document been submitted to Defensio?
-    def saved?
-      @saved
-    end
-
-    ##
-    # Submit the document to Defensio.
-    #
-    # This will send all of the {#data} if the document hasn't been saved
-    # before. If it has been saved, it will submit whether the document was a
-    # false positive/negative (set the {#allow} param before saving to do
-    # this).
-    #
-    # @see #saved?
-    # @return [Boolean] Whether the save succeded or not.
-    def save
-      if saved?
-        ret = Defender.call(:put_document, @signature, {:allow => @allow})
-      else
-        ret = Defender.call(:post_document, self.class.normalize_data(@data))
-      end
-      return false if ret == false
-      return true if saved?
-
-      data = ret.last
-      @allow = data['allow']
-      @signature = data['signature']
-      @spaminess = data['spaminess']
-
-      @saved = true # This will also return true, since nothing failed as we got here
-    end
-
-
-    ##
-    # Normalizes a data hash to submit to defensio.
-    #
-    # @param [Hash] hsh The hash to be normalized
-    # @return [Hash{String => String}] The normalized hash
-    def self.normalize_data(data)
-      normalized = {}
-      data.each { |key, value|
-        if value.respond_to?(:strftime)
-          value = value.strftime('%Y-%m-%d')
-        end
-        normalized[key.to_s.gsub('_','-')] = value.to_s
-      }
-      
-      normalized
-    end
-  end
-end

data/lib/generators/defender/USAGE

@@ -1,9 +0,0 @@
-Description:
-    Creates a migration that adds defender fields to the table of your choice.
-    Pass the model name, either CamelCased or under_scored, as an argument.
-
-Example:
-    rails generate defender Comment
-
-    creates a migration for the Comment model:
-        db/migrate/12345678901234_add_defender_to_comments.rb

data/lib/generators/defender/defender_generator.rb

@@ -1,11 +0,0 @@
-require 'rails/generators'
-
-class DefenderGenerator < Rails::Generators::NamedBase
-  def self.source_root
-    File.join(File.dirname(__FILE__), 'templates')
-  end
-
-  def create_migration
-    generate(:migration, "add_defender_to_#{table_name} defensio_signature:string spaminess:float spam:boolean")
-  end
-end