the_viking 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61b5ca2605b4bc43665fdafcf0cde34cb65f3ca5
+  data.tar.gz: 7774d1f91ba3dfd013d422d267a53b7268bd5c10
+SHA512:
+  metadata.gz: 04156c163c1414dc988c6352aedbcbd5e8c769db9ba8dc6b08e9e61971820c0fceffd66e9f0c61ae56a0e7b519fa7c2b586b217f770ceedbe2f4d4fa58396bc3
+  data.tar.gz: 2e8f84c1b424326948e7ea418a944503d28c8d589db7d3a26d4f73976f0c7ff09a1a37db7624af2ed52e18252a660c5ee11619cb9a787646c70ceebb7b69cbb3

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - 1.8.7
+  - ree

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,84 @@
+### TheViking 1.0
+
+Akismet anti-spam service for Ruby and Rails
+
+====
+
+1. TheViking - **is repack** of [Viking gem](https://github.com/dimelo/viking) without support of Defensio anti-spam service
+2. [Viking gem](https://github.com/dimelo/viking) is a fork of [Vikinggem](https://rubygems.org/gems/vikinggem). Bug fix and new feature for this gem should be place here.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+  gem 'the_viking'
+```
+
+And then execute:
+
+```sh
+  bundle
+```
+
+Or install it yourself as:
+
+```sh
+gem install the_viking
+```
+
+### Usage
+
+```ruby
+  @vik = TheViking::Akismet.new(api_key: '1234', blog: 'http://foo.com')
+```
+
+### Spam or ham ?
+
+```ruby
+  @vik.check_comment(
+    user_ip: '111.222.333.444',
+    user_agent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:33.0) Gecko/20100101 Firefox/33.0',
+    comment_author: 'Spammer Bot',
+    comment_author_email: 'spam@spam-server.com',
+    comment_content: 'Hello! <a href='http://viagra-for-u.xxx'>I am spammer! Click it!</a>'
+  )
+
+  # additional options
+  #
+  # referrer
+  # comment_author_url
+  # permalink - url of commented page
+  # comment_type - may be blank, comment, trackback, pingback, or a made up value like
+```
+
+## History
+
+### TheViking 1.0.0
+
+4 dec 2015, repack by github.com/the-teacher
+
+### 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,7 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/gem_version.rb

@@ -0,0 +1,3 @@
+module TheViking
+  VERSION = "1.0.0"
+end

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/the_viking.rb

@@ -0,0 +1,80 @@
+require "core_ext/object"
+require "core_ext/transformations"
+require "the_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 TheViking 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:
+#
+#   TheViking.default_engine = 'akismet'
+#   TheViking.connect_options = { :api_key => '1234abc' }
+#
+# From this point out, TheViking should have everything it needs to access the
+# service of your choice. Merely call methods on your service of choice as
+# documented. For instance:
+#
+#   TheViking.mark_as_spam(:signaturs => "1234abc")
+module TheViking
+  class Error < StandardError; end
+
+  autoload :Akismet, 'the_viking/akismet'
+
+  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)
+      engine = engine.to_s
+      if !engine.empty?
+        TheViking.const_get(engine.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 "the_viking/base"

data/lib/the_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 TheViking
+  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'   => "TheViking (Ruby Gem) v#{TheViking::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/the_viking/base.rb

@@ -0,0 +1,74 @@
+module TheViking
+  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
+      TheViking.logger
+    end
+
+    def self.logger
+      TheViking.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

data/lib/the_viking/version.rb

@@ -0,0 +1 @@
+require_relative '../../gem_version'

data/spec/core_ext/object_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Object do
+
+  describe '#to_param' do
+
+    it 'should return a representation of an object' do
+      1.to_param.should == '1'
+    end
+
+  end
+
+  describe '#to_query' do
+
+    it 'should CGI escape an object and its associated key' do
+      'foo'.to_query('bar').should == 'bar=foo'
+    end
+
+  end
+
+end

data/spec/core_ext/transformations_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Hash do
+
+  describe '#symbolize_keys' do
+
+    it 'should convert all keys to symbols' do
+      { 'foo' => 'bar', :baz => 1 }.symbolize_keys.should == { :foo => 'bar', :baz => 1 }
+    end
+
+    it 'should handle bad keys' do
+      { nil => 'bar' }.symbolize_keys[nil].should == 'bar'
+    end
+
+  end
+
+  describe '#dasherize_keys' do
+
+    it 'should convert all all underscores in keys to dashes' do
+      { 'foo_bar' => 'baz' }.dasherize_keys.should == { 'foo-bar' => 'baz' }
+    end
+
+  end
+
+  describe '#to_query' do
+
+    it 'should convert to a valid URI query' do
+      { :foo => 'baz', :bar => 1 }.to_query.should == 'bar=1&foo=baz'
+    end
+
+  end
+
+end
+
+describe Array, '#to_query' do
+
+  it 'should convert to a valid URI query' do
+    [:foo, :bar].to_query('baz').should == 'baz%5B%5D=foo&baz%5B%5D=bar'
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'rspec'
+
+require 'viking'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end
+
+# See http://blog.jayfields.com/2007/11/ruby-testing-private-methods.html
+class Class
+  def publicize_methods(instance=nil)
+    saved_private_instance_methods = self.private_instance_methods
+    self.class_eval { public *saved_private_instance_methods }
+    yield(instance)
+  ensure
+    self.class_eval { private *saved_private_instance_methods }
+  end
+end
+
+##
+# rSpec Hash additions.
+#
+# From
+#   * http://wincent.com/knowledge-base/Fixtures_considered_harmful%3F
+#   * Neil Rahilly
+class Hash
+  ##
+  # Filter keys out of a Hash.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.except(:a)
+  #   => { :b => 2, :c => 3 }
+  def except(*keys)
+    self.reject { |k,v| keys.include?(k || k.to_sym) }
+  end
+
+  ##
+  # Override some keys.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.with(:a => 4)
+  #   => { :a => 4, :b => 2, :c => 3 }
+  def with(overrides = {})
+    self.merge overrides
+  end
+
+  ##
+  # Returns a Hash with only the pairs identified by +keys+.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.only(:a)
+  #   => { :a => 1 }
+  def only(*keys)
+    self.reject { |k,v| !keys.include?(k || k.to_sym) }
+  end
+end

data/spec/viking/akismet_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Viking::Akismet do
+
+  def valid_options
+    {
+      :blog => 'foo',
+      :api_key => 'bar'
+    }
+  end
+
+  let(:akismet) { Viking.connect('akismet', valid_options) }
+  let(:http) { Net::HTTP.new('url') }
+
+  before do
+    Net::HTTP.stub(:new).and_return(http)
+  end
+
+  describe ".new" do
+
+    it "should not have a verified key when initialized" do
+      akismet.send(:verified_key).should be_false
+    end
+
+  end
+
+  describe '.url' do
+
+    it 'should return an URL for a request' do
+      Viking::Akismet.url('bar').should == '/1.1/bar'
+    end
+
+  end
+
+  describe "#verified?" do
+
+    it "should be verified when all parameters are provided" do
+      http.should_receive(:post).and_return(stub("response", :body => "valid"))
+
+      akismet.should be_verified # #verified? is called twice to make sure #verify_api_key is not called twice
+      akismet.should be_verified
+    end
+
+    it "should not be verified if Akismet doesn't validate" do
+      http.should_receive(:post).and_return(stub("response", :body => "invalid"))
+      akismet.should_not be_verified
+    end
+
+    it "should not be verified if its options are invalid" do
+      Viking.connect('akismet', {}).should_not be_verified
+    end
+
+  end
+
+  describe "#check_comment" do
+
+    it "should be false if the instance has invalid options" do
+      Viking.connect('akismet', {}).check_comment({}).should be_false
+    end
+
+    it "should be spam when the response body isn't a valid response" do
+      http.should_receive(:post).and_return(stub("response", :body => "invalid"))
+      akismet.check_comment(:user_ip => "127.0.0.1", :user_agent => "Mozilla").should == { :message => "invalid", :spam => true }
+    end
+
+    it "should not be spam when the response body is a valid response" do
+      http.should_receive(:post).and_return(stub("response", :body => "false"))
+      akismet.check_comment(:user_ip => "127.0.0.1", :user_agent => "Mozilla").should == { :message => "false", :spam => false }
+    end
+
+  end
+
+  describe "#mark_as_spam" do
+
+    it 'should be false if the instance has invalid options' do
+      Viking.connect('akismet', {}).mark_as_spam({}).should be_false
+    end
+
+    it 'should return the response body' do
+      http.should_receive(:post).and_return(stub('response', :body => "foo"))
+      akismet.mark_as_spam({}).should == { :message => "foo" }
+    end
+
+  end
+
+  describe '#mark_as_ham' do
+
+    it 'should be false if the instance has invalid options' do
+      Viking.connect('akismet', {}).mark_as_ham({}).should be_false
+    end
+
+    it 'should return the response body' do
+      http.should_receive(:post).and_return(stub('response', :body => "foo"))
+      akismet.mark_as_ham({}).should == { :message => "foo" }
+    end
+
+  end
+
+end

data/spec/viking/base_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Viking::Base do
+
+  def valid_base_options
+    {
+      :api_key => "1234abc",
+      :blog    => "wiki.mysite.com"
+    }
+  end
+
+  let(:base) { Viking::Base.new({}) }
+
+  describe "#mark_as_spam_or_ham" do
+
+    it "should mark as spam when is_spam is true" do
+      base.should_receive(:mark_as_spam).and_return("I will be spam")
+      base.mark_as_spam_or_ham(true, {}).should == "I will be spam"
+    end
+
+    it "should mark as ham when is_spam is false" do
+      base.should_receive(:mark_as_ham).and_return("I will be ham")
+      base.mark_as_spam_or_ham(false, {}).should == "I will be ham"
+    end
+
+  end
+
+  describe "#invalid_options?" do
+
+    it "should be false if the required options are non-nil" do
+      base.options = valid_base_options
+      base.should_not be_invalid_options
+    end
+
+    it "should be true if the options don't include an API key" do
+      base.options = valid_base_options.except(:api_key)
+      base.should be_invalid_options
+    end
+
+    it "should be true if the options don't include a blog address" do
+      base.options = valid_base_options.except(:blog)
+      base.should be_invalid_options
+    end
+
+  end
+
+end

data/spec/viking/viking_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Viking do
+
+  it { should respond_to :logger }
+  it { should respond_to :default_engine }
+  it { should respond_to :connect_options }
+  it { should respond_to :default_instance }
+
+  describe ".connect" do
+    it "should load the Akismet engine" do
+      Viking.connect('akismet', {}).should be_a_kind_of(Viking::Akismet)
+    end
+
+    it "should load the Akismet engine with Symbol" do
+      Viking.connect(:akismet, {}).should be_a_kind_of(Viking::Akismet)
+    end
+
+    it "should be nil if the engine is nil" do
+      Viking.connect(nil, {}).should be_nil
+    end
+
+    it "should be nil if the engine is blank" do
+      Viking.connect('', {}).should be_nil
+    end
+
+  end
+
+  describe ".enabled?" do
+    it "should not be enabled if a default instance has not be initialized" do
+      Viking.should_not be_enabled
+    end
+  end
+
+end

data/the_viking.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'the_viking/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "the_viking"
+  gem.version       = TheViking::VERSION
+  gem.authors       = ["Risk Danger Olson", "James Herdman", "Pierre-Louis Gottfrois", "Ilya N. Zykin"]
+  gem.email         = ["ilya-zykin@ya.ru", "pl.gottfrois@dimelo.com"]
+  gem.description   = %q{TheViking is repack of Viking gem}
+  gem.summary       = %q{Akismet anti-spam service for Ruby and Rails}
+  gem.homepage      = "https://github.com/the-teacher/the_viking"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency(%q{rspec}, ['~> 2.12.0'])
+  gem.add_development_dependency(%q{rake})
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: the_viking
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Risk Danger Olson
+- James Herdman
+- Pierre-Louis Gottfrois
+- Ilya N. Zykin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: TheViking is repack of Viking gem
+email:
+- ilya-zykin@ya.ru
+- pl.gottfrois@dimelo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gem_version.rb
+- lib/core_ext/object.rb
+- lib/core_ext/transformations.rb
+- lib/the_viking.rb
+- lib/the_viking/akismet.rb
+- lib/the_viking/base.rb
+- lib/the_viking/version.rb
+- spec/core_ext/object_spec.rb
+- spec/core_ext/transformations_spec.rb
+- spec/spec_helper.rb
+- spec/viking/akismet_spec.rb
+- spec/viking/base_spec.rb
+- spec/viking/viking_spec.rb
+- the_viking.gemspec
+homepage: https://github.com/the-teacher/the_viking
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Akismet anti-spam service for Ruby and Rails
+test_files:
+- spec/core_ext/object_spec.rb
+- spec/core_ext/transformations_spec.rb
+- spec/spec_helper.rb
+- spec/viking/akismet_spec.rb
+- spec/viking/base_spec.rb
+- spec/viking/viking_spec.rb