mikehale-akismet 0.0.1

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 0

data/lib/akismet.rb

@@ -0,0 +1,64 @@
+require 'net/http'
+require 'uri'
+
+class Akismet
+  USER_AGENT = "Akismet-rb/1.0 | Akismet/1.11"
+
+  def initialize(key, url)
+    @key = key
+    @url = url
+  end
+
+  def verify_key
+    response = Net::HTTP.start('rest.akismet.com', 80) do |http|
+      http.post('/1.1/verify-key', post_data(:key => @key, :blog => @url), {'User-Agent' => USER_AGENT})
+    end
+
+    case response.body
+    when "invalid"
+      raise Akismet::VerifyException, response.to_hash["x-akismet-debug-help"], caller
+    when "valid"
+      true
+    end
+  end
+  
+  def submit_spam(args)
+    call_akismet('submit-spam', args)
+  end
+  
+  def submit_ham(args)
+    call_akismet('submit-ham', args)
+  end
+  
+  def spam?(args)
+    call_akismet('comment-check', args)
+  end
+  
+  def ham?(args)
+    !spam?(args)
+  end
+
+  def call_akismet(method, args)
+    args.update(:blog => @url)
+
+    response = Net::HTTP.start("#{@key}.rest.akismet.com", 80) do |http|
+      http.post("/1.1/#{method}", post_data(args), {'User-Agent' => USER_AGENT})
+    end
+    
+    case response.body
+    when "true"
+      true
+    when "false"
+      false
+    end
+  end
+  
+  def post_data(hash)
+    hash.inject([]) do |memo, hash|
+      k, v = hash
+      memo << "#{k}=#{URI.escape(v)}"
+    end.join('&')
+  end
+
+  class VerifyException < Exception; end
+end

data/spec/akismet_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Akismet" do
+  include SpecHttp
+  
+  def params
+    {
+      :user_ip => "1.2.3.4",
+      :referrer => "http://othersite.com",
+      :permalink => "http://example.com/post",
+      :comment_type => "comment",
+      :comment_author => "joe smith",
+      :comment_author_email => "joe@smith.com",
+      :comment_author_url => "blog.smith.com"
+    }
+  end
+  
+  before do
+    @akismet = Akismet.new('thekey', 'http://example.com')
+    app = lambda do |env|
+      spam = env["rack.input"].include?('viagra')
+      [200, {}, [spam ? "true" : "false"]]
+    end
+    map Rack::URLMap.new("http://thekey.rest.akismet.com/1.1/comment-check" => app)
+  end
+  
+  it "should verify the key" do
+    map Rack::URLMap.new("http://rest.akismet.com/" => lambda { |env| [200, {}, ["valid"]]})
+    
+    @akismet.verify_key.should == true
+    request.post?.should == true
+    request.env['HTTP_USER_AGENT'].should == "Akismet-rb/1.0 | Akismet/1.11"
+    request.body.should include('http://example.com')
+    response.status.should == 200
+  end
+  
+  it "should not verify an invalid key" do
+    map Rack::URLMap.new("http://rest.akismet.com/" => lambda { |env| [200, {'x-akismet-debug-help' => 'sorry!'}, ["invalid"]]})    
+    lambda {@akismet.verify_key}.should raise_error Akismet::VerifyException
+    response['x-akismet-debug-help'].should == 'sorry!'
+  end
+  
+  it "should detect spam" do
+    @akismet.spam?(params.update(:comment_content => "viagra-test-123")).should == true
+    request.env.has_key?('HTTP_USER_AGENT').should == true
+    request.body.should include("blog=http://example.com")
+    request.body.should include("user_ip=1.2.3.4")
+    request.body.should include("referrer=http://othersite.com")
+    request.body.should include("permalink=http://example.com/post")
+    request.body.should include("comment_type=comment")
+    request.body.should include("comment_author=joe%20smith")
+    request.body.should include("comment_author_email=joe@smith.com")
+    request.body.should include("comment_author_url=blog.smith.com")
+    request.body.should include("comment_content=viagra-test-123")
+  end
+
+  it "should detect ham" do
+    @akismet.ham?(params.update(:comment_content => "not spam")).should == true
+  end
+  
+  it "should submit spam" do
+    map Rack::URLMap.new("http://thekey.rest.akismet.com/1.1/submit-spam" => lambda { |env| [200, {}, "true"]})
+    @akismet.submit_spam(params.update(:comment_content => "this-is-spam"))
+    request.script_name.should == "/1.1/submit-spam"
+    
+    request.env.has_key?('HTTP_USER_AGENT').should == true
+    request.body.should include("blog=http://example.com")
+    request.body.should include("user_ip=1.2.3.4")
+    request.body.should include("referrer=http://othersite.com")
+    request.body.should include("permalink=http://example.com/post")
+    request.body.should include("comment_type=comment")
+    request.body.should include("comment_author=joe%20smith")
+    request.body.should include("comment_author_email=joe@smith.com")
+    request.body.should include("comment_author_url=blog.smith.com")
+    request.body.should include("comment_content=this-is-spam")
+  end
+  
+  it "should submit ham" do
+    map Rack::URLMap.new("http://thekey.rest.akismet.com/1.1/submit-ham" => lambda { |env| [200, {}, "true"]})
+    @akismet.submit_ham(params.update(:comment_content => "this-is-ham"))
+    request.script_name.should == "/1.1/submit-ham"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'spec'
+require 'rr'
+require 'rack/urlmap'
+require File.dirname(__FILE__) + '/spec_http'
+require 'ruby-debug'
+
+class MethodSpy
+  def initialize(delegate, &block)
+    @delegate = delegate
+    @filter = block
+  end
+
+  def method_missing(symbol, *args, &block)
+    result = @delegate.send(symbol, *args, &block)
+    p [symbol, args, result, block]
+    result
+  end
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'akismet'
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end

