recaptcha 0.3.6 → 5.6.0

data/Rakefile

@@ -1,9 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new :test do |test|
-  test.libs << "lib"
-  test.pattern = "test/*_test.rb"
-end
-
-task :default => :test

data/init.rb

@@ -1,5 +0,0 @@
-# Rails plugin initialization.
-# You can also install it as a gem:
-#   config.gem "ambethia-recaptcha", :lib => "recaptcha/rails", :source => "http://gems.github.com"
-
-require 'recaptcha/rails'

data/lib/recaptcha/client_helper.rb

@@ -1,69 +0,0 @@
-module Recaptcha
-  module ClientHelper
-    # Your public API can be specified in the +options+ hash or preferably
-    # using the Configuration.
-    def recaptcha_tags(options = {})
-      # Default options
-      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   = Recaptcha.configuration.api_server_url(options[:ssl])
-      lang  = options[:display] && options[:display][:lang] ? options[:display][:lang].to_sym : ""
-      html  = ""
-      if options[:display]
-        html << %{<script type="text/javascript">\n}
-        html << %{  var RecaptchaOptions = #{hash_to_json(options[:display])};\n}
-        html << %{</script>\n}
-      end
-      if options[:ajax]
-        html << <<-EOS
-          <div id="dynamic_recaptcha"></div>
-          <script type="text/javascript">
-            var rc_script_tag = document.createElement('script'),
-                rc_init_func = function(){Recaptcha.create("#{key}", document.getElementById("dynamic_recaptcha")#{',RecaptchaOptions' if options[:display]});}
-            rc_script_tag.src = "#{uri}/js/recaptcha_ajax.js";
-            rc_script_tag.type = 'text/javascript';
-            rc_script_tag.onload = function(){rc_init_func.call();};
-            rc_script_tag.onreadystatechange = function(){
-              if (rc_script_tag.readyState == 'loaded' || rc_script_tag.readyState == 'complete') {rc_init_func.call();}
-            };
-            (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(rc_script_tag);
-          </script>
-        EOS
-      else
-        html << %{<script type="text/javascript" src="#{uri}/challenge?k=#{key}}
-        html << %{#{error ? "&amp;error=#{CGI::escape(error)}" : ""}}
-        html << %{#{lang ? "&amp;lang=#{lang}" : ""}"></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 << %{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 << %{</noscript>\n}
-        end
-      end
-      return (html.respond_to?(:html_safe) && html.html_safe) || html
-    end # recaptcha_tags
-
-    private
-
-    def hash_to_json(hash)
-      result = "{"
-      result << hash.map do |k, v|
-        if v.is_a?(Hash)
-          "\"#{k}\": #{hash_to_json(v)}"
-        elsif ! v.is_a?(String) || k.to_s == "callback"
-          "\"#{k}\": #{v}"
-        else
-          "\"#{k}\": \"#{v}\""
-        end
-      end.join(", ")
-      result << "}"
-    end
-  end # ClientHelper
-end # Recaptcha

data/lib/recaptcha/merb.rb

@@ -1,4 +0,0 @@
-require 'recaptcha'
-
-Merb::GlobalHelpers.send(:include, Recaptcha::ClientHelper)
-Merb::Controller.send(:include, Recaptcha::Verify)

data/lib/recaptcha/verify.rb

@@ -1,75 +0,0 @@
-require "uri"
-module Recaptcha
-  module Verify
-    # Your private API can be specified in the +options+ hash or preferably
-    # 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 Recaptcha.configuration.skip_verify_env.include? env
-      model = options[:model]
-      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
-        if(Recaptcha.configuration.proxy)
-          proxy_server = URI.parse(Recaptcha.configuration.proxy)
-          http = Net::HTTP::Proxy(proxy_server.host, proxy_server.port, proxy_server.user, proxy_server.password)
-        else
-          http = Net::HTTP
-        end
-
-        Timeout::timeout(options[:timeout] || 3) do
-          recaptcha = http.post_form(URI.parse(Recaptcha.configuration.verify_url), {
-            "privatekey" => private_key,
-            "remoteip"   => request.remote_ip,
-            "challenge"  => params[:recaptcha_challenge_field],
-            "response"   => params[:recaptcha_response_field]
-          })
-        end
-        answer, error = recaptcha.body.split.map { |s| s.chomp }
-        unless answer == 'true'
-          flash[:recaptcha_error] = if defined?(I18n)
-            I18n.translate("recaptcha.errors.#{error}", {:default => error})
-          else
-            error
-          end
-
-          if model
-            message = "Word verification response is incorrect, please try again."
-            message = I18n.translate('recaptcha.errors.verification_failed', {:default => message}) if defined?(I18n)
-            model.errors.add attribute, options[:message] || message
-          end
-          return false
-        else
-          flash.delete(:recaptcha_error)
-          return true
-        end
-      rescue Timeout::Error
-        if Recaptcha.configuration.handle_timeouts_gracefully
-          flash[:recaptcha_error] = if defined?(I18n)
-            I18n.translate('recaptcha.errors.recaptcha_unreachable', {:default => 'Recaptcha unreachable.'})
-          else
-            'Recaptcha unreachable.'
-          end
-
-          if model
-            message = "Oops, we failed to validate your word verification response. Please try again."
-            message = I18n.translate('recaptcha.errors.recaptcha_unreachable', :default => message) if defined?(I18n)
-            model.errors.add attribute, options[:message] || message
-          end
-          return false
-        else
-          raise RecaptchaError, "Recaptcha unreachable."
-        end
-      rescue Exception => e
-        raise RecaptchaError, e.message, e.backtrace
-      end
-    end # verify_recaptcha
-  end # Verify
-end # Recaptcha

data/recaptcha.gemspec

@@ -1,24 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "recaptcha/version"
-
-Gem::Specification.new do |s|
-  s.name        = "recaptcha"
-  s.version     = Recaptcha::VERSION
-  s.authors     = ["Jason L Perry"]
-  s.email       = ["jasper@ambethia.com"]
-  s.homepage    = "http://github.com/ambethia/recaptcha"
-  s.summary     = %q{Helpers for the reCAPTCHA API}
-  s.description = %q{This plugin adds helpers for the reCAPTCHA API}
-
-  s.rubyforge_project = "recaptcha"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ["lib"]
-
-  s.add_development_dependency "mocha"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "activesupport"
-  s.add_development_dependency "i18n"
-end

data/test/recaptcha_test.rb

@@ -1,62 +0,0 @@
-require 'test/unit'
-require 'cgi'
-require File.dirname(File.expand_path(__FILE__)) + '/../lib/recaptcha'
-
-class RecaptchaClientHelperTest < Test::Unit::TestCase
-  include Recaptcha
-  include Recaptcha::ClientHelper
-  include Recaptcha::Verify
-
-  attr_accessor :session
-
-  def setup
-    @session = {}
-    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 /"\/\/www.google.com\/recaptcha\/api\/challenge/, recaptcha_tags
-  end
-
-  def test_ssl_by_default
-    Recaptcha.configuration.use_ssl_by_default = true
-    assert_match /https:\/\/www.google.com\/recaptcha\/api\/challenge/, recaptcha_tags
-  end
-
-  def test_relative_protocol_by_default_without_ssl
-    Recaptcha.configuration.use_ssl_by_default = false
-    assert_match /\/\/www.google.com\/recaptcha\/api\/challenge/, recaptcha_tags(:ssl => false)
-  end
-
-  def test_recaptcha_tags_with_ssl
-    assert_match /https:\/\/www.google.com\/recaptcha\/api\/challenge/, recaptcha_tags(:ssl => true)
-  end
-
-  def test_recaptcha_tags_without_noscript
-    assert_no_match /noscript/, recaptcha_tags(:noscript => false)
-  end
-
-  def test_should_raise_exception_without_public_key
-    assert_raise RecaptchaError do
-      Recaptcha.configuration.public_key = nil
-      recaptcha_tags
-    end
-  end
-
-  def test_different_configuration_within_with_configuration_block
-    key = Recaptcha.with_configuration(:public_key => '12345') do
-      Recaptcha.configuration.public_key
-    end
-
-    assert_equal('12345', key)
-  end
-
-  def test_reset_configuration_after_with_configuration_block
-    Recaptcha.with_configuration(:public_key => '12345')
-    assert_equal('0000000000000000000000000000000000000000', Recaptcha.configuration.public_key)
-  end
-end

data/test/verify_recaptcha_test.rb

@@ -1,151 +0,0 @@
-# coding: utf-8
-
-require 'test/unit'
-require 'rubygems'
-require 'active_support'
-require 'active_support/core_ext/string'
-require 'mocha/setup'
-require 'i18n'
-require 'net/http'
-require File.dirname(File.expand_path(__FILE__)) + '/../lib/recaptcha'
-
-class RecaptchaVerifyTest < Test::Unit::TestCase
-  def setup
-    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"] = 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(Recaptcha.configuration.verify_url)
-  end
-
-  def test_should_raise_exception_without_private_key
-    assert_raise Recaptcha::RecaptchaError do
-      Recaptcha.configuration.private_key = nil
-      @controller.verify_recaptcha
-    end
-  end
-
-  def test_should_return_false_when_key_is_invalid
-    expect_http_post(response_with_body("false\ninvalid-site-private-key"))
-
-    assert !@controller.verify_recaptcha
-    assert_equal "invalid-site-private-key", @controller.flash[:recaptcha_error]
-  end
-
-  def test_returns_true_on_success
-    @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.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, "Word verification response is incorrect, please try again.")
-    model = mock(:errors => errors)
-
-    assert !@controller.verify_recaptcha(:model => model)
-    assert_equal "bad-news", @controller.flash[:recaptcha_error]
-  end
-
-  def test_returns_true_on_success_with_optional_key
-    @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.flash[:recaptcha_error]
-  end
-
-  def test_timeout
-    expect_http_post(Timeout::Error, :exception => true)
-    assert !@controller.verify_recaptcha()
-    assert_equal "Recaptcha unreachable.", @controller.flash[:recaptcha_error]
-  end
-
-  def test_timeout_when_handle_timeouts_gracefully_disabled
-    Recaptcha.with_configuration(:handle_timeouts_gracefully => false) do
-      expect_http_post(Timeout::Error, :exception => true)
-      assert_raise Recaptcha::RecaptchaError, "Recaptcha unreachable." do
-        assert @controller.verify_recaptcha()
-      end
-      assert_nil @controller.flash[:recaptcha_error]
-    end
-  end
-
-  def test_message_should_use_i18n
-    I18n.locale = :de
-    verification_failed_translated   = "Sicherheitscode konnte nicht verifiziert werden."
-    verification_failed_default      = "Word verification response is incorrect, please try again."
-    recaptcha_unreachable_translated = "Netzwerkfehler, bitte versuchen Sie es später erneut."
-    recaptcha_unreachable_default    = "Oops, we failed to validate your word verification response. Please try again."
-
-    I18n.expects(:translate).with('recaptcha.errors.bad-news', {:default => 'bad-news'})
-    I18n.expects(:translate).with('recaptcha.errors.recaptcha_unreachable', {:default => 'Recaptcha unreachable.'})
-
-    I18n.expects(:translate).with('recaptcha.errors.verification_failed', :default => verification_failed_default).returns(verification_failed_translated)
-    I18n.expects(:translate).with('recaptcha.errors.recaptcha_unreachable', :default => recaptcha_unreachable_default).returns(recaptcha_unreachable_translated)
-
-    errors = mock
-    errors.expects(:add).with(:base, verification_failed_translated)
-    errors.expects(:add).with(:base, recaptcha_unreachable_translated)
-    model  = mock; model.stubs(:errors => errors)
-
-    expect_http_post(response_with_body("false\nbad-news"))
-    @controller.verify_recaptcha(:model => model)
-
-    expect_http_post(Timeout::Error, :exception => true)
-    @controller.verify_recaptcha(:model => model)
-
-  end
-
-  def test_it_translates_api_response_with_i18n
-    api_error_translated = "Bad news, body :("
-    expect_http_post(response_with_body("false\nbad-news"))
-    I18n.expects(:translate).with('recaptcha.errors.bad-news', :default => 'bad-news').returns(api_error_translated)
-
-    assert !@controller.verify_recaptcha
-    assert_equal api_error_translated, @controller.flash[:recaptcha_error]
-  end
-
-  def test_it_fallback_to_api_response_if_i18n_translation_is_missing
-    expect_http_post(response_with_body("false\nbad-news"))
-
-    assert !@controller.verify_recaptcha
-    assert_equal 'bad-news', @controller.flash[:recaptcha_error]
-  end
-
-  private
-
-  class TestController
-    include Recaptcha::Verify
-    attr_accessor :request, :params, :flash
-
-    def initialize
-      @flash = {}
-    end
-  end
-
-  def expect_http_post(response, options = {})
-    unless options[:exception]
-      Net::HTTP.expects(:post_form).with(@expected_uri, @expected_post_data).returns(response)
-    else
-      Net::HTTP.expects(:post_form).raises response
-    end
-  end
-
-  def response_with_body(body)
-    stub(:body => body)
-  end
-end