acts_as_textcaptcha 4.4.1 → 4.6.0

data/lib/acts_as_textcaptcha/textcaptcha.rb

@@ -1,20 +1,19 @@
-require 'yaml'
-require 'net/http'
-require 'digest/md5'
-require 'acts_as_textcaptcha/textcaptcha_cache'
-require 'acts_as_textcaptcha/textcaptcha_api'
+# frozen_string_literal: true
+
+require "yaml"
+require "net/http"
+require "digest/md5"
+require "acts_as_textcaptcha/textcaptcha_cache"
+require "acts_as_textcaptcha/textcaptcha_api"
 
 module ActsAsTextcaptcha
   module Textcaptcha
-
     def acts_as_textcaptcha(options = nil)
       cattr_accessor :textcaptcha_config
       attr_accessor :textcaptcha_question, :textcaptcha_answer, :textcaptcha_key
 
       # ensure these attrs are accessible (Rails 3)
-      if respond_to?(:accessible_attributes) && respond_to?(:attr_accessible)
-        attr_accessible :textcaptcha_answer, :textcaptcha_key
-      end
+      attr_accessible :textcaptcha_answer, :textcaptcha_key if respond_to?(:accessible_attributes) && respond_to?(:attr_accessible)
 
       self.textcaptcha_config = build_textcaptcha_config(options).symbolize_keys!
 
@@ -24,122 +23,117 @@ module ActsAsTextcaptcha
     end
 
     module InstanceMethods
-
       # override this method to toggle textcaptcha checking, by default this
       # will only allow new records to be protected with textcaptchas
       def perform_textcaptcha?
-        (!respond_to?('new_record?') || new_record?)
+        (!respond_to?("new_record?") || new_record?)
       end
 
       def textcaptcha
-        if perform_textcaptcha? && textcaptcha_config
-          assign_textcaptcha(fetch_q_and_a || config_q_and_a)
-        end
+        assign_textcaptcha(fetch_q_and_a || config_q_and_a) if perform_textcaptcha? && textcaptcha_config
       end
 
-
       private
 
-        def fetch_q_and_a
-          return unless should_fetch?
+      def fetch_q_and_a
+        return unless should_fetch?
 
-          TextcaptchaApi.new(
-            api_key: textcaptcha_config[:api_key],
-            api_endpoint: textcaptcha_config[:api_endpoint],
-            raise_errors: textcaptcha_config[:raise_errors]
-          ).fetch
-        end
+        TextcaptchaApi.new(
+          api_key: textcaptcha_config[:api_key],
+          api_endpoint: textcaptcha_config[:api_endpoint],
+          raise_errors: textcaptcha_config[:raise_errors]
+        ).fetch
+      end
 
-        def should_fetch?
-          textcaptcha_config[:api_key] || textcaptcha_config[:api_endpoint]
-        end
+      def should_fetch?
+        textcaptcha_config[:api_key] || textcaptcha_config[:api_endpoint]
+      end
 
-        def config_q_and_a
-          if textcaptcha_config[:questions]
-            random_question = textcaptcha_config[:questions][rand(textcaptcha_config[:questions].size)].symbolize_keys!
-            answers = (random_question[:answers] || '').split(',').map!{ |answer| safe_md5(answer) }
-            if random_question && answers.present?
-              { 'q' => random_question[:question], 'a' => answers }
-            end
-          end
-        end
+      def config_q_and_a
+        return unless textcaptcha_config[:questions]
 
-        # check textcaptcha, if incorrect, generate a new textcaptcha
-        def validate_textcaptcha
-          valid_answers = textcaptcha_cache.read(textcaptcha_key) || []
-          reset_textcaptcha
-          if valid_answers.include?(safe_md5(textcaptcha_answer))
-            # answer was valid, mutate the key again
-            self.textcaptcha_key = textcaptcha_random_key
-            textcaptcha_cache.write(textcaptcha_key, valid_answers, textcaptcha_cache_options)
-            true
-          else
-            add_textcaptcha_error(too_slow: valid_answers.empty?)
-            textcaptcha
-            false
-          end
-        end
+        random_question = textcaptcha_config[:questions][rand(textcaptcha_config[:questions].size)].symbolize_keys!
+        answers = (random_question[:answers] || "").split(",").map { |answer| safe_md5(answer) }
+        { "q" => random_question[:question], "a" => answers } if random_question && answers.present?
+      end
 
