recaptcha 4.13.1 → 5.1.1

data/lib/recaptcha/railtie.rb

@@ -3,13 +3,33 @@
 module Recaptcha
   class Railtie < Rails::Railtie
     ActiveSupport.on_load(:action_view) do
-      require 'recaptcha/client_helper'
-      include Recaptcha::ClientHelper
+      include Recaptcha::Adapters::ViewMethods
     end
 
     ActiveSupport.on_load(:action_controller) do
-      require 'recaptcha/verify'
-      include Recaptcha::Verify
+      include Recaptcha::Adapters::ControllerMethods
+    end
+
+    initializer 'recaptcha' do |app|
+      Recaptcha::Railtie.instance_eval do
+        pattern = pattern_from app.config.i18n.available_locales
+
+        add("rails/locales/#{pattern}.yml")
+      end
+    end
+
+    class << self
+      protected
+
+      def add(pattern)
+        files = Dir[File.join(File.dirname(__FILE__), '../..', pattern)]
+        I18n.load_path.concat(files)
+      end
+
+      def pattern_from(args)
+        array = Array(args || [])
+        array.blank? ? '*' : "{#{array.join ','}}"
+      end
     end
   end
 end

data/lib/recaptcha/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Recaptcha
-  VERSION = '4.13.1'
+  VERSION = '5.1.1'
 end

data/rails/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  recaptcha:
+    errors:
+      verification_failed: reCAPTCHA verification failed, please try again.
+      recaptcha_unreachable: Oops, we failed to validate your reCAPTCHA response. Please try again.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: recaptcha
 version: !ruby/object:Gem::Version
-  version: 4.13.1
+  version: 5.1.1
 platform: ruby
 authors:
 - Jason L Perry
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-01 00:00:00.000000000 Z
+date: 2019-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  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'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -161,16 +147,19 @@ files:
 - LICENSE
 - README.md
 - lib/recaptcha.rb
-- lib/recaptcha/client_helper.rb
+- lib/recaptcha/adapters/controller_methods.rb
+- lib/recaptcha/adapters/view_methods.rb
 - lib/recaptcha/configuration.rb
+- lib/recaptcha/helpers.rb
 - lib/recaptcha/rails.rb
 - lib/recaptcha/railtie.rb
-- lib/recaptcha/verify.rb
 - lib/recaptcha/version.rb
+- rails/locales/en.yml
 homepage: http://github.com/ambethia/recaptcha
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/ambethia/recaptcha
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -186,8 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Helpers for the reCAPTCHA API

