recaptcha 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9928918ae6c300aacb0a2df19c974edf706f770
-  data.tar.gz: e0c54cc33cb1bb416644c531a3d687db4d9b357b
+  metadata.gz: 9d8c84c84605f3b19d067af5b08d173f5dd681f2
+  data.tar.gz: c0126d1350d3da2dda33a8d4a2932a0b1ad5f504
 SHA512:
-  metadata.gz: b90152d14acb163ec175bfc44e89ac7a0fc9e05ec460ce181fb8f80b734e09ca20ec6f52a10fcea9b6958a6e32dad59d307d8394345f7a60dcec96802ad7a213
-  data.tar.gz: d44621c515e8ce8ce0c615aab4622c747918c29d0fa63161dedd7bea435059be44a1309a6e0e8ad25d242b1c6e5c9388cc07a1ecd08a303e358103c5e0e68632
+  metadata.gz: 2ee980f5953e85425572add41e07b142b323743f8f0c14824145604a8f20176b6a54b5d365852f4dbadd283ecc3e67bf203599e8f03c4c9afc5a5d58c541c5a4
+  data.tar.gz: 8a8677420abff0ceac5f2674fd58da71623b980ff3336c6a2aaf196562adce8d295257d73c964cf220ed98ea1119f4723ea794c7acd7c4b004ff83edcda1fa10

data/README.md