-        def add_textcaptcha_error(too_slow: false)
-          if too_slow
-            errors.add(:textcaptcha_answer, :expired, :message => 'was not submitted quickly enough, try another question instead')
-          else
-            errors.add(:textcaptcha_answer, :incorrect, :message => 'is incorrect, try another question instead')
-          end
+      # check textcaptcha, if incorrect, generate a new textcaptcha
+      def validate_textcaptcha
+        valid_answers = textcaptcha_cache.read(textcaptcha_key) || []
+        reset_textcaptcha
+        if valid_answers.include?(safe_md5(textcaptcha_answer))
+          # answer was valid, mutate the key again
+          self.textcaptcha_key = textcaptcha_random_key
+          textcaptcha_cache.write(textcaptcha_key, valid_answers, textcaptcha_cache_options)
+          true
+        else
+          add_textcaptcha_error(too_slow: valid_answers.empty?)
+          textcaptcha
+          false
         end
+      end
 
-        def reset_textcaptcha
-          if textcaptcha_key
-            textcaptcha_cache.delete(textcaptcha_key)
-            self.textcaptcha_key = nil
-          end
+      def add_textcaptcha_error(too_slow: false)
+        if too_slow
+          errors.add(:textcaptcha_answer, :expired, message: "was not submitted quickly enough, try another question instead")
+        else
+          errors.add(:textcaptcha_answer, :incorrect, message: "is incorrect, try another question instead")
         end
+      end
 
-        def assign_textcaptcha(q_and_a)
-          return unless q_and_a
-          self.textcaptcha_question = q_and_a['q']
-          self.textcaptcha_key = textcaptcha_random_key
-          textcaptcha_cache.write(textcaptcha_key, q_and_a['a'], textcaptcha_cache_options)
+      def reset_textcaptcha
+        if textcaptcha_key
+          textcaptcha_cache.delete(textcaptcha_key)
+          self.textcaptcha_key = nil
         end
+      end
 
-        # strip whitespace pass through mb_chars (a multibyte safe proxy for
-        # strings) then downcase
-        def safe_md5(answer)
-          Digest::MD5.hexdigest(answer.to_s.strip.mb_chars.downcase)
-        end
+      def assign_textcaptcha(q_and_a)
+        return unless q_and_a
 
-        # a random cache key, time based, random
-        def textcaptcha_random_key
-          safe_md5(Time.now.to_i + rand(1_000_000))
-        end
+        self.textcaptcha_question = q_and_a["q"]
+        self.textcaptcha_key = textcaptcha_random_key
+        textcaptcha_cache.write(textcaptcha_key, q_and_a["a"], textcaptcha_cache_options)
+      end
 
-        def textcaptcha_cache_options
-          if textcaptcha_config[:cache_expiry_minutes]
-            { :expires_in => textcaptcha_config[:cache_expiry_minutes].to_f.minutes }
-          else
-            {}
-          end
-        end
+      # strip whitespace pass through mb_chars (a multibyte safe proxy for
+      # strings) then downcase
+      def safe_md5(answer)
+        Digest::MD5.hexdigest(answer.to_s.strip.mb_chars.downcase)
+      end
+
+      # a random cache key, time based, random
+      def textcaptcha_random_key
+        safe_md5(Time.now.to_i + rand(1_000_000))
+      end
 
-        def textcaptcha_cache
-          @@textcaptcha_cache ||= TextcaptchaCache.new
+      def textcaptcha_cache_options
+        if textcaptcha_config[:cache_expiry_minutes]
+          { expires_in: textcaptcha_config[:cache_expiry_minutes].to_f.minutes }
+        else
+          {}
         end
+      end
+
+      def textcaptcha_cache
+        @textcaptcha_cache ||= TextcaptchaCache.new
+      end
     end
 
     private
 
-      def build_textcaptcha_config(options)
-        if options.is_a?(Hash)
-          options
-        else
-          YAML.load(ERB.new(read_textcaptcha_config).result)[Rails.env]
-        end
-      rescue
-        raise ArgumentError.new('could not find any textcaptcha options, in config/textcaptcha.yml or model - run rake textcaptcha:config to generate a template config file')
+    def build_textcaptcha_config(options)
+      if options.is_a?(Hash)
+        options
+      else
+        YAML.safe_load(ERB.new(read_textcaptcha_config).result, aliases: true)[Rails.env]
       end
+    rescue StandardError
+      raise ArgumentError, "could not find any textcaptcha options, in config/textcaptcha.yml or model - run rake textcaptcha:config to generate a template config file"
+    end
 
-      def read_textcaptcha_config
-        File.read("#{Rails.root ? Rails.root : '.'}/config/textcaptcha.yml")
-      end
+    def read_textcaptcha_config
+      File.read("#{Rails.root || "."}/config/textcaptcha.yml")
+    end
   end
 end

data/lib/acts_as_textcaptcha/textcaptcha_api.rb

@@ -1,19 +1,20 @@
-require 'json'
+# frozen_string_literal: true
+
+require "json"
 
 module ActsAsTextcaptcha
   class TextcaptchaApi