data/spec/spec_http.rb

@@ -0,0 +1,164 @@
+require 'uri'
+require 'rack/request'
+require 'rack/response'
+require 'rack/utils'
+
+module SpecHttp
+  def map(map)
+    @socket = SocketInterceptor.new(map)
+    stub(TCPSocket).open(anything, numeric) { @socket }
+  end
+  
+  def request
+    Rack::Request.new(@socket.env)
+  end
+  
+  def response
+    @socket.response
+  end
+end
+
+class SocketInterceptor < StringIO
+  attr_reader :env, :response
+  
+  def initialize(map)
+    @map = map
+    super()
+  end
+  
+  def write(string)
+    raise "Already responded" if self.string.size > 0
+    @written = '' unless @written
+    @written << string
+    string.size
+  end
+  
+  # this depends on Net::HTTP calling socket.sysread after it has finished all writes
+  alias :orig_sysread :sysread
+  def sysread(size)
+    set_string unless self.string.size > 0
+    orig_sysread(size)
+  end
+  
+  def set_string
+    response_io = StringIO.new
+    @env = Rack::RequestStringParser.env(@written)
+    Rack::Handler::StringIO.run(app(@env), @env, response_io)
+    @response = Rack::Handler::StringIO.response
+    self.string = response_io.string
+  end
+  
+  def app(env)
+    app_to_use = @map if !@map.respond_to? :mapping
+    unless app_to_use
+      path = env["PATH_INFO"].to_s.squeeze("/")
+      hHost, sName, sPort = env.values_at('HTTP_HOST','SERVER_NAME','SERVER_PORT')
+      @map.mapping.each { |host, location, app|
+        next unless (hHost == host || sName == host \
+          || (host.nil? && (hHost == sName || hHost == sName+':'+sPort)))
+        next unless location == path[0, location.size]
+        next unless path[location.size] == nil || path[location.size] == ?/
+
+        env["SCRIPT_NAME"] += location
+        env["PATH_INFO"]    = path[location.size..-1]
+        app_to_use = app
+      }
+      raise "No application associated with #{env['rack.url_scheme']}://#{hHost}#{path}" unless app_to_use
+    end
+    app_to_use
+  end
+end
+
+module Rack
+  class URLMap
+    attr_reader :mapping
+  end
+  
+  class RequestStringParser
+    def self.env_key(key)
+      key = key.split('-').join('_').upcase
+      key = "HTTP_#{key}" unless key =~ /content/i
+      key
+    end
+    
+    def self.env(input)
+      lines = input.split("\r\n")
+
+      # find blank line which seperates the headers from the body
+      index_of_blank = nil
+      lines.each_with_index{|e,i|
+        index_of_blank = i if e == ""
+      }
+
+      type, uri = lines.first.split(/\s+/)
+      
+      if index_of_blank
+        headers = lines[1..index_of_blank]
+        body = lines[(index_of_blank + 1)..-1].first
+      else
+        headers = lines[1..-1]
+      end
+
+      headers = headers.inject({}){|h,e|
+        k,v = e.split(/:\s+/)
+        h.merge! env_key(k) => v if k
+        h
+      }
+      
+      uri = URI(uri)
+      env = headers.dup
+      env["SERVER_NAME"] = uri.host
+      env["SERVER_PORT"] = uri.port ? uri.port.to_s : "80"
+      env["QUERY_STRING"] = uri.query.to_s
+      env["PATH_INFO"] = (!uri.path || uri.path.empty?) ? "/" : uri.path
+      env["SCRIPT_NAME"] = ""
+      env["REQUEST_METHOD"] = type
+      env["rack.url_scheme"] = uri.scheme || "http"
+      env["rack.input"] = body
+      env
+    end
+  end
+  
+  module Handler
+    class StringIO
+      def self.response
+        @@response
+      end
+      
+      def self.run(app, env={}, output=StringIO.new)
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+
+        status, headers, body = app.call(env)
+        @@response = Rack::Response.new(body, status, headers)
+        begin
+          send_headers output, status, headers
+          send_body output, body
+          output.rewind
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+
+      def self.send_headers(output, status, headers)
+        output.print "HTTP/1.1 #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}\r\n"
+        headers.each { |k, vs|
+          vs.each { |v|
+            output.print "#{k}: #{v}\r\n"
+          }
+        }
+        output.print "\r\n"
+        output.flush
+      end
+
+      def self.send_body(output, body)
+        body.each { |part|
+          output.print part
+          output.flush
+        }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: mikehale-akismet
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Michael Hale
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: TODO
+email: mikehale@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- lib/akismet.rb
+- spec/akismet_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/spec_http.rb
+has_rdoc: true
+homepage: http://github.com/mikehale/akismet
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: []
+