recaptcha 0.2.3 → 0.3.0

data/README.rdoc

@@ -7,19 +7,25 @@ Info::      http://ambethia.com/recaptcha
 Git::       http://github.com/ambethia/recaptcha/tree/master
 Bugs::      http://github.com/ambethia/recaptcha/issues
 
-This plugin adds helpers for the {reCAPTCHA API}[http://recaptcha.net]. In your views you can use
-the +recaptcha_tags+ method to embed the needed javascript, and you can validate in your controllers
-with +verify_recaptcha+.
+This plugin adds helpers for the {reCAPTCHA API}[http://recaptcha.net]. In your
+views you can use the +recaptcha_tags+ method to embed the needed javascript,
+and you can validate in your controllers with +verify_recaptcha+.
 
-You'll want to add your public and private API keys in the environment variables +RECAPTCHA_PUBLIC_KEY+
-and +RECAPTCHA_PRIVATE_KEY+, respectively. You could also specify them in <tt>config/environment.rb</tt> if you
-are so inclined (see below). Exceptions will be raised if you call these methods and the keys can't be found.
+Beforehand you need to configure Recaptcha with your custom private and public
+key. You may find detailed examples below. Exceptions will be raised if you
+call these methods and the keys can't be found.
+
+== About this fork
+
+This fork tries to introduces a more convenient way to configure recaptcha's
+settings. The API will be inspired by {Thoughtbot's
+Hoptoad}[http://robots.thoughtbot.com/post/344833329/mygem-configure-block].
 
 == Rails Installation
 
 reCAPTCHA for Rails can be installed as a gem:
 
-  config.gem "ambethia-recaptcha", :lib => "recaptcha/rails", :source => "http://gems.github.com"
+  config.gem "recaptcha", :lib => "recaptcha/rails"
 
 Or, as a standard rails plugin:
 
@@ -35,27 +41,43 @@ Initial Merb compatability funded by ALM Labs.
 
 == Setting up your API Keys
 
-There are two ways to setup your reCAPTCHA API keys once you {obtain}[http://recaptcha.net/whyrecaptcha.html]
-a pair. You can pass in your keys as options at runtime, for example:
+There are multiple ways to setup your reCAPTCHA API key once you
+{obtain}[http://recaptcha.net/whyrecaptcha.html] a pair.
 
-  recaptcha_tags :public_key => '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+=== Recaptcha.configure
 
-and later,
+You may use the block style configuration. The following code could be placed
+into a +config/initializers/recaptcha.rb+ when used in a Rails project.
 
-  verify_recaptcha :private_key => '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+  Recaptcha.configure do |config|
+    config.public_key  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+    config.private_key = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+  end
+
+This way, you may also set additional options to fit recaptcha into your
+deployment environment.
 
+=== Shell environment
 
-Or, preferably, you can keep your keys out of your code base by exporting the environment variables
-mentioned earlier. You might do this in the .profile/rc, or equivalent for the user running your
-application:
+Or, you can keep your keys out of your code base by exporting the following
+environment variables. You might do this in the .profile/rc, or equivalent for
+the user running your application:
 
   export RECAPTCHA_PUBLIC_KEY  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
   export RECAPTCHA_PRIVATE_KEY = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
 
-If that's not your thing, and dropping things into <tt>config/environment.rb</tt> is, you can just do:
+=== Per call
+
+You can also pass in your keys as options at runtime, for example:
+
+  recaptcha_tags :public_key => '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+
+and later,
+
+  verify_recaptcha :private_key => '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
 
-  ENV['RECAPTCHA_PUBLIC_KEY']  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
-  ENV['RECAPTCHA_PRIVATE_KEY'] = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+This option might be useful, if the same code base is used for multiple
+reCAPTCHA setups.
 
 == +recaptcha_tags+
 
@@ -81,12 +103,13 @@ error will be added to the object for you to use.
 Some of the options available:
 
 <tt>:model</tt>::       Model to set errors
+<tt>:attribute</tt>::   Model attribute to receive errors (default :base)
 <tt>:message</tt>::     Custom error message
 <tt>:private_key</tt>:: Your private API key, takes precedence over the ENV variable (default +nil+).
 <tt>:timeout</tt>::     The number of seconds to wait for reCAPTCHA servers before give up. (default +3+)
 
   respond_to do |format|
-    if verify_recaptcha(:model => @post, :message => 'Oh! It's error with reCAPTCHA!') && @post.save
+    if verify_recaptcha(:model => @post, :message => "Oh! It's error with reCAPTCHA!") && @post.save
       # ...
     else
       # ...

data/Rakefile

@@ -10,6 +10,8 @@ begin
     gem.authors        = ["Jason L. Perry"]
     gem.email          = "jasper@ambethia.com"
     gem.files.reject! { |fn| fn.include? ".gitignore" }
+    gem.add_development_dependency "mocha"
+    gem.add_development_dependency "activesupport"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.0

data/lib/recaptcha.rb

@@ -1,3 +1,4 @@
+require 'recaptcha/configuration'
 require 'recaptcha/client_helper'
 require 'recaptcha/verify'
 
@@ -12,12 +13,28 @@ module Recaptcha
   end
 
   
-  RECAPTCHA_API_SERVER        = 'http://api.recaptcha.net';
-  RECAPTCHA_API_SECURE_SERVER = 'https://api-secure.recaptcha.net';
-  RECAPTCHA_VERIFY_SERVER     = 'api-verify.recaptcha.net';
+  RECAPTCHA_API_SERVER_URL        = 'http://www.google.com/recaptcha/api'
+  RECAPTCHA_API_SECURE_SERVER_URL = 'https://www.google.com/recaptcha/api'
+  RECAPTCHA_VERIFY_URL            = 'http://www.google.com/recaptcha/api'
 
   SKIP_VERIFY_ENV = ['test', 'cucumber']
 
+  # Gives access to the current Configuration.
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Allows easy setting of multiple configuration options. See Configuration
+  # for all available options.
+  #--
+  # The temp assignment is only used to get a nicer rdoc. Feel free to remove
+  # this hack.
+  #++
+  def self.configure
+    config = configuration
+    yield(config)
+  end
+
   class RecaptchaError < StandardError
   end
-end
+end

data/lib/recaptcha/client_helper.rb

@@ -1,13 +1,13 @@
 module Recaptcha
   module ClientHelper
     # Your public API can be specified in the +options+ hash or preferably
-    # the environment variable +RECAPTCHA_PUBLIC_KEY+.
+    # using the Configuration.
     def recaptcha_tags(options = {})
       # Default options
-      key   = options[:public_key] ||= ENV['RECAPTCHA_PUBLIC_KEY']
+      key   = options[:public_key] ||= Recaptcha.configuration.public_key
       raise RecaptchaError, "No public key specified." unless key
       error = options[:error] ||= (defined? flash ? flash[:recaptcha_error] : "")
-      uri   = options[:ssl] ? RECAPTCHA_API_SECURE_SERVER : RECAPTCHA_API_SERVER
+      uri   = Recaptcha.configuration.api_server_url(options[:ssl])
       html  = ""
       if options[:display]
         html << %{<script type="text/javascript">\n}
@@ -22,21 +22,21 @@ module Recaptcha
         html << %{</script>\n}
       else
         html << %{<script type="text/javascript" src="#{uri}/challenge?k=#{key}}
-        html << %{#{error ? "&error=#{CGI::escape(error)}" : ""}"></script>\n}
+        html << %{#{error ? "&amp;error=#{CGI::escape(error)}" : ""}"></script>\n}
         unless options[:noscript] == false
           html << %{<noscript>\n  }
           html << %{<iframe src="#{uri}/noscript?k=#{key}" }
           html << %{height="#{options[:iframe_height] ||= 300}" }
           html << %{width="#{options[:iframe_width]   ||= 500}" }
-          html << %{frameborder="0"></iframe><br/>\n  }
+          html << %{style="border:none;"></iframe><br/>\n  }
           html << %{<textarea name="recaptcha_challenge_field" }
           html << %{rows="#{options[:textarea_rows] ||= 3}" }
           html << %{cols="#{options[:textarea_cols] ||= 40}"></textarea>\n  }
-          html << %{<input type="hidden" name="recaptcha_response_field" value="manual_challenge">}
+          html << %{<input type="hidden" name="recaptcha_response_field" value="manual_challenge"/>}
           html << %{</noscript>\n}
         end
       end
-      return html
+      return html.html_safe
     end # recaptcha_tags
   end # ClientHelper
 end # Recaptcha

data/lib/recaptcha/configuration.rb

@@ -0,0 +1,52 @@
+module Recaptcha
+  # This class enables detailed configuration of the recaptcha services.
+  # 
+  # By calling
+  #
+  #   Recaptcha.configuration # => instance of Recaptcha::Configuration
+  #
+  # or
+  #   Recaptcha.configure do |config|
+  #     config # => instance of Recaptcha::Configuration
+  #   end
+  #
+  # you are able to perform configuration updates.
+  #
+  # Your are able to customize all attributes listed below. All values have
+  # sensitive default and will very likely not need to be changed. 
+  #
+  # Please note that the public and private key for the reCAPTCHA API Access
+  # have no useful default value. The keys may be set via the Shell enviroment
+  # or using this configuration. Settings within this configuration always take
+  # precedence.
+  #
+  # Setting the keys with this Configuration
+  #
+  #   Recaptcha.configure do |config|
+  #     config.public_key  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+  #     config.private_key = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+  #   end
+  #
+  class Configuration
+    attr_accessor :nonssl_api_server_url,
+                  :ssl_api_server_url,
+                  :verify_url,
+                  :skip_verify_env,
+                  :private_key,
+                  :public_key
+
+    def initialize #:nodoc:
+      @nonssl_api_server_url = RECAPTCHA_API_SERVER_URL
+      @ssl_api_server_url    = RECAPTCHA_API_SECURE_SERVER_URL
+      @verify_url            = RECAPTCHA_VERIFY_URL
+      @skip_verify_env       = SKIP_VERIFY_ENV
+
+      @private_key           = ENV['RECAPTCHA_PRIVATE_KEY']
+      @public_key            = ENV['RECAPTCHA_PUBLIC_KEY']
+    end
+
+    def api_server_url(ssl = false) #:nodoc:
+      ssl ? ssl_api_server_url : nonssl_api_server_url
+    end
+  end
+end

data/lib/recaptcha/verify.rb

@@ -1,22 +1,23 @@
 module Recaptcha
   module Verify
     # Your private API can be specified in the +options+ hash or preferably
-    # the environment variable +RECAPTCHA_PUBLIC_KEY+.
+    # using the Configuration.
     def verify_recaptcha(options = {})
       if !options.is_a? Hash
         options = {:model => options}
       end
       
       env = options[:env] || ENV['RAILS_ENV']
-      return true if SKIP_VERIFY_ENV.include? env
+      return true if Recaptcha.configuration.skip_verify_env.include? env
       model = options[:model]
-      private_key = options[:private_key] || ENV['RECAPTCHA_PRIVATE_KEY']
+      attribute = options[:attribute] || :base
+      private_key = options[:private_key] || Recaptcha.configuration.private_key
       raise RecaptchaError, "No private key specified." unless private_key
       
       begin
         recaptcha = nil
         Timeout::timeout(options[:timeout] || 3) do
-          recaptcha = Net::HTTP.post_form URI.parse("http://#{RECAPTCHA_VERIFY_SERVER}/verify"), {
+          recaptcha = Net::HTTP.post_form URI.parse(Recaptcha.configuration.verify_url), {
             "privatekey" => private_key,
             "remoteip"   => request.remote_ip,
             "challenge"  => params[:recaptcha_challenge_field],
@@ -28,7 +29,7 @@ module Recaptcha
           flash[:recaptcha_error] = error
           if model
             model.valid?
-            model.errors.add :base, options[:message] || "Word verification response is incorrect, please try again."
+            model.errors.add attribute, options[:message] || "Word verification response is incorrect, please try again."
           end
           return false
         else
@@ -39,7 +40,7 @@ module Recaptcha
         flash[:recaptcha_error] = "recaptcha-not-reachable"
         if model
           model.valid?
-          model.errors.add :base, options[:message] || "Oops, we failed to validate your word verification response. Please try again."
+          model.errors.add attribute, options[:message] || "Oops, we failed to validate your word verification response. Please try again."
         end
         return false
       rescue Exception => e

data/recaptcha.gemspec

@@ -1,56 +1,62 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{recaptcha}
-  s.version = "0.2.3"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jason L. Perry"]
-  s.date = %q{2009-10-23}
+  s.date = %q{2010-12-16}
   s.description = %q{This plugin adds helpers for the reCAPTCHA API }
   s.email = %q{jasper@ambethia.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+    "README.rdoc"
   ]
   s.files = [
     "CHANGELOG",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "init.rb",
-     "lib/recaptcha.rb",
-     "lib/recaptcha/client_helper.rb",
-     "lib/recaptcha/merb.rb",
-     "lib/recaptcha/rails.rb",
-     "lib/recaptcha/verify.rb",
-     "recaptcha.gemspec",
-     "tasks/recaptcha_tasks.rake",
-     "test/recaptcha_test.rb",
-     "test/verify_recaptcha_test.rb"
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "init.rb",
+    "lib/recaptcha.rb",
+    "lib/recaptcha/client_helper.rb",
+    "lib/recaptcha/configuration.rb",
+    "lib/recaptcha/merb.rb",
+    "lib/recaptcha/rails.rb",
+    "lib/recaptcha/verify.rb",
+    "recaptcha.gemspec",
+    "tasks/recaptcha_tasks.rake",
+    "test/recaptcha_test.rb",
+    "test/verify_recaptcha_test.rb"
   ]
   s.homepage = %q{http://ambethia.com/recaptcha}
-  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Helpers for the reCAPTCHA API}
   s.test_files = [
     "test/recaptcha_test.rb",
-     "test/verify_recaptcha_test.rb"
+    "test/verify_recaptcha_test.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<activesupport>, [">= 0"])
     else
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
     end
   else
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
   end
 end
 

data/test/recaptcha_test.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'cgi'
-require File.dirname(__FILE__) + '/../lib/recaptcha'
+require File.dirname(File.expand_path(__FILE__)) + '/../lib/recaptcha'
 
 class RecaptchaClientHelperTest < Test::Unit::TestCase
   include Recaptcha
@@ -11,17 +11,19 @@ class RecaptchaClientHelperTest < Test::Unit::TestCase
 
   def setup
     @session = {}
-    ENV['RECAPTCHA_PUBLIC_KEY']  = '0000000000000000000000000000000000000000'
-    ENV['RECAPTCHA_PRIVATE_KEY'] = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+    Recaptcha.configure do |config|
+      config.public_key = '0000000000000000000000000000000000000000'
+      config.private_key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+    end
   end
     
   def test_recaptcha_tags
     # Might as well match something...
-    assert_match /http:\/\/api.recaptcha.net/, recaptcha_tags 
+    assert_match /http:\/\/www.google.com\/recaptcha\/api\/challenge/, recaptcha_tags
   end
   
   def test_recaptcha_tags_with_ssl
-    assert_match /https:\/\/api-secure.recaptcha.net/, recaptcha_tags(:ssl => true)
+    assert_match /https:\/\/www.google.com\/recaptcha\/api\/challenge/, recaptcha_tags(:ssl => true)
   end
 
   def test_recaptcha_tags_without_noscript
@@ -30,7 +32,7 @@ class RecaptchaClientHelperTest < Test::Unit::TestCase
   
   def test_should_raise_exception_without_public_key
     assert_raise RecaptchaError do
-      ENV['RECAPTCHA_PUBLIC_KEY'] = nil
+      Recaptcha.configuration.public_key = nil
       recaptcha_tags
     end
   end

data/test/verify_recaptcha_test.rb

@@ -1,30 +1,29 @@
 require 'test/unit'
-require 'rails/version' # For getting the rails version constants
-require 'active_support/vendor' # For loading I18n
+require 'active_support/core_ext/string'
+require 'rubygems'
 require 'mocha'
 require 'net/http'
-require File.dirname(__FILE__) + '/../lib/recaptcha'
+require File.dirname(File.expand_path(__FILE__)) + '/../lib/recaptcha'
 
 class RecaptchaVerifyTest < Test::Unit::TestCase
   def setup
-
-    ENV['RECAPTCHA_PRIVATE_KEY'] = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+    Recaptcha.configuration.private_key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
     @controller = TestController.new
     @controller.request = stub(:remote_ip => "1.1.1.1")
     @controller.params = {:recaptcha_challenge_field => "challenge", :recaptcha_response_field => "response"}
 
     @expected_post_data = {}
-    @expected_post_data["privatekey"] = ENV['RECAPTCHA_PRIVATE_KEY']
+    @expected_post_data["privatekey"] = Recaptcha.configuration.private_key
     @expected_post_data["remoteip"]   = @controller.request.remote_ip
     @expected_post_data["challenge"]  = "challenge"
     @expected_post_data["response"]   = "response"
     
-    @expected_uri = URI.parse("http://#{Recaptcha::RECAPTCHA_VERIFY_SERVER}/verify")
+    @expected_uri = URI.parse(Recaptcha.configuration.verify_url)
   end
 
   def test_should_raise_exception_without_private_key
     assert_raise Recaptcha::RecaptchaError do
-      ENV['RECAPTCHA_PRIVATE_KEY'] = nil
+      Recaptcha.configuration.private_key = nil
       @controller.verify_recaptcha
     end
   end
@@ -33,52 +32,52 @@ class RecaptchaVerifyTest < Test::Unit::TestCase
     expect_http_post(response_with_body("false\ninvalid-site-private-key"))
 
     assert !@controller.verify_recaptcha    
-    assert_equal "invalid-site-private-key", @controller.session[:recaptcha_error]
+    assert_equal "invalid-site-private-key", @controller.flash[:recaptcha_error]
   end
   
   def test_returns_true_on_success
-    @controller.session[:recaptcha_error] = "previous error that should be cleared"    
+    @controller.flash[:recaptcha_error] = "previous error that should be cleared" 
     expect_http_post(response_with_body("true\n"))
 
     assert @controller.verify_recaptcha
-    assert_nil @controller.session[:recaptcha_error]
+    assert_nil @controller.flash[:recaptcha_error]
   end
   
   def test_errors_should_be_added_to_model
     expect_http_post(response_with_body("false\nbad-news"))
     
     errors = mock
-    errors.expects(:add).with(:base, "Captcha response is incorrect, please try again.")
+    errors.expects(:add).with(:base, "Word verification response is incorrect, please try again.")
     model = mock(:valid? => false, :errors => errors)
 
     assert !@controller.verify_recaptcha(:model => model)
-    assert_equal "bad-news", @controller.session[:recaptcha_error]
+    assert_equal "bad-news", @controller.flash[:recaptcha_error]
   end
 
   def test_returns_true_on_success_with_optional_key
-    @controller.session[:recaptcha_error] = "previous error that should be cleared"
+    @controller.flash[:recaptcha_error] = "previous error that should be cleared"
     # reset private key
     @expected_post_data["privatekey"] =  'ADIFFERENTPRIVATEKEYXXXXXXXXXXXXXX'
     expect_http_post(response_with_body("true\n"))
 
     assert @controller.verify_recaptcha(:private_key => 'ADIFFERENTPRIVATEKEYXXXXXXXXXXXXXX')
-    assert_nil @controller.session[:recaptcha_error]
+    assert_nil @controller.flash[:recaptcha_error]
   end
 
   def test_timeout
     expect_http_post(Timeout::Error, :exception => true)
     assert !@controller.verify_recaptcha()
-    assert_equal "recaptcha-not-reachable", @controller.session[:recaptcha_error]
+    assert_equal "recaptcha-not-reachable", @controller.flash[:recaptcha_error]
   end
 
   private
 
   class TestController
     include Recaptcha::Verify
-    attr_accessor :request, :params, :session
+    attr_accessor :request, :params, :flash
     
     def initialize
-      @session = {}
+      @flash = {}
     end
   end
   

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: recaptcha
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jason L. Perry
@@ -9,10 +14,35 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-23 00:00:00 -04:00
+date: 2010-12-16 00:00:00 -05:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: "This plugin adds helpers for the reCAPTCHA API "
 email: jasper@ambethia.com
 executables: []
@@ -31,6 +61,7 @@ files:
 - init.rb
 - lib/recaptcha.rb
 - lib/recaptcha/client_helper.rb
+- lib/recaptcha/configuration.rb
 - lib/recaptcha/merb.rb
 - lib/recaptcha/rails.rb
 - lib/recaptcha/verify.rb
@@ -43,26 +74,30 @@ homepage: http://ambethia.com/recaptcha
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Helpers for the reCAPTCHA API