-
-    BASE_URL = 'http://textcaptcha.com'
+    BASE_URL = "http://textcaptcha.com"
 
     def initialize(api_key: nil, api_endpoint: nil, raise_errors: false)
-      if api_endpoint
-        self.uri = URI(api_endpoint)
-      else
-        self.uri = URI("#{BASE_URL}/#{api_key}.json")
-      end
+      self.uri = if api_endpoint
+                   URI(api_endpoint)
+                 else
+                   URI("#{BASE_URL}/#{api_key}.json")
+                 end
       self.raise_errors = raise_errors || false
-    rescue URI::InvalidURIError => exception
-      raise ApiKeyError.new(api_key, exception)
+    rescue URI::InvalidURIError => e
+      raise ApiKeyError.new(api_key, e)
     end
 
     def fetch
@@ -22,35 +23,33 @@ module ActsAsTextcaptcha
 
     private
 
-      attr_accessor :uri, :raise_errors
-
-      def get
-        response = Net::HTTP.new(uri.host, uri.port).get(uri.path)
-        if response.code == '200'
-          response.body
-        else
-          handle_error ResponseError.new(uri, "status: #{response.code}")
-        end
-      rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
-        Errno::EHOSTUNREACH, EOFError, Errno::ECONNREFUSED, Errno::ETIMEDOUT,
-        Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
-        Net::ProtocolError => exception
-        handle_error ResponseError.new(uri, exception)
-      end
+    attr_accessor :uri, :raise_errors
 
-      def parse(response)
-        JSON.parse(response) unless response.empty?
-      rescue JSON::ParserError
-        handle_error ParseError.new(uri)
+    def get
+      response = Net::HTTP.new(uri.host, uri.port).get(uri.path)
+      if response.code == "200"
+        response.body
+      else
+        handle_error ResponseError.new(uri, "status: #{response.code}")
       end
+    rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
+           Errno::EHOSTUNREACH, EOFError, Errno::ECONNREFUSED, Errno::ETIMEDOUT,
+           Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+           Net::ProtocolError => e
+      handle_error ResponseError.new(uri, e)
+    end
 
-      def handle_error(error)
-        if raise_errors
-          raise error
-        else
-          Rails.logger.error("#{error.class} #{error.message}")
-          nil
-        end
-      end
+    def parse(response)
+      JSON.parse(response) unless response.empty?
+    rescue JSON::ParserError
+      handle_error ParseError.new(uri)
+    end
+
+    def handle_error(error)
+      raise error if raise_errors
+
+      Rails.logger.error("#{error.class} #{error.message}")
+      nil
+    end
   end
 end

data/lib/acts_as_textcaptcha/textcaptcha_cache.rb

@@ -1,16 +1,15 @@
+# frozen_string_literal: true
+
 # A simple cache for storing Textcaptcha answers, Rails.cache is used as the
-# backend (ActiveSupport::Cache)
+# backend (ActiveSupport::Cache). This must not be set as a `:null_store`.
 
 module ActsAsTextcaptcha
   class TextcaptchaCache
-
-    KEY_PREFIX = 'acts_as_textcaptcha-'
+    KEY_PREFIX = "acts_as_textcaptcha-"
     DEFAULT_EXPIRY_MINUTES = 10
 
     def write(key, value, options = {})
-      unless options.has_key?(:expires_in)
-        options[:expires_in] = DEFAULT_EXPIRY_MINUTES.minutes
-      end
+      options[:expires_in] = DEFAULT_EXPIRY_MINUTES.minutes unless options.has_key?(:expires_in)
       Rails.cache.write(cache_key(key), value, options)
     end
 
@@ -24,8 +23,8 @@ module ActsAsTextcaptcha
 
     private
 
-      def cache_key(key)
-        "#{KEY_PREFIX}#{key}"
-      end
+    def cache_key(key)
+      "#{KEY_PREFIX}#{key}"
+    end
   end
 end

data/lib/acts_as_textcaptcha/textcaptcha_config.rb

@@ -1,46 +1,47 @@
+# frozen_string_literal: true
+
 module ActsAsTextcaptcha
   class TextcaptchaConfig
+    YAML = <<~CONFIG
+      development: &common_settings
+        api_key: 'TEXTCAPTCHA_API_IDENT' # see https://textcaptcha.com for details
+        # api_endpoint: nil        # Optional API URL to fetch questions and answers from
+        # raise_errors: false      # Optional flag, if true errors will be raised if the API endpoint fails
+        # cache_expiry_minutes: 10 # Optional minutes for captcha answers to persist in the cache (default 10 minutes)
 
