viking 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in viking.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Risk Danger Olson, James Herdman & Pierre-Louis Gottfrois
+
+MIT License
+
+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.md

@@ -0,0 +1,55 @@
+# Viking
+
+This is a fork of [Vikinggem](https://rubygems.org/gems/vikinggem). Bug fix and
+new feature for this gem should be place here.
+
+Viking brings you easy access to the [Akismet](http://akismet.com/), and [Defensio](http://www.defensio.com/) spam protection services, but without the need for you to use Rails. VikingGem is Ruby web framework agnostic.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'viking'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install viking
+
+## Usage
+
+    Viking.connect('akismet', api_key: '1234', blog: 'http://foo.com')
+
+Spam or ham ?
+
+    Viking::Akismet.check_comment(options)
+
+## History
+
+### 1.0.0 2013-03-04
+
+* Recreated new gem using current standards
+* Fix some bugs
+
+### 0.0.3 2008-04-25
+
+* Made contents of script/ executable
+
+### 0.0.2 2008-04-22
+
+* Changed Manifest to include spec_helper.rb and website
+
+### 0.0.1 2008-04-22
+
+* Initial release
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/core_ext/object.rb

@@ -0,0 +1,15 @@
+require 'cgi'
+
+class Object
+  unless method_defined?(:to_param)
+    def to_param
+      to_s
+    end
+  end
+
+  unless method_defined?(:to_query)
+    def to_query(key)
+      [CGI.escape(key.to_s), CGI.escape(to_param.to_s)].join('=')
+    end
+  end
+end

data/lib/core_ext/transformations.rb

@@ -0,0 +1,35 @@
+class Hash
+  unless method_defined?(:symbolize_keys)
+    def symbolize_keys
+      inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
+        options
+      end
+    end
+  end
+
+  unless method_defined?(:dasherize_keys)
+    def dasherize_keys
+      inject({}) do |options, (key, value)|
+        options[key.to_s.gsub(/_/, '-')] = value
+        options
+      end
+    end
+  end
+
+  unless method_defined?(:to_query) && method(:to_query).arity == -1
+    def to_query(namespace=nil)
+      collect do |key, value|
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end.sort * '&'
+    end
+  end
+end
+
+class Array
+  unless method_defined?(:to_query) && method(:to_query).arity == -1
+    def to_query(key)
+      collect { |value| value.to_query("#{key}[]") } * '&'
+    end
+  end
+end

data/lib/viking.rb

@@ -0,0 +1,80 @@
+require "core_ext/object"
+require "core_ext/transformations"
+require "viking/version"
+
+# = Description
+# Provides a simple interface to polymorphically access to the spam protection
+# service of your choice.
+#
+# = Usage
+# I find it useful to first initialize Viking in a separate file during
+# framework initialization. Rails initializers, for instance, work great for
+# this. An example of such an initializer would be as follows:
+#
+#   Viking.default_engie = 'defensio'
+#   Viking.connect_options = { :api_key => '1234abc' }
+#
+# From this point out, Viking should have everything it needs to access the
+# service of your choice. Merely call methods on your service of choice as
+# documented. For instance:
+#
+#   Viking.mark_as_spam(:signaturs => "1234abc")
+module Viking
+  class Error < StandardError; end
+
+  autoload :Akismet, 'viking/akismet'
+  autoload :Defensio, 'viking/defensio'
+
+  class << self
+
+    attr_accessor :logger
+    attr_accessor :default_engine
+    attr_accessor :connect_options
+    attr_writer   :default_instance
+
+    def default_instance
+      @default_instance ||= connect(self.default_engine, self.connect_options)
+    end
+
+    def enabled?
+      !self.default_instance.nil?
+    end
+
+    def connect(engine, options)
+      unless engine.nil? || engine.empty?
+        Viking.const_get(engine.to_s.capitalize).new(options)
+      end
+    end
+
+    def verified?
+      self.default_instance.verified?
+    end
+
+    def check_article(options = {})
+      self.default_instance.check_article(options)
+    end
+
+    def check_comment(options = {})
+      self.default_instance.check_comment(options)
+    end
+
+    def mark_as_spam(options = {})
+      self.default_instance.mark_as_spam(options)
+    end
+
+    def mark_as_ham(options = {})
+      self.default_instance.mark_as_ham(options)
+    end
+
+    def stats
+      self.default_instance.stats
+    end
+
+    def mark_as_spam_or_ham(is_spam, options = {})
+      self.default_instance.mark_as_spam_or_ham(is_spam, options)
+    end
+
+  end
+end
+
+require "viking/base"

data/lib/viking/akismet.rb

@@ -0,0 +1,203 @@
+require 'net/http'
+require 'uri'
+require 'set'
+
+# Akismet
+#
+# Author::    David Czarnecki
+# Copyright:: Copyright (c) 2005 - David Czarnecki
+# License::   BSD
+#
+# Rewritten to be more agnostic
+module Viking
+  class Akismet < Base
+
+    class << self
+
+      attr_accessor :valid_responses
+      attr_accessor :normal_responses
+      attr_accessor :standard_headers
+      attr_accessor :host
+      attr_accessor :port
+
+    end
+
+    self.host             = 'rest.akismet.com'
+    self.port             = 80
+    self.valid_responses  = Set.new(['false', ''])
+    self.normal_responses = valid_responses.dup << 'true'
+    self.standard_headers = {
+      'User-Agent'   => "Viking (Ruby Gem) v#{Viking::VERSION}",
+      'Content-Type' => 'application/x-www-form-urlencoded'
+    }
+
+    # Create a new instance of the Akismet class
+    #
+    # ==== Arguments
+    # Arguments are provided in the form of a Hash with the following keys
+    # (as Symbols) available:
+    #
+    # +api_key+::    your Akismet API key
+    # +blog+::       the blog associated with your api key
+    #
+    # The following keys are available and are entirely optional. They are
+    # available incase communication with Akismet's servers requires a
+    # proxy port and/or host:
+    #
+    # * +proxy_port+
+    # * +proxy_host+
+    def initialize(options)
+      super
+      self.verified_key = false
+    end
+
+    # Returns +true+ if the API key has been verified, +false+ otherwise
+    def verified?
+      (@verified_key ||= verify_api_key) != :false
+    end
+
+    # This is basically the core of everything. This call takes a number of
+    # arguments and characteristics about the submitted content and then
+    # returns a thumbs up or thumbs down. Almost everything is optional, but
+    # performance can drop dramatically if you exclude certain elements.
+    #
+    # ==== Arguments
+    # +options+ <Hash>:: describes the comment being verified
+    #
+    # The following keys are available for the +options+ hash:
+    #
+    # +user_ip+ (*required*)::
+    #   IP address of the comment submitter.
+    # +user_agent+ (*required*)::
+    #   user agent information.
+    # +referrer+ (<i>note spelling</i>)::
+    #   the content of the HTTP_REFERER header should be sent here.
+    # +permalink+::
+    #   permanent location of the entry the comment was submitted to
+    # +comment_type+::
+    #   may be blank, comment, trackback, pingback, or a made up value like
+    #   "registration".
+    # +comment_author+::
+    #   submitted name with the comment
+    # +comment_author_email+::
+    #   submitted email address
+    # +comment_author_url+::
+    #   commenter URL
+    # +comment_content+::
+    #   the content that was submitted
+    # Other server enviroment variables::
+    #   In PHP there is an array of enviroment variables called <tt>_SERVER</tt>
+    #   which contains information about the web server itself as well as a
+    #   key/value for every HTTP header sent with the request. This data is
+    #   highly useful to Akismet as how the submited content interacts with
+    #   the server can be very telling, so please include as much information
+    #   as possible.
+    def check_comment(options = {})
+      return false if invalid_options?
+      message = call_akismet('comment-check', options)
+      { :spam => !self.class.valid_responses.include?(message), :message => message }
+    end
+
+    # This call is for submitting comments that weren't marked as spam but
+    # should have been (i.e. false negatives). It takes identical arguments as
+    # +check_comment+.
+    def mark_as_spam(options = {})
+      return false if invalid_options?
+      { :message => call_akismet('submit-spam', options) }
+    end
+
+    # This call is intended for the marking of false positives, things that
+    # were incorrectly marked as spam. It takes identical arguments as
+    # +check_comment+ and +mark_as_spam+.
+    def mark_as_ham(options = {})
+      return false if invalid_options?
+      { :message => call_akismet('submit-ham', options) }
+    end
+
+    # Returns the URL for an Akismet request
+    #
+    # ==== Arguments
+    # +action+ <~to_s>:: a valid Akismet function name
+    #
+    # ==== Returns
+    # String
+    def self.url(action)
+      "/1.1/#{action}"
+    end
+
+    protected
+
+    # Internal call to Akismet. Prepares the data for posting to the Akismet
+    # service.
+    #
+    # ==== Arguments
+    # +akismet_function+ <String>::
+    #   the Akismet function that should be called
+    #
+    # The following keys are available to configure a given call to Akismet:
+    #
+    # +user_ip+ (*required*)::
+    #   IP address of the comment submitter.
+    # +user_agent+ (*required*)::
+    #   user agent information.
+    # +referrer+ (<i>note spelling</i>)::
+    #   the content of the HTTP_REFERER header should be sent here.
+    # +permalink+::
+    #   the permanent location of the entry the comment was submitted to.
+    # +comment_type+::
+    #   may be blank, comment, trackback, pingback, or a made up value like
+    #   "registration".
+    # +comment_author+::
+    #   submitted name with the comment
+    # +comment_author_email+::
+    #   submitted email address
+    # +comment_author_url+::
+    #   commenter URL
+    # +comment_content+::
+    #   the content that was submitted
+    # Other server enviroment variables::
+    #   In PHP there is an array of enviroment variables called <tt>_SERVER</tt>
+    #   which contains information about the web server itself as well as a
+    #   key/value for every HTTP header sent with the request. This data is
+    #   highly useful to Akismet as how the submited content interacts with
+    #   the server can be very telling, so please include as much information
+    #   as possible.
+    def call_akismet(akismet_function, options = {})
+      http_post(
+        Net::HTTP.new([self.options[:api_key], self.class.host].join('.'), options[:proxy_host], options[:proxy_port]),
+        akismet_function,
+        options.update(:blog => self.options[:blog]).to_query
+      )
+    end
+
+    # Call to check and verify your API key. You may then call the
+    # <tt>verified?</tt> method to see if your key has been validated
+    def verify_api_key
+      return :false if invalid_options?
+      value = http_post(
+        Net::HTTP.new(self.class.host, self.class.port, options[:proxy_host], options[:proxy_port]),
+        'verify-key',
+        {
+          :key  => self.options[:api_key],
+          :blog => self.options[:blog]
+        }.to_query
+      )
+      self.verified_key = (value == 'valid') ? true : :false
+    end
+
+    def http_post(http, action, data)
+      resp = http.post(self.url(action), data, self.class.standard_headers)
+      log_request(self.url(action), data, resp)
+      resp.body
+    end
+
+    def url(action)
+      "/1.1/#{action}"
+    end
+
+    private
+
+    attr_accessor :verified_key
+
+  end
+end

data/lib/viking/base.rb

@@ -0,0 +1,74 @@
+module Viking
+  class Base
+
+    attr_accessor :options
+
+    def initialize(options = {})
+      self.options = options
+    end
+
+    def verified?
+    end
+
+    def check_article(options = {})
+    end
+
+    def check_comment(options = {})
+    end
+
+    def mark_as_spam(options = {})
+    end
+
+    def mark_as_ham(options = {})
+    end
+
+    # Automatically determines whether to mark as spam or ham depending on a
+    # boolean switch, +is_spam+. The post will be marked as spam when
+    # +is_spam+ is +true+. The post will be marked as ham if +is_spam+ is
+    # +false+.
+    #
+    # ==== Arguments
+    # +is_spam+ <Boolean>::
+    #   determines whether to mark a post as spam or ham -- spam when true,
+    #   ham when false
+    #
+    # +options+ <Hash>::
+    #   any options either +mark_as_spam+ or +mark_as_ham+ accepts
+    def mark_as_spam_or_ham(is_spam, options = {})
+      is_spam ? mark_as_spam(options) : mark_as_ham(options)
+    end
+
+    def stats
+    end
+
+    def logger
+      Viking.logger
+    end
+
+    def self.logger
+      Viking.logger
+    end
+
+    # Checks to ensure that the minimum number of +options+ have been provided
+    # to make a call to the spam protection service.
+    #
+    # Required options include:
+    # * +api_key+
+    # * +blog+
+    #
+    # See the module for your desired spam protection service for details on
+    # the format of these options.
+    def invalid_options?
+      self.options[:api_key].nil? || self.options[:blog].nil?
+    end
+
+    protected
+
+    def log_request(url, data, response)
+      return unless logger
+      logger.info("[#{self.class.name}] POST '%s' with %s" % [url, data])
+      logger.debug(">> #{response.body.inspect}")
+    end
+
+  end
+end