@@ -0,0 +1,295 @@
+# reCAPTCHA
+
+Author:    Jason L Perry (http://ambethia.com)<br/>
+Copyright: Copyright (c) 2007-2013 Jason L Perry<br/>
+License:   [MIT](http://creativecommons.org/licenses/MIT/)<br/>
+Info:      https://github.com/ambethia/recaptcha<br/>
+Bugs:      https://github.com/ambethia/recaptcha/issues<br/>
+
+This plugin adds helpers for the [reCAPTCHA API](https://www.google.com/recaptcha). 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` or `verify_recaptcha!`,
+which throws an error on failiure.
+
+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.
+
+## Rails Installation
+
+```Ruby
+gem "recaptcha", require: "recaptcha/rails"
+```
+
+(Rails < 3.0: install an older release and view it's README)
+
+## Setting up your API Keys
+
+There are multiple ways to setup your reCAPTCHA API key once you
+[obtain a pair](https://www.google.com/recaptcha/admin).
+
+### Recaptcha.configure
+
+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.
+
+```Ruby
+Recaptcha.configure do |config|
+  config.public_key  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+  config.private_key = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+  # Uncomment the following line if you are using a proxy server:
+  # config.proxy = 'http://myproxy.com.au:8080'
+  # Uncomment if you want to use the older version of the API,
+  # only works for versions >= 0.3.7, default value is 'v2':
+  # config.api_version = 'v1'
+end
+```
+
+This way, you may also set additional options to fit recaptcha into your
+deployment environment.
+
+### Recaptcha.with_configuration
+
+If you want to temporarily overwrite the configuration you set with 
+`Recaptcha.configure` (when testing, for example), you can use a 
+`Recaptcha#with_configuration` block:
+
+```Ruby
+Recaptcha.with_configuration(public_key: '12345') do
+  # Do stuff with the overwritten public_key.
+end
+```
+
+### Heroku & Shell environment
+
+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. This would also be the preffered method
+in an Heroku deployment.
+
+```
+export RECAPTCHA_PUBLIC_KEY  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+export RECAPTCHA_PRIVATE_KEY = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+```
+
+### Per call
+
+You can also pass in your keys as options at runtime, for example:
+
+```Ruby
+recaptcha_tags public_key: '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+```
+
+and later,
+
+```Ruby
+verify_recaptcha private_key: '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+```
+
+This option might be useful, if the same code base is used for multiple
+reCAPTCHA setups.
+
+## To use 'recaptcha'
+
+Add `recaptcha_tags` to each form you want to protect. 
+Place it where you want the recaptcha widget to appear.
+
+Example:
+
+```Erb
+<%= form_for @foo do |f| %>
+  # ... additional lines truncated for brevity ...
+  <%= recaptcha_tags %>
+  # ... additional lines truncated for brevity ...
+<% end %>
+```
+
+And, add `verify_recaptcha` logic to each form action that you've protected.
+
+### recaptcha_tags
+
+Some of the options available:
+
+| Option      | Description |
+|-------------|-------------|
+| :ssl        | Uses secure http for captcha widget (default `false`, but can be changed by setting `config.use_ssl_by_default`)|
+| :noscript   | Include <noscript> content (default `true`)|
+| :display    | Takes a hash containing the `theme` and `tabindex` options per the API. (default `nil`), options: 'red', 'white', 'blackglass', 'clean', 'custom'|
+| :ajax       | Render the dynamic AJAX captcha per the API. (default `false`)|
+| :public_key | Your public API key, takes precedence over the ENV variable (default `nil`)|
+| :error      | Override the error code returned from the reCAPTCHA API (default `nil`)|
+| :stoken     | Include in reCAPTCHA API v2 the security token (default `true`)|
+| :size       | Specify a size (default `nil`)|
+
+
+You can also override the html attributes for the sizes of the generated `textarea` and `iframe`
+elements, if CSS isn't your thing. Inspect the source of `recaptcha_tags` to see these options.
+
+### verify_recaptcha
+
+This method returns `true` or `false` after processing the parameters from the reCAPTCHA widget. Why
+isn't this a model validation? Because that violates MVC. You can use it like this, or how ever you
+like. Passing in the ActiveRecord object is optional, if you do--and the captcha fails to verify--an
+error will be added to the object for you to use.
+
+Some of the options available:
+
+| Option       | Description |
+|--------------|-------------|
+| :model       | Model to set errors
+| :attribute   | Model attribute to receive errors (default :base)
+| :message     | Custom error message
+| :private_key | Your private API key, takes precedence over the ENV variable (default `nil`).
+| :timeout     | The number of seconds to wait for reCAPTCHA servers before give up. (default `3`)
+
+```Ruby
+respond_to do |format|
+  if verify_recaptcha(model @post, message: "Oh! It's error with reCAPTCHA!") && @post.save
+    # ...
+  else
+    # ...
+  end
+end
+```
+
+### Add multiple widgets to the same page
+
+This is an example taken from the [official google documentation](https://developers.google.com/recaptcha/docs/display).
+
+Add a script tag for a callback
+
+```Html
+<script type="text/javascript">
+  var verifyCallback = function(response) {
+    alert(response);
+  };
+  var widgetId1;
+  var widgetId2;
+  var onloadCallback = function() {
+    // Renders the HTML element with id 'example1' as a reCAPTCHA widget.
+    // The id of the reCAPTCHA widget is assigned to 'widgetId1'.
+    widgetId1 = grecaptcha.render('example1', {
+      'sitekey' : "<%= Recaptcha.configuration.public_key %>",
+      'theme' : 'light'
+    });
+    widgetId2 = grecaptcha.render(document.getElementById('example2'), {
+      'sitekey' : "<%= Recaptcha.configuration.public_key %>"
+    });
+    grecaptcha.render('example3', {
+      'sitekey' : "<%= Recaptcha.configuration.public_key %>",
+      'callback' : verifyCallback,
+      'theme' : 'dark'
+    });
+  };
+</script>
+```
+
+In the callback you will have the `sitekey` generated by this gem with `<%= Recaptcha.configuration.public_key %>`
+
+Next you need to have some elements with an id matching those specified in the callback
+
+```Erb
+<%= form_for @foo do |f| %>
+  # ... additional lines truncated for brevity ...
+  <div id="example1"></div>
+  # ... additional lines truncated for brevity ...
+<% end %>
+<%= form_for @foo2 do |f| %>
+  # ... additional lines truncated for brevity ...
+  <div id="example2"></div>
+  # ... additional lines truncated for brevity ...
+<% end %>
+<%= form_for @foo3 do |f| %>
+  # ... additional lines truncated for brevity ...
+  <div id="example3"></div>
+  # ... additional lines truncated for brevity ...
+<% end %>
+```
+
+And finally you need a script tag that gets the reCAPTCHA code from google and tells it that your code is explicit and gives it the callback.
+
+```Html
+<script src="https://www.google.com/recaptcha/api.js?onload=onloadCallback&render=explicit" async defer></script>
+```
+
+Now all together:
+
+```Html
+<html>
+  <head>
+    <title>reCAPTCHA demo: Explicit render for multiple widgets</title>
+    <script type="text/javascript">
+      var verifyCallback = function(response) {
+        alert(response);
+      };
+      var widgetId1;
+      var widgetId2;
+      var onloadCallback = function() {
+        // Renders the HTML element with id 'example1' as a reCAPTCHA widget.
+        // The id of the reCAPTCHA widget is assigned to 'widgetId1'.
+        widgetId1 = grecaptcha.render('example1', {
+          'sitekey' : "<%= Recaptcha.configuration.public_key %>",
+          'theme' : 'light'
+        });
+        widgetId2 = grecaptcha.render(document.getElementById('example2'), {
+          'sitekey' : "<%= Recaptcha.configuration.public_key %>"
+        });
+        grecaptcha.render('example3', {
+          'sitekey' : "<%= Recaptcha.configuration.public_key %>",
+          'callback' : verifyCallback,
+          'theme' : 'dark'
+        });
+      };
+    </script>
+  </head>
+  <body>
+    <%= form_for @foo do |f| %>
+      # ... additional lines truncated for brevity ...
+      <div id="example1"></div>
+      # ... additional lines truncated for brevity ...
+    <% end %>
+    <%= form_for @foo2 do |f| %>
+      # ... additional lines truncated for brevity ...
+      <div id="example2"></div>
+      # ... additional lines truncated for brevity ...
+    <% end %>
+    <%= form_for @foo3 do |f| %>
+      # ... additional lines truncated for brevity ...
+      <div id="example3"></div>
+      # ... additional lines truncated for brevity ...
+    <% end %>
+    <script src="https://www.google.com/recaptcha/api.js?onload=onloadCallback&render=explicit" async defer></script>
+  </body>
+</html>
+```
+
+The only real difference between this example and the google example is you will use the `<%= Recaptcha.configuration.public_key %>` for the `sitekey`
+
+If your callback has to live on another file (maybe a layout), then you would set the callback on window `window.onloadCallback = function() {...}`
+
+Then on the backend, you will still use the `verify_recaptcha` as explained in this readme.
+
+## I18n support
+reCAPTCHA passes two types of error explanation to a linked model. It will use the I18n gem
+to translate the default error message if I18n is available. To customize the messages to your locale,
+add these keys to your I18n backend:
+
+`recaptcha.errors.verification_failed` error message displayed if the captcha words didn't match
+`recaptcha.errors.recaptcha_unreachable` displayed if a timeout error occured while attempting to verify the captcha
+
+Also you can translate API response errors to human friendly by adding translations to the locale (`config/locales/en.yml`):
+
+```Yaml
+en:
+  recaptcha:
+    errors:
+      incorrect-captcha-sol: 'Fail'
+```
+
+## Testing
+By default, reCAPTCHA is skipped on "test" env, so if you need to make sure it's working properly, just remove the "test" entry of the skip_environment inside Recapcha class, look:
+
+
+```Ruby
+Recaptcha.configuration.skip_verify_env.delete("test")
+```

data/lib/recaptcha.rb

@@ -18,7 +18,7 @@ module Recaptcha
       }
     }
 
-  RECAPTCHA_API_VERSION           = 'v2' 
+  RECAPTCHA_API_VERSION           = 'v2'
   USE_SSL_BY_DEFAULT              = false
   HANDLE_TIMEOUTS_GRACEFULLY      = true
   SKIP_VERIFY_ENV = ['test', 'cucumber']
@@ -58,9 +58,4 @@ module Recaptcha
 
   class VerifyError < RecaptchaError
   end
-
-end
-
-if defined?(Rails)
-  require 'recaptcha/rails'
 end

data/lib/recaptcha/client_helper.rb

@@ -63,20 +63,39 @@ module Recaptcha
     end
 
     def v2_tags(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] : "")
+      public_key   = options[:public_key] ||= Recaptcha.configuration.public_key
+      raise RecaptchaError, "No public key specified." unless public_key
+      private_key  = options[:private_key] ||= Recaptcha.configuration.private_key
+      raise RecaptchaError, "No private key specified." unless private_key
+      error = options[:error] ||= ((defined? flash) ? flash[:recaptcha_error] : "") # TODO not being used !?
       uri   = Recaptcha.configuration.api_server_url(options[:ssl])
       uri += "?hl=#{options[:hl]}" unless options[:hl].blank?
-      
-      v2_options = options.slice(:theme, :type, :callback).map {|k,v| %{data-#{k}="#{v}"} }.join(" ")
 
       html = ""
       html << %{<script src="#{uri}" async defer></script>\n}
-      html << %{<div class="g-recaptcha" data-sitekey="#{key}" #{v2_options}></div>\n}
-    
+
+      data_attributes = options.slice(:theme, :type, :callback, :expired_callback, :size)
+      data_attributes[:sitekey] = public_key
+
+      if options[:stoken] != false
+        stoken_json = hash_to_json({'session_id' => SecureRandom.uuid, 'ts_ms' => (Time.now.to_f * 1000).to_i})
+        cipher = OpenSSL::Cipher::AES128.new(:ECB)
+        private_key_digest = Digest::SHA1.digest(private_key)[0...16]
+
+        cipher.encrypt
+        cipher.key = private_key_digest
+        encrypted_stoken = cipher.update(stoken_json) << cipher.final
+        encoded_stoken = Base64.urlsafe_encode64(encrypted_stoken).gsub(/\=+\Z/, '')
+
+        data_attributes[:stoken] = encoded_stoken
+      end
+
+      data_attributes = data_attributes.map {|k,v| %{data-#{k.to_s.gsub(/_/,'-')}="#{v}"} }.join(" ")
+
+      html << %{<div class="g-recaptcha" #{data_attributes}></div>\n}
+
       unless options[:noscript] == false
-        fallback_uri = "#{uri.chomp('.js')}/fallback?k=#{key}"
+        fallback_uri = "#{uri.chomp('.js')}/fallback?k=#{public_key}"
         html << %{<noscript>}
         html << %{<div style="width: 302px; height: 352px;">}
         html << %{  <div style="width: 302px; height: 352px; position: relative;">}
@@ -99,7 +118,7 @@ module Recaptcha
         html << %{</noscript>}
       end
 
-      return (html.respond_to?(:html_safe) && html.html_safe) || html
+      (html.respond_to?(:html_safe) && html.html_safe) || html
     end
 
     private
@@ -109,7 +128,7 @@ module Recaptcha
       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"
+        elsif ! v.is_a?(String) || k.to_s =~ %r{(callback|expired-callback)}
           "\"#{k}\": #{v}"
         else
           "\"#{k}\": \"#{v}\""
@@ -117,5 +136,5 @@ module Recaptcha
       end.join(", ")
       result << "}"
     end
-  end # ClientHelper
-end # Recaptcha
+  end
+end

data/lib/recaptcha/rails.rb

@@ -1,5 +1,13 @@
 require 'net/http'
 require 'recaptcha'
 
-ActionView::Base.send(:include, Recaptcha::ClientHelper)
-ActionController::Base.send(:include, Recaptcha::Verify)
+module Rails
+  module Recaptcha
+    class Railtie < Rails::Railtie
+      initializer :recaptcha do
+        ActionView::Base.send(:include, ::Recaptcha::ClientHelper)
+        ActionController::Base.send(:include, ::Recaptcha::Verify)
+      end
+    end
+  end
+end

data/lib/recaptcha/verify.rb

@@ -1,12 +1,16 @@
 require "uri"
+require "json"
+
 module Recaptcha
   module Verify
+    DEFAULT_TIMEOUT = 3
+
     # Your private API can be specified in the +options+ hash or preferably
     # using the Configuration.
     def verify_recaptcha(options = {})
       options = {:model => options} unless options.is_a? Hash
 
-      env_options = options[:env] || ENV['RAILS_ENV']
+      env_options = options[:env] || ENV['RAILS_ENV'] || (Rails.env if defined? Rails.env)
       return true if Recaptcha.configuration.skip_verify_env.include? env_options
       model = options[:model]
       attribute = options[:attribute] || :base
@@ -15,7 +19,7 @@ module Recaptcha
 
       begin
         recaptcha = nil
-        if(Recaptcha.configuration.proxy)
+        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
@@ -31,7 +35,7 @@ module Recaptcha
             "challenge"  => params[:recaptcha_challenge_field],
             "response"   => params[:recaptcha_response_field]
           }
-          Timeout::timeout(options[:timeout] || 3) do
+          Timeout::timeout(options[:timeout] || DEFAULT_TIMEOUT) do
             recaptcha = http.post_form(URI.parse(Recaptcha.configuration.verify_url), verify_hash)
           end
           answer, error = recaptcha.body.split.map { |s| s.chomp }
@@ -44,10 +48,10 @@ module Recaptcha
             "response"  => params['g-recaptcha-response']
           }
 
-          Timeout::timeout(options[:timeout] || 3) do
+          Timeout::timeout(options[:timeout] || DEFAULT_TIMEOUT) do
             uri = URI.parse(Recaptcha.configuration.verify_url + '?' + verify_hash.to_query)
             http_instance = http.new(uri.host, uri.port)
-            if uri.port==443
+            if uri.port == 443
               http_instance.use_ssl =
               http_instance.verify_mode = OpenSSL::SSL::VERIFY_NONE
             end
@@ -57,55 +61,56 @@ module Recaptcha
           answer, error = JSON.parse(recaptcha.body).values
         end
 
-        unless answer.to_s == 'true'
+        if answer.to_s == 'true'
+          flash.delete(:recaptcha_error) if request_in_html_format?
+          true
+        else
           error = 'verification_failed' if error && Recaptcha.configuration.v2?
           if request_in_html_format?
             flash[:recaptcha_error] = if defined?(I18n)
-                                        I18n.translate("recaptcha.errors.#{error}", {:default => error})
-                                      else
-                                        error
-                                      end
+              I18n.translate("recaptcha.errors.#{error}", default: error)
+            else
+              error
+            end
           end
 
           if model
             message = "Word verification response is incorrect, please try again."
-            message = I18n.translate('recaptcha.errors.verification_failed', {:default => message}) if defined?(I18n)
+            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) if request_in_html_format?
-          return true
+          false
         end
       rescue Timeout::Error
         if Recaptcha.configuration.handle_timeouts_gracefully
           if request_in_html_format?
             flash[:recaptcha_error] = if defined?(I18n)
-                                        I18n.translate('recaptcha.errors.recaptcha_unreachable', {:default => 'Recaptcha unreachable.'})
-                                      else
-                                        'Recaptcha unreachable.'
-                                      end
+              I18n.translate('recaptcha.errors.recaptcha_unreachable', default: 'Recaptcha unreachable.')
+            else
+              'Recaptcha unreachable.'
+            end
           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)
+            message = I18n.translate('recaptcha.errors.recaptcha_unreachable', default: message) if defined?(I18n)
             model.errors.add attribute, options[:message] || message
           end
-          return false
+          false
         else
           raise RecaptchaError, "Recaptcha unreachable."
         end
-      rescue Exception => e
+      rescue StandardError => e
         raise RecaptchaError, e.message, e.backtrace
       end
-    end # verify_recaptcha
+    end
 
     def request_in_html_format?
       request.respond_to?(:format) && request.format == :html && respond_to?(:flash)
     end
+
     def verify_recaptcha!(options = {})
       verify_recaptcha(options) or raise VerifyError
-    end #verify_recaptcha!
-  end # Verify
-end # Recaptcha
+    end
+  end
+end

data/lib/recaptcha/version.rb

@@ -1,3 +1,3 @@
 module Recaptcha
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: recaptcha
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Jason L Perry
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-22 00:00:00.000000000 Z
+date: 2015-11-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -67,19 +81,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: maxitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -94,37 +108,39 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: This plugin adds helpers for the reCAPTCHA API
+- !ruby/object:Gem::Dependency
+  name: bump
+  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: Helpers for the reCAPTCHA API
 email:
 - jasper@ambethia.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - CHANGELOG
-- Gemfile
-- Gemfile.lock
 - LICENSE
-- README.rdoc
-- Rakefile
-- init.rb
+- README.md
 - lib/recaptcha.rb
 - lib/recaptcha/client_helper.rb
 - lib/recaptcha/configuration.rb
-- lib/recaptcha/merb.rb
 - lib/recaptcha/rails.rb
-- lib/recaptcha/railtie.rb
 - lib/recaptcha/verify.rb
 - lib/recaptcha/version.rb
-- recaptcha.gemspec
-- test/recaptcha_configuration_test.rb
-- test/recaptcha_test.rb
-- test/recaptcha_v1_test.rb
-- test/verify_recaptcha_test.rb
 homepage: http://github.com/ambethia/recaptcha
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -134,20 +150,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: recaptcha
-rubygems_version: 2.4.5
+rubyforge_project: 
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Helpers for the reCAPTCHA API
-test_files:
-- test/recaptcha_configuration_test.rb
-- test/recaptcha_test.rb
-- test/recaptcha_v1_test.rb
-- test/verify_recaptcha_test.rb
+test_files: []

data/.gitignore

@@ -1,8 +0,0 @@
-rdoc
-pkg
-.ruby-gemset
-.ruby-version
-.bundle
-
-.gems
-.rbenv-gemsets

data/.travis.yml

@@ -1,3 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.2

data/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

data/Gemfile.lock

@@ -1,52 +0,0 @@
-PATH
-  remote: .
-  specs:
-    recaptcha (0.4.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (4.1.8)
-      i18n (~> 0.6, >= 0.6.9)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.1)
-      tzinfo (~> 1.1)
-    byebug (3.5.1)
-      columnize (~> 0.8)
-      debugger-linecache (~> 1.2)
-      slop (~> 3.6)
-    coderay (1.1.0)
-    columnize (0.8.9)
-    debugger-linecache (1.2.0)
-    i18n (0.6.11)
-    json (1.8.1)
-    metaclass (0.0.4)
-    method_source (0.8.2)
-    minitest (5.4.3)
-    mocha (1.1.0)
-      metaclass (~> 0.0.1)
-    pry (0.10.1)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    pry-byebug (2.0.0)
-      byebug (~> 3.4)
-      pry (~> 0.10)
-    rake (10.3.2)
-    slop (3.6.0)
-    thread_safe (0.3.4)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport
-  i18n
-  minitest (~> 5.0)
-  mocha
-  pry-byebug
-  rake
-  recaptcha!

data/README.rdoc

@@ -1,151 +0,0 @@
-= reCAPTCHA
-
-Author::    Jason L Perry (http://ambethia.com)
-Copyright:: Copyright (c) 2007-2013 Jason L Perry
-License::   {MIT}[http://creativecommons.org/licenses/MIT/]
-Info::      http://github.com/ambethia/recaptcha
-Bugs::      http://github.com/ambethia/recaptcha/issues
-
-This plugin adds helpers for the {reCAPTCHA API}[https://www.google.com/recaptcha]. 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+ or +verify_recaptcha!+,
-which throws an error on failiure.
-
-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.
-
-== Rails Installation
-
-reCAPTCHA for Rails > 3.0, add this to your Gemfile:
-
-  gem "recaptcha", :require => "recaptcha/rails"
-
-Rails apps below 3.0 are no longer supported, but you can install an older
-release and view it's README.
-
-== Setting up your API Keys
-
-There are multiple ways to setup your reCAPTCHA API key once you
-{obtain}[https://www.google.com/recaptcha/admin] a pair.
-
-=== Recaptcha.configure
-
-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.
-
-  Recaptcha.configure do |config|
-    config.public_key  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
-    config.private_key = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
-    # Uncomment the following line if you are using a proxy server:
-    # config.proxy = 'http://myproxy.com.au:8080'
-    # Uncomment if you want to use the newer version of the API,
-    # only works for versions >= 0.3.7:
-    # config.api_version = 'v2'
-  end
-
-This way, you may also set additional options to fit recaptcha into your
-deployment environment.
-
-== Recaptcha#with_configuration
-
-If you want to temporarily overwrite the configuration you set with `Recaptcha.configure` (when testing, for example), you can use a `Recaptcha#with_configuration` block:
-
-  Recaptcha.with_configuration(:public_key => '12345') do
-    # Do stuff with the overwritten public_key.
-  end
-
-=== Heroku & Shell environment
-
-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. This would also be the preffered method
-in an Heroku deployment.
-
-  export RECAPTCHA_PUBLIC_KEY  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
-  export RECAPTCHA_PRIVATE_KEY = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
-
-=== 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'
-
-This option might be useful, if the same code base is used for multiple
-reCAPTCHA setups.
-
-== To use 'recaptcha'
-
-Add +recaptcha_tags+ to each form you want to protect. Place it where you want the recaptcha widget to appear.
-
-Example:
-
-  <%= form_for @foo do |f| %>
-    # ... additional lines truncated for brevity ...
-    <%= recaptcha_tags %>
-    # ... additional lines truncated for brevity ...
-  <% end %>
-
-And, add +verify_recaptcha+ logic to each form action that you've protected.
-
-=== +recaptcha_tags+
-
-Some of the options available:
-
-<tt>:ssl</tt>::         Uses secure http for captcha widget (default +false+, but can be changed by setting +config.use_ssl_by_default+)
-<tt>:noscript</tt>::    Include <noscript> content (default +true+)
-<tt>:display</tt>::     Takes a hash containing the +theme+ and +tabindex+ options per the API. (default +nil+), options: 'red', 'white', 'blackglass', 'clean', 'custom'
-<tt>:ajax</tt>::        Render the dynamic AJAX captcha per the API. (default +false+)
-<tt>:public_key</tt>::  Your public API key, takes precedence over the ENV variable (default +nil+)
-<tt>:error</tt>::       Override the error code returned from the reCAPTCHA API (default +nil+)
-
-You can also override the html attributes for the sizes of the generated +textarea+ and +iframe+
-elements, if CSS isn't your thing. Inspect the source of +recaptcha_tags+ to see these options.
-
-=== +verify_recaptcha+
-
-This method returns +true+ or +false+ after processing the parameters from the reCAPTCHA widget. Why
-isn't this a model validation? Because that violates MVC. You can use it like this, or how ever you
-like. Passing in the ActiveRecord object is optional, if you do--and the captcha fails to verify--an
-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
-      # ...
-    else
-      # ...
-    end
-  end
-
-== I18n support
-reCAPTCHA passes two types of error explanation to a linked model. It will use the I18n gem
-to translate the default error message if I18n is available. To customize the messages to your locale,
-add these keys to your I18n backend:
-
-<tt>recaptcha.errors.verification_failed</tt>:: error message displayed if the captcha words didn't match
-<tt>recaptcha.errors.recaptcha_unreachable</tt>:: displayed if a timeout error occured while attempting to verify the captcha
-
-Also you can translate API response errors to human friendly by adding translations to the locale (+config/locales/en.yml+):
-
-  en:
-    recaptcha:
-      errors:
-        incorrect-captcha-sol: 'Fail'
-
-== TODO
-* Remove Rails/ActionController dependencies
-* Framework agnostic
-* Add some helpers to use in before_filter and what not
-* Better documentation

data/Rakefile

@@ -1,8 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new do |t|
-  t.test_files = FileList['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/merb.rb

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

data/lib/recaptcha/railtie.rb

@@ -1,15 +0,0 @@
-require 'net/http'
-require 'recaptcha'
-module Rails
-  module Recaptcha
-    class Railtie < Rails::Railtie
-      initializer "setup config" do
-        begin
-          ActionView::Base.send(:include, ::Recaptcha::ClientHelper)
-          ActionController::Base.send(:include, ::Recaptcha::Verify)
-        end
-      end
-    end
-  end
-end
-

data/recaptcha.gemspec

@@ -1,26 +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"
-  s.add_development_dependency "minitest", "~> 5.0"
-  s.add_development_dependency "pry-byebug"
-end

data/test/recaptcha_configuration_test.rb

@@ -1,44 +0,0 @@
-require 'minitest/autorun'
-require 'cgi'
-require File.dirname(File.expand_path(__FILE__)) + '/../lib/recaptcha'
-
-class RecaptchaConfigurationTest < Minitest::Test
-  include Recaptcha
-  include Recaptcha::ClientHelper
-  include Recaptcha::Verify
-
-  attr_accessor :session
-
-  def setup
-    @session = {}
-    @nonssl_api_server_url = Regexp.new(Regexp.quote(Recaptcha.configuration.nonssl_api_server_url) + '(.*)')
-    @ssl_api_server_url = Regexp.new(Regexp.quote(Recaptcha.configuration.ssl_api_server_url) + '(.*)')
-    Recaptcha.configure do |config|
-      config.public_key = '0000000000000000000000000000000000000000'
-      config.private_key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
-      config.api_version = 'v2'
-    end
-  end
-
-  def test_recaptcha_api_version_default
-    assert_equal(Recaptcha.configuration.api_version, Recaptcha::RECAPTCHA_API_VERSION)
-  end
-
-  def test_v2_with_v2_api?
-    assert Recaptcha.configuration.v2?
-    refute Recaptcha.configuration.v1?
-  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/recaptcha_test.rb

@@ -1,54 +0,0 @@
-require 'minitest/autorun'
-require 'cgi'
-require File.dirname(File.expand_path(__FILE__)) + '/../lib/recaptcha'
-
-class RecaptchaClientHelperTest < Minitest::Test
-  include Recaptcha
-  include Recaptcha::ClientHelper
-  include Recaptcha::Verify
-
-  attr_accessor :session
-
-  def setup
-    @session = {}
-    @nonssl_api_server_url = Regexp.new(Regexp.quote(Recaptcha.configuration.nonssl_api_server_url) + '(.*)')
-    @ssl_api_server_url = Regexp.new(Regexp.quote(Recaptcha.configuration.ssl_api_server_url) + '(.*)')
-    Recaptcha.configure do |config|
-      config.public_key = '0000000000000000000000000000000000000000'
-      config.private_key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
-    end
-  end
-
-  def test_recaptcha_tags_v2
-    Recaptcha.configuration.api_version = 'v2'
-    # match a v2 only tag
-    assert_match /data-sitekey/, recaptcha_tags
-    # refute a v1 only tag
-    refute_match /\/challenge\?/, recaptcha_tags
-  end
-
-  def test_ssl_by_default
-    Recaptcha.configuration.use_ssl_by_default = true
-    assert_match @ssl_api_server_url, recaptcha_tags
-  end
-
-  def test_relative_protocol_by_default_without_ssl
-    Recaptcha.configuration.use_ssl_by_default = false
-    assert_match @nonssl_api_server_url, recaptcha_tags(:ssl => false)
-  end
-
-  def test_recaptcha_tags_with_ssl
-    assert_match @ssl_api_server_url, recaptcha_tags(:ssl => true)
-  end
-
-  def test_recaptcha_tags_without_noscript
-    refute_match /noscript/, recaptcha_tags(:noscript => false)
-  end
-
-  def test_should_raise_exception_without_public_key
-    assert_raises RecaptchaError do
-      Recaptcha.configuration.public_key = nil
-      recaptcha_tags
-    end
-  end
-end

data/test/recaptcha_v1_test.rb

@@ -1,35 +0,0 @@
-require 'minitest/autorun'
-require 'cgi'
-require File.dirname(File.expand_path(__FILE__)) + '/../lib/recaptcha'
-
-class RecaptchaV1Test < Minitest::Test
-  include Recaptcha
-  include Recaptcha::ClientHelper
-  include Recaptcha::Verify
-
-  attr_accessor :session
-
-  def setup
-    @session = {}
-    @nonssl_api_server_url = Regexp.new(Regexp.quote(Recaptcha.configuration.nonssl_api_server_url) + '(.*)')
-    @ssl_api_server_url = Regexp.new(Regexp.quote(Recaptcha.configuration.ssl_api_server_url) + '(.*)')
-    Recaptcha.configure do |config|
-      config.public_key = '0000000000000000000000000000000000000000'
-      config.private_key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
-      config.api_version = 'v1'
-    end
-  end
-
-  def test_v1_with_v1_api?
-    assert Recaptcha.configuration.v1?
-    refute Recaptcha.configuration.v2?
-  end
-
-  def test_recaptcah_tags_v1
-    Recaptcha.configuration.api_version = 'v1'
-    # match a v1 only tag
-    assert_match /\/challenge\?/, recaptcha_tags
-    # refute a v2 only tag
-    refute_match /data-sitekey/, recaptcha_tags
-  end
-end

data/test/verify_recaptcha_test.rb

@@ -1,191 +0,0 @@
-# coding: utf-8
-
-require 'minitest/autorun'
-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 < Minitest::Test
-  def setup
-    Recaptcha.configuration.private_key = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
-    @controller = TestController.new
-    @controller.request = stub(:remote_ip => "1.1.1.1", format: :html)
-
-    @expected_post_data = {}
-    @expected_post_data["remoteip"]   = @controller.request.remote_ip
-    @expected_post_data["response"]   = "response"
-
-    if Recaptcha.configuration.v1?
-      @controller.params = {:recaptcha_challenge_field => "challenge", :recaptcha_response_field => "response"}
-      @expected_post_data["privatekey"] = Recaptcha.configuration.private_key
-      @expected_post_data["challenge"]  = "challenge"
-    end
-
-    if Recaptcha.configuration.v2?
-      @controller.params = {:recaptcha_response_field => "response"}
-      @expected_post_data["secret"] = Recaptcha.configuration.private_key
-    end
-
-    @expected_uri = URI.parse(Recaptcha.configuration.verify_url)
-  end
-
-  def test_should_raise_exception_when_calling_bang_method
-    @controller.expects(:verify_recaptcha).returns(false)
-
-    assert_raises Recaptcha::VerifyError do
-      @controller.verify_recaptcha!
-    end
-  end
-
-  def test_should_return_whatever_verify_method_returns_when_using_bang_method
-    @controller.expects(:verify_recaptcha).returns(:foo)
-
-    assert_equal :foo, @controller.verify_recaptcha!
-  end
-
-  def test_should_raise_exception_without_private_key
-    skip
-    assert_raises Recaptcha::RecaptchaError do
-      Recaptcha.configuration.private_key = nil
-      @controller.verify_recaptcha
-    end
-  end
-
-  def test_should_return_false_when_key_is_invalid
-    skip
-    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
-    skip
-    @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
-    skip
-    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
-    skip
-    @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
-    skip
-    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
-    skip
-    Recaptcha.with_configuration(:handle_timeouts_gracefully => false) do
-      expect_http_post(Timeout::Error, :exception => true)
-      assert_raises Recaptcha::RecaptchaError, "Recaptcha unreachable." do
-        assert @controller.verify_recaptcha()
-      end
-      assert_nil @controller.flash[:recaptcha_error]
-    end
-  end
-
-  def test_message_should_use_i18n
-    skip
-    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
-    skip
-    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
-    skip
-    expect_http_post(response_with_body("false\nbad-news"))
-
-    assert !@controller.verify_recaptcha
-    assert_equal 'bad-news', @controller.flash[:recaptcha_error]
-  end
-
-  def test_not_flashing_error_if_request_format_not_in_html
-    skip
-    @controller.request = stub(:remote_ip => "1.1.1.1", format: :json)
-    expect_http_post(response_with_body("false\nbad-news"))
-    assert !@controller.verify_recaptcha
-    assert_nil @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