-    YAML = <<-CONFIG
-development: &common_settings
-  api_key: 'TEXTCAPTCHA_API_IDENT' # see http://textcaptcha.com for details
-  # api_endpoint: nil        # Optional API URL to fetch questions and answers from
-  # raise_errors: false      # Optional flag, if true errors will be raised if the API endpoint fails
-  # cache_expiry_minutes: 10 # Optional minutes for captcha answers to persist in the cache (default 10 minutes)
-
-  questions:
-      - question: 'Is ice hot or cold?'
-        answers: 'cold'
-      - question: 'what color is an orange?'
-        answers: 'orange'
-      - question: 'what is two plus 3?'
-        answers: '5,five'
-      - question: 'what is 5 times two?'
-        answers: '10,ten'
-      - question: 'How many colors in the list, green, brown, foot and blue?'
-        answers: '3,three'
-      - question: 'what is Georges name?'
-        answers: 'george'
-      - question: '11 minus 1?'
-        answers: '10,ten'
-      - question: 'is boiling water hot or cold?'
-        answers: 'hot'
-      - question: 'what color is my blue shirt today?'
-        answers: 'blue'
-      - question: 'what is 16 plus 4?'
-        answers: '20,twenty'
+        questions:
+            - question: 'Is ice hot or cold?'
+              answers: 'cold'
+            - question: 'what color is an orange?'
+              answers: 'orange'
+            - question: 'what is two plus 3?'
+              answers: '5,five'
+            - question: 'what is 5 times two?'
+              answers: '10,ten'
+            - question: 'How many colors in the list, green, brown, foot and blue?'
+              answers: '3,three'
+            - question: 'what is Georges name?'
+              answers: 'george'
+            - question: '11 minus 1?'
+              answers: '10,ten'
+            - question: 'is boiling water hot or cold?'
+              answers: 'hot'
+            - question: 'what color is my blue shirt today?'
+              answers: 'blue'
+            - question: 'what is 16 plus 4?'
+              answers: '20,twenty'
 
-test:
-  <<: *common_settings
-  api_key: 'TEST_TEXTCAPTCHA_API_IDENT'
+      test:
+        <<: *common_settings
+        api_key: 'TEST_TEXTCAPTCHA_API_IDENT'
 
-production:
-  <<: *common_settings
-CONFIG
+      production:
+        <<: *common_settings
+    CONFIG
 
-    def self.create(path: './config/textcaptcha.yml')
+    def self.create(path: "./config/textcaptcha.yml")
       FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, 'w') { |f| f.write(YAML) }
+      File.write(path, YAML)
     end
   end
 end

data/lib/acts_as_textcaptcha/textcaptcha_helper.rb

@@ -1,22 +1,21 @@
+# frozen_string_literal: true
+
 module ActsAsTextcaptcha
   module TextcaptchaHelper
-
-    def textcaptcha_fields(f, &block)
-      if f.object.perform_textcaptcha? && f.object.textcaptcha_key
-        build_textcaptcha_form_elements(f, &block)
-      end
+    def textcaptcha_fields(form, &block)
+      build_textcaptcha_form_elements(form, &block) if form.object.perform_textcaptcha? && form.object.textcaptcha_key
     end
 
     private
 
-      def build_textcaptcha_form_elements(f, &block)
-        captcha_html = f.hidden_field(:textcaptcha_key)
-        if f.object.textcaptcha_question
-          captcha_html += capture(&block)
-        elsif f.object.textcaptcha_answer
-          captcha_html += f.hidden_field(:textcaptcha_answer)
-        end
-        captcha_html.html_safe
+    def build_textcaptcha_form_elements(form, &block)
+      captcha_html = form.hidden_field(:textcaptcha_key)
+      if form.object.textcaptcha_question
+        captcha_html += capture(&block)
+      elsif form.object.textcaptcha_answer
+        captcha_html += form.hidden_field(:textcaptcha_answer)
       end
+      captcha_html.html_safe
+    end
   end
 end

data/lib/acts_as_textcaptcha/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTextcaptcha
-  VERSION = '4.4.1'
+  VERSION = "4.6.0"
 end

data/lib/acts_as_textcaptcha.rb

@@ -1,6 +1,9 @@
-require 'acts_as_textcaptcha/version'
-require 'acts_as_textcaptcha/errors'
-require 'acts_as_textcaptcha/textcaptcha'
-require 'acts_as_textcaptcha/textcaptcha_config'
-require 'acts_as_textcaptcha/textcaptcha_helper'
-require 'acts_as_textcaptcha/framework/rails'
+# frozen_string_literal: true
+
+require "acts_as_textcaptcha/version"
+require "acts_as_textcaptcha/errors"
+require "acts_as_textcaptcha/textcaptcha"
+require "acts_as_textcaptcha/textcaptcha_config"
+require "acts_as_textcaptcha/textcaptcha_helper"
+require "acts_as_textcaptcha/framework/rails"
+require "acts_as_textcaptcha/railtie" if defined?(Rails::Railtie)