hcaptcha 7.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a8d13c5892c269bd846a2be83ff471553e73cabe9e029bd0665835f38ab0750
+  data.tar.gz: 61eb765060b5f609a35e058f6841144c829b52ebf3019d55929f659b3adf8e7d
+SHA512:
+  metadata.gz: 4dd587e34892cdf438cc18039659760682985c69d50fee1eaadc8becdf660a79b1d4297ad46699e0a6e81bd7bf2e7dc80cb7d4bd45263250801e5585453848f5
+  data.tar.gz: 1902d04442608418ddfac1e3bb1ad4acef2763691482c1b9a0a632adcdb254d5392b03f5e3deb389f74ddd797e967edfb5b0c83597585279e04c004592c86beb

data/CHANGELOG.md

@@ -0,0 +1 @@
+## Next

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2019 First Movers Advantage
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,160 @@
+# hCaptcha
+[![Gem Version](https://badge.fury.io/rb/hcaptcha.svg)](https://badge.fury.io/rb/hcaptcha)
+
+Disclaimer: This gem is forked from the [recaptcha gem](https://github.com/ambethia/recaptcha). All ideas, including the documentation and demo Rails and Sinatra integrations come from [recaptcha gem](https://github.com/ambethia/recaptcha) but are adoped for hCaptcha.
+
+Author:    Tyler VanNurden & Jason L Perry (http://ambethia.com)<br/>
+License:   [MIT](http://creativecommons.org/licenses/MIT/)<br/>
+Info:      https://github.com/firstmoversadvantage/hcaptcha<br/>
+Bugs:      https://github.com/firstmoversadvantage/hcaptcha/issues<br/>
+
+This gem provides helper methods for the [hCaptcha API](https://hcaptcha.com). In your
+views you can use the `hcaptcha_tags` method to embed the needed javascript, and you can validate
+in your controllers with `verify_hcaptcha` or `verify_hcaptcha!`.
+
+## Obtaining a key and setup
+
+Go to the [hCaptcha](https://hcaptcha.com/webmaster/signup) signup page to obtain API keys. **You'll also need to set a hostname that your application will run from, even for local development. hCaptcha will not work if your application is being served from `localhost` or `127.0.0.1`. You will need to add a hosts entry for local development.** See the [hCaptcha docs](https://hcaptcha.com/docs) for how to do this.
+
+The hostname you set it to must be a real hostname, since hCaptcha validates it when you create it in the portal. For example, `example.fmadata.com` does not have a DNS record, but `mydomain.com` does. The DNS record doesn't need to point to your application though, it just has to exist - that's why we added the record into the local hosts file.
+
+## Rails Installation
+
+```ruby
+gem "hcaptcha"
+```
+
+You can keep keys out of the code base with environment variables or with Rails [secrets](https://api.rubyonrails.org/classes/Rails/Application.html#method-i-secrets).<br/>
+
+In development, you can use the [dotenv](https://github.com/bkeepers/dotenv) gem. (Make sure to add it above `gem 'hcaptcha'`.)
+
+See [Alternative API key setup](#alternative-api-key-setup) for more ways to configure or override
+keys. See also the
+[Configuration](https://www.rubydoc.info/github/ambethia/recaptcha/master/Recaptcha/Configuration)
+documentation.
+
+```shell
+export HCAPTCHA_SITE_KEY='6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+export HCAPTCHA_SECRET_KEY='6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+```
+
+Add `hcaptcha_tags` to the forms you want to protect:
+
+```erb
+<%= form_for @foo do |f| %>
+  # …
+  <%= hcaptcha_tags %>
+  # …
+<% end %>
+```
+
+Then, add `verify_hcaptcha` logic to each form action that you've protected:
+
+```ruby
+# app/controllers/users_controller.rb
+@user = User.new(params[:user].permit(:name))
+if verify_hcaptcha(model: @user) && @user.save
+  redirect_to @user
+else
+  render 'new'
+end
+```
+
+## Sinatra / Rack / Ruby installation
+
+See [sinatra demo](/demo/sinatra) for details.
+
+ - add `gem 'hcaptcha'` to `Gemfile`
+ - set env variables
+ - `include Hcaptcha::Adapters::ViewMethods` where you need `recaptcha_tags`
+ - `include Hcaptcha::Adapters::ControllerMethods` where you need `verify_recaptcha`
+
+
+## hCaptcha API and Usage
+
+### `recaptcha_tags`
+
+Use in your views to render the JavaScript widget.
+
+### `verify_recaptcha`
+
+This method returns `true` or `false` after processing the response token from the hCaptcha widget.
+This is usually called from your controller, as seen [above](#rails-installation).
+
+Passing in the ActiveRecord object via `model: object` is optional. If you pass a `model`—and the
+captcha fails to verify—an error will be added to the object for you to use (available as
+`object.errors`).
+
+Why isn't this a model validation? Because that violates MVC. You can use it like this, or how ever
+you like.
+
+Some of the options available:
+
+| Option         | Description |
+|----------------|-------------|
+| `:model`       | Model to set errors.
+| `:attribute`   | Model attribute to receive errors. (default: `:base`)
+| `:message`     | Custom error message.
+| `:secret_key`  | Override the secret API key from the configuration.
+| `:timeout`     | The number of seconds to wait for hCaptcha servers before give up. (default: `3`)
+| `:response`    | Custom response parameter. (default: `params['g-recaptcha-response']`)
+| `:hostname`    | Expected hostname or a callable that validates the hostname, see [domain validation](https://developers.google.com/recaptcha/docs/domain_validation) and [hostname](https://developers.google.com/recaptcha/docs/verify#api-response) docs. (default: `nil`, but can be changed by setting `config.hostname`)
+| `:env`         | Current environment. The request to verify will be skipped if the environment is specified in configuration under `skip_verify_env`
+
+## I18n support
+
+hCaptcha supports the I18n gem (it comes with English translations)
+To override or add new languages, add to `config/locales/*.yml`
+
+```yaml
+# config/locales/en.yml
+en:
+  recaptcha:
+    errors:
+      verification_failed: 'hCaptcha was incorrect, please try again.'
+      recaptcha_unreachable: 'hCaptcha verification server error, please try again.'
+```
+
+## Testing
+
+By default, hCaptcha is skipped in "test" and "cucumber" env. To enable it during test:
+
+```ruby
+Recaptcha.configuration.skip_verify_env.delete("test")
+```
+
+## Alternative API key setup
+
+### Recaptcha.configure
+
+```ruby
+# config/initializers/recaptcha.rb
+Recaptcha.configure do |config|
+  config.site_key  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+  config.secret_key = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+  # Uncomment the following line if you are using a proxy server:
+  # config.proxy = 'http://myproxy.com.au:8080'
+end
+```
+
+### Recaptcha.with_configuration
+
+For temporary overwrites (not thread safe).
+
+```ruby
+Recaptcha.with_configuration(site_key: '12345') do
+  # Do stuff with the overwritten site_key.
+end
+```
+
+### Per call
+
+Pass in keys as options at runtime, for code base with multiple hCaptcha setups:
+
+```ruby
+recaptcha_tags site_key: '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+
+# and
+
+verify_recaptcha secret_key: '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+```

data/lib/hcaptcha.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+require 'hcaptcha/configuration'
+require 'hcaptcha/helpers'
+require 'hcaptcha/adapters/controller_methods'
+require 'hcaptcha/adapters/view_methods'
+if defined?(Rails)
+  require 'hcaptcha/railtie'
+end
+
+module Hcaptcha
+  DEFAULT_TIMEOUT = 3
+  RESPONSE_LIMIT = 32767
+
+  class HcaptchaError < StandardError
+  end
+
+  class VerifyError < HcaptchaError
+  end
+
+  # 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
+
+  def self.with_configuration(config)
+    original_config = {}
+
+    config.each do |key, value|
+      original_config[key] = configuration.send(key)
+      configuration.send("#{key}=", value)
+    end
+
+    yield if block_given?
+  ensure
+    original_config.each { |key, value| configuration.send("#{key}=", value) }
+  end
+
+  def self.skip_env?(env)
+    configuration.skip_verify_env.include?(env || configuration.default_env)
+  end
+
+  def self.invalid_response?(resp)
+    resp.empty? || resp.length > RESPONSE_LIMIT
+  end
+
+  def self.verify_via_api_call(response, options)
+    secret_key = options.fetch(:secret_key) { configuration.secret_key! }
+    verify_hash = { 'secret' => secret_key, 'response' => response }
+    verify_hash['remoteip'] = options[:remote_ip] if options.key?(:remote_ip)
+
+    reply = api_verification(verify_hash, timeout: options[:timeout])
+    reply['success'].to_s == 'true' &&
+      hostname_valid?(reply['hostname'], options[:hostname]) &&
+      action_valid?(reply['action'], options[:action]) &&
+      score_above_threshold?(reply['score'], options[:minimum_score])
+  end
+
+  def self.hostname_valid?(hostname, validation)
+    validation ||= configuration.hostname
+
+    case validation
+    when nil, FalseClass then true
+    when String then validation == hostname
+    else validation.call(hostname)
+    end
+  end
+
+  def self.action_valid?(action, expected_action)
+    case expected_action
+    when nil, FalseClass then true
+    else action == expected_action
+    end
+  end
+
+  # Returns true iff score is greater or equal to (>=) minimum_score, or if no minimum_score was specified
+  def self.score_above_threshold?(score, minimum_score)
+    return true if minimum_score.nil?
+    return false if score.nil?
+
+    case minimum_score
+    when nil, FalseClass then true
+    else score >= minimum_score
+    end
+  end
+
+  def self.api_verification(verify_hash, timeout: DEFAULT_TIMEOUT)
+    http = if configuration.proxy
+      proxy_server = URI.parse(configuration.proxy)
+      Net::HTTP::Proxy(proxy_server.host, proxy_server.port, proxy_server.user, proxy_server.password)
+    else
+      Net::HTTP
+    end
+    query = URI.encode_www_form(verify_hash)
+    uri = URI.parse(configuration.verify_url + '?' + query)
+    http_instance = http.new(uri.host, uri.port)
+    http_instance.read_timeout = http_instance.open_timeout = timeout
+    http_instance.use_ssl = true if uri.port == 443
+    request = Net::HTTP::Get.new(uri.request_uri)
+    JSON.parse(http_instance.request(request).body)
+  end
+end

data/lib/hcaptcha/adapters/controller_methods.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Hcaptcha
+  module Adapters
+    module ControllerMethods
+      private
+
+      # Your private API can be specified in the +options+ hash or preferably
+      # using the Configuration.
+      def verify_hcaptcha(options = {})
+        options = { model: options } unless options.is_a? Hash
+        return true if Hcaptcha.skip_env?(options[:env])
+
+        model = options[:model]
+        attribute = options.fetch(:attribute, :base)
+        hcaptcha_response = options[:response] || hcaptcha_response_token(options[:action])
+
+        begin
+          verified = if Hcaptcha.invalid_response?(hcaptcha_response)
+            false
+          else
+            unless options[:skip_remote_ip]
+              remoteip = (request.respond_to?(:remote_ip) && request.remote_ip) || (env && env['REMOTE_ADDR'])
+              options = options.merge(remote_ip: remoteip.to_s) if remoteip
+            end
+
+            Hcaptcha.verify_via_api_call(hcaptcha_response, options)
+          end
+
+          if verified
+            flash.delete(:hcaptcha_error) if hcaptcha_flash_supported? && !model
+            true
+          else
+            hcaptcha_error(
+              model,
+              attribute,
+              options.fetch(:message) { Hcaptcha::Helpers.to_error_message(:verification_failed) }
+            )
+            false
+          end
+        rescue Timeout::Error
+          if Hcaptcha.configuration.handle_timeouts_gracefully
+            hcaptcha_error(
+              model,
+              attribute,
+              options.fetch(:message) { Hcaptcha::Helpers.to_error_message(:hcaptcha_unreachable) }
+            )
+            false
+          else
+            raise HcaptchaError, 'Hcaptcha unreachable.'
+          end
+        rescue StandardError => e
+          raise HcaptchaError, e.message, e.backtrace
+        end
+      end
+
+      def verify_hcaptcha!(options = {})
+        verify_hcaptcha(options) || raise(VerifyError)
+      end
+
+      def hcaptcha_error(model, attribute, message)
+        if model
+          model.errors.add(attribute, message)
+        elsif hcaptcha_flash_supported?
+          flash[:hcaptcha_error] = message
+        end
+      end
+
+      def hcaptcha_flash_supported?
+        request.respond_to?(:format) && request.format == :html && respond_to?(:flash)
+      end
+
+      # Extracts response token from params. params['h-captcha-response'] should either be a
+      # string or a hash with the action name(s) as keys. If it is a hash, then `action` is used as
+      # the key.
+      # @return [String] A response token if one was passed in the params; otherwise, `''`
+      def hcaptcha_response_token(action = nil)
+        response_param = params['h-captcha-response']
+        if response_param&.respond_to?(:to_h) # Includes ActionController::Parameters
+          response_param[action].to_s
+        else
+          response_param.to_s
+        end
+      end
+    end
+  end
+end

data/lib/hcaptcha/adapters/view_methods.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Hcaptcha
+  module Adapters
+    module ViewMethods
+      def hcaptcha_tags(options = {})
+        ::Hcaptcha::Helpers.hcaptcha(options)
+      end
+    end
+  end
+end

data/lib/hcaptcha/configuration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Hcaptcha
+  # This class enables detailed configuration of the hcaptcha services.
+  #
+  # By calling
+  #
+  #   Hcaptcha.configuration # => instance of Hcaptcha::Configuration
+  #
+  # or
+  #   Hcaptcha.configure do |config|
+  #     config # => instance of Hcaptcha::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 site and secret key for the hCaptcha 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
+  #
+  #   Hcaptcha.configure do |config|
+  #     config.site_key  = '6Lc6BAAAAAAAAChqRbQZcn_yyyyyyyyyyyyyyyyy'
+  #     config.secret_key = '6Lc6BAAAAAAAAKN3DRm6VA_xxxxxxxxxxxxxxxxx'
+  #   end
+  #
+  class Configuration
+    DEFAULTS = {
+      'server_url' => 'https://hcaptcha.com/1/api.js',
+      'verify_url' => 'https://hcaptcha.com/siteverify'
+    }.freeze
+
+    attr_accessor :default_env, :skip_verify_env, :secret_key, :site_key, :proxy, :handle_timeouts_gracefully, :hostname
+    attr_writer :api_server_url, :verify_url
+
+    def initialize #:nodoc:
+      @default_env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || (Rails.env if defined? Rails.env)
+      @skip_verify_env = %w[test cucumber]
+      @handle_timeouts_gracefully = true
+
+      @secret_key = ENV['HCAPTCHA_SECRET_KEY']
+      @site_key = ENV['HCAPTCHA_SITE_KEY']
+      @verify_url = nil
+      @api_server_url = nil
+    end
+
+    def secret_key!
+      secret_key || raise(HcaptchaError, "No secret key specified.")
+    end
+
+    def site_key!
+      site_key || raise(HcaptchaError, "No site key specified.")
+    end
+
+    def api_server_url
+      @api_server_url || DEFAULTS.fetch('server_url')
+    end
+
+    def verify_url
+      @verify_url || DEFAULTS.fetch('verify_url')
+    end
+  end
+end

data/lib/hcaptcha/helpers.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Hcaptcha
+  module Helpers
+    DEFAULT_ERRORS = {
+      hcaptcha_unreachable: 'Oops, we failed to validate your hCaptcha response. Please try again.',
+      verification_failed: 'hCaptcha verification failed, please try again.'
+    }.freeze
+
+    def self.hcaptcha(options)
+      if options.key?(:stoken)
+        raise(HcaptchaError, "Secure Token is deprecated. Please remove 'stoken' from your calls to hcaptcha_tags.")
+      end
+      if options.key?(:ssl)
+        raise(HcaptchaError, "SSL is now always true. Please remove 'ssl' from your calls to hcaptcha_tags.")
+      end
+
+      html, tag_attributes = components(options.dup)
+      html << %(<div #{tag_attributes}></div>\n)
+
+      html << <<-HTML
+        <div class="h-captcha" data-sitekey="#{Hcaptcha.configuration.site_key!}" data-theme="dark"></div>
+      HTML
+
+      html.respond_to?(:html_safe) ? html.html_safe : html
+    end
+
+    def self.to_error_message(key)
+      default = DEFAULT_ERRORS.fetch(key) { raise ArgumentError "Unknown hCaptcha error - #{key}" }
+      to_message("hcaptcha.errors.#{key}", default)
+    end
+
+    if defined?(I18n)
+      def self.to_message(key, default)
+        I18n.translate(key, default: default)
+      end
+    else
+      def self.to_message(_key, default)
+        default
+      end
+    end
+
+    private_class_method def self.components(options)
+      html = +''
+      attributes = {}
+
+      options = options.dup
+      class_attribute = options.delete(:class)
+      site_key = options.delete(:site_key)
+      hl = options.delete(:hl)
+      onload = options.delete(:onload)
+      render = options.delete(:render)
+      script_async = options.delete(:script_async)
+      script_defer = options.delete(:script_defer)
+      nonce = options.delete(:nonce)
+      skip_script = (options.delete(:script) == false) || (options.delete(:external_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
+
+      site_key ||= Hcaptcha.configuration.site_key!
+      script_url = Hcaptcha.configuration.api_server_url
+      query_params = hash_to_query(
+        hl: hl,
+        onload: onload,
+        render: render
+      )
+      script_url += "?#{query_params}" unless query_params.empty?
+      async_attr = "async" if script_async != false
+      defer_attr = "defer" if script_defer != false
+      nonce_attr = " nonce='#{nonce}'" if nonce
+      html << %(<script src="#{script_url}" #{async_attr} #{defer_attr} #{nonce_attr}></script>\n) unless skip_script
+      attributes["data-sitekey"] = site_key
+      attributes.merge! data_attributes
+
+      # The remaining options will be added as attributes on the tag.
+      attributes["class"] = "hcaptcha #{class_attribute}"
+      tag_attributes = attributes.merge(options).map { |k, v| %(#{k}="#{v}") }.join(" ")
+
+      [html, tag_attributes]
+    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/hcaptcha/rails.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# deprecated, but let's not blow everyone up
+require 'hcaptcha'

data/lib/hcaptcha/railtie.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hcaptcha
+  class Railtie < Rails::Railtie
+    ActiveSupport.on_load(:action_view) do
+      include Hcaptcha::Adapters::ViewMethods
+    end
+
+    ActiveSupport.on_load(:action_controller) do
+      include Hcaptcha::Adapters::ControllerMethods
+    end
+
+    initializer 'hcaptcha' do |app|
+      Hcaptcha::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/hcaptcha/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Hcaptcha
+  VERSION = '7.0.1'
+end

data/rails/locales/en.yml

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

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: hcaptcha
+version: !ruby/object:Gem::Version
+  version: 7.0.1
+platform: ruby
+authors:
+- Christopher Harrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-30 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
+    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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  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: maxitest
+  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: pry-byebug
+  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: 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'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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: rubocop
+  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: Ruby helpers for hCaptcha
+email:
+- chris.harrison@nexusmods.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/hcaptcha.rb
+- lib/hcaptcha/adapters/controller_methods.rb
+- lib/hcaptcha/adapters/view_methods.rb
+- lib/hcaptcha/configuration.rb
+- lib/hcaptcha/helpers.rb
+- lib/hcaptcha/rails.rb
+- lib/hcaptcha/railtie.rb
+- lib/hcaptcha/version.rb
+- rails/locales/en.yml
+homepage: https://github.com/Nexus-Mods/hcaptcha
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Nexus-Mods/hcaptcha
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Ruby helpers for hCaptcha
+test_files: []