data/lib/recaptcha/client_helper.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-module Recaptcha
-  module ClientHelper
-    # Your public API can be specified in the +options+ hash or preferably
-    # using the Configuration.
-    def recaptcha_tags(options = {})
-      if options.key?(:stoken)
-        raise(RecaptchaError, "Secure Token is deprecated. Please remove 'stoken' from your calls to recaptcha_tags.")
-      end
-      if options.key?(:ssl)
-        raise(RecaptchaError, "SSL is now always true. Please remove 'ssl' from your calls to recaptcha_tags.")
-      end
-
-      noscript = options.delete(:noscript)
-
-      html, tag_attributes, fallback_uri = Recaptcha::ClientHelper.recaptcha_components(options)
-      html << %(<div #{tag_attributes}></div>\n)
-
-      if noscript != false
-        html << <<-HTML
-          <noscript>
-            <div>
-              <div style="width: 302px; height: 422px; position: relative;">
-                <div style="width: 302px; height: 422px; position: absolute;">
-                  <iframe
-                    src="#{fallback_uri}"
-                    scrolling="no" name="ReCAPTCHA"
-                    style="width: 302px; height: 422px; border-style: none; border: 0;">
-                  </iframe>
-                </div>
-              </div>
-              <div style="width: 300px; height: 60px; border-style: none;
-                bottom: 12px; left: 25px; margin: 0px; padding: 0px; right: 25px;
-                background: #f9f9f9; border: 1px solid #c1c1c1; border-radius: 3px;">
-                <textarea id="g-recaptcha-response" name="g-recaptcha-response"
-                  class="g-recaptcha-response"
-                  style="width: 250px; height: 40px; border: 1px solid #c1c1c1;
-                  margin: 10px 25px; padding: 0px; resize: none;">
-                </textarea>
-              </div>
-            </div>
-          </noscript>
-        HTML
-      end
-
-      html.respond_to?(:html_safe) ? html.html_safe : html
-    end
-
-    # Invisible reCAPTCHA implementation
-    def invisible_recaptcha_tags(options = {})
-      options = {callback: 'invisibleRecaptchaSubmit', ui: :button}.merge options
-      text = options.delete(:text)
-      html, tag_attributes = Recaptcha::ClientHelper.recaptcha_components(options)
-      html << recaptcha_default_callback(options) if recaptcha_default_callback_required?(options)
-      case options[:ui]
-      when :button
-        html << %(<button type="submit" #{tag_attributes}>#{text}</button>\n)
-      when :invisible
-        html << %(<div data-size="invisible" #{tag_attributes}></div>\n)
-      when :input
-        html << %(<input type="submit" #{tag_attributes} value="#{text}"/>\n)
-      else
-        raise(RecaptchaError, "ReCAPTCHA ui `#{options[:ui]}` is not valid.")
-      end
-      html.respond_to?(:html_safe) ? html.html_safe : html
-    end
-
-    def self.recaptcha_components(options = {})
-      html = +''
-      attributes = {}
-      fallback_uri = +''
-
-      # Since leftover options get passed directly through as tag
-      # attributes, we must unconditionally delete all our options
-      options = options.dup
-      env = options.delete(:env)
-      class_attribute = options.delete(:class)
-      site_key = options.delete(:site_key)
-      hl = options.delete(:hl)
-      onload = options.delete(:onload)
-      render = options.delete(:render)
-      nonce = options.delete(:nonce)
-      skip_script = (options.delete(:script) == false)
-      ui = options.delete(:ui)
-
-      data_attribute_keys = [:badge, :theme, :type, :callback, :expired_callback, :error_callback, :size]
-      data_attribute_keys << :tabindex unless ui == :button
-      data_attributes = {}
-      data_attribute_keys.each do |data_attribute|
-        value = options.delete(data_attribute)
-        data_attributes["data-#{data_attribute.to_s.tr('_', '-')}"] = value if value
-      end
-
-      unless Recaptcha::Verify.skip?(env)
-        site_key ||= Recaptcha.configuration.site_key!
-        script_url = Recaptcha.configuration.api_server_url
-        query_params = hash_to_query(
-          hl: hl,
-          onload: onload,
-          render: render
-        )
-        script_url += "?#{query_params}" unless query_params.empty?
-        nonce_attr = " nonce='#{nonce}'" if nonce
-        html << %(<script src="#{script_url}" async defer#{nonce_attr}></script>\n) unless skip_script
-        fallback_uri = %(#{script_url.chomp(".js")}/fallback?k=#{site_key})
-        attributes["data-sitekey"] = site_key
-        attributes.merge! data_attributes
-      end
-
-      # Append whatever that's left of options to be attributes on the tag.
-      attributes["class"] = "g-recaptcha #{class_attribute}"
-      tag_attributes = attributes.merge(options).map { |k, v| %(#{k}="#{v}") }.join(" ")
-
-      [html, tag_attributes, fallback_uri]
-    end
-
-    private
-
-    def recaptcha_default_callback(options = {})
-      nonce = options[:nonce]
-      nonce_attr = " nonce='#{nonce}'" if nonce
-
-      <<-HTML
-        <script#{nonce_attr}>
-          var invisibleRecaptchaSubmit = function () {
-            var closestForm = function (ele) {
-              var curEle = ele.parentNode;
-              while (curEle.nodeName !== 'FORM' && curEle.nodeName !== 'BODY'){
-                curEle = curEle.parentNode;
-              }
-              return curEle.nodeName === 'FORM' ? curEle : null
-            };
-
-            var eles = document.getElementsByClassName('g-recaptcha');
-            if (eles.length > 0) {
-              var form = closestForm(eles[0]);
-              if (form) {
-                form.submit();
-              }
-            }
-          };
-        </script>
-      HTML
-    end
-
-    def recaptcha_default_callback_required?(options)
-      options[:callback] == 'invisibleRecaptchaSubmit' &&
-      !Recaptcha::Verify.skip?(options[:env]) &&
-      options[:script] != false
-    end
-
-    private_class_method def self.hash_to_query(hash)
-      hash.delete_if { |_, val| val.nil? || val.empty? }.to_a.map { |pair| pair.join('=') }.join('&')
-    end
-  end
-end

data/lib/recaptcha/verify.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Recaptcha
-  module Verify
-    # 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
-      return true if Recaptcha::Verify.skip?(options[:env])
-
-      model = options[:model]
-      attribute = options[:attribute] || :base
-      recaptcha_response = options[:response] || params['g-recaptcha-response'].to_s
-
-      begin
-        verified = if recaptcha_response.empty?
-          false
-        else
-          recaptcha_verify_via_api_call(request, recaptcha_response, options)
-        end
-
-        if verified
-          flash.delete(:recaptcha_error) if recaptcha_flash_supported? && !model
-          true
-        else
-          recaptcha_error(
-            model,
-            attribute,
-            options[:message],
-            "recaptcha.errors.verification_failed",
-            "reCAPTCHA verification failed, please try again."
-          )
-          false
-        end
-      rescue Timeout::Error
-        if Recaptcha.configuration.handle_timeouts_gracefully
-          recaptcha_error(
-            model,
-            attribute,
-            options[:message],
-            "recaptcha.errors.recaptcha_unreachable",
-            "Oops, we failed to validate your reCAPTCHA response. Please try again."
-          )
-          false
-        else
-          raise RecaptchaError, "Recaptcha unreachable."
-        end
-      rescue StandardError => e
-        raise RecaptchaError, e.message, e.backtrace
-      end
-    end
-
-    def verify_recaptcha!(options = {})
-      verify_recaptcha(options) || raise(VerifyError)
-    end
-
-    def self.skip?(env)
-      env ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || (Rails.env if defined? Rails.env)
-      Recaptcha.configuration.skip_verify_env.include? env
-    end
-
-    private
-
-    def recaptcha_verify_via_api_call(request, recaptcha_response, options)
-      secret_key = options[:secret_key] || Recaptcha.configuration.secret_key!
-
-      verify_hash = {
-        "secret"    => secret_key,
-        "response"  => recaptcha_response
-      }
-
-      unless options[:skip_remote_ip]
-        remoteip = (request.respond_to?(:remote_ip) && request.remote_ip) || (env && env['REMOTE_ADDR'])
-        verify_hash["remoteip"] = remoteip.to_s
-      end
-
-      reply = JSON.parse(Recaptcha.get(verify_hash, options))
-      reply['success'].to_s == "true" &&
-        recaptcha_hostname_valid?(reply['hostname'], options[:hostname])
-    end
-
-    def recaptcha_hostname_valid?(hostname, validation)
-      validation ||= Recaptcha.configuration.hostname
-
-      case validation
-      when nil, FalseClass then true
-      when String then validation == hostname
-      else validation.call(hostname)
-      end
-    end
-
-    def recaptcha_error(model, attribute, message, key, default)
-      message ||= Recaptcha.i18n(key, default)
-      if model
-        model.errors.add attribute, message
-      else
-        flash[:recaptcha_error] = message if recaptcha_flash_supported?
-      end
-    end
-
-    def recaptcha_flash_supported?
-      request.respond_to?(:format) && request.format == :html && respond_to?(:flash)
-    end
-  end
-end