acts_as_textcaptcha 4.2.0 → 4.5.2

data/Rakefile

@@ -1,32 +1,39 @@
-require 'rubygems'
-require 'bundler/gem_tasks'
-require 'rake/testtask'
+# frozen_string_literal: true
 
-gem 'rdoc'
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rdoc/task"
+require "rubocop/rake_task"
 
+# generate docs
+RDoc::Task.new do |rd|
+  rd.main = "README.md"
+  rd.title = "ActsAsTextcaptcha"
+  rd.rdoc_dir = "doc"
+  rd.options << "--all"
+  rd.rdoc_files.include("README.md", "LICENSE", "lib/**/*.rb")
+end
+
+# run tests
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList['test/**/*_test.rb']
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :default => [:test]
+# run lint
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options = ["--display-cop-names"]
+end
 
-# code coverage
+# run tests with code coverage (default)
 namespace :test do
-  desc "Run all tests and generate a code coverage report (simplecov)"
+  desc "Run all tests and features and generate a code coverage report"
   task :coverage do
-    ENV['COVERAGE'] = 'true'
-    Rake::Task['test'].execute
+    ENV["COVERAGE"] = "true"
+    Rake::Task["test"].execute
+    Rake::Task["rubocop"].execute
   end
 end
 
-# rdoc tasks
-require 'rdoc/task'
-RDoc::Task.new do |rd|
-  rd.main     = "README.md"
-  rd.title    = 'acts_as_textcaptcha'
-  rd.rdoc_dir = 'doc'
-  rd.options  << "--all"
-  rd.rdoc_files.include("README.md", "LICENSE.txt", "lib/**/*.rb")
-end
+task default: [:rubocop, "test:coverage"]

data/acts_as_textcaptcha.gemspec

@@ -1,45 +1,61 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "acts_as_textcaptcha/version"
 
-Gem::Specification.new do |s|
-  s.name        = "acts_as_textcaptcha"
-  s.version     = ActsAsTextcaptcha::VERSION
-  s.authors     = ["Matthew Hutchinson"]
-  s.email       = ["matt@hiddenloop.com"]
-  s.homepage    = "http://github.com/matthutchinson/acts_as_textcaptcha"
-  s.license     = 'MIT'
-  s.summary     = %q{Spam protection for your models via logic questions and the textcaptcha.com API}
-
-  s.description = %q{Simple question/answer based spam protection for your Rails models.
-  You can define your own logic questions and/or fetch questions from the textcaptcha.com API.
-  The questions involve human logic and are tough for spam bots to crack.
-  For more reasons on why logic questions are a good idea visit; http://textcaptcha.com/why}
-
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the
-  # 'allowed_push_host' to allow pushing to a single host or delete this section
-  # to allow pushing to any host.
-  if s.respond_to?(:metadata)
-    s.metadata['allowed_push_host'] = "https://rubygems.org"
-  else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
-  end
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test}/*`.split("\n")
-  s.require_paths = ["lib"]
-
-  # always test against latest rails version
-  s.add_development_dependency('rails', '~> 5.1.4')
-
-  s.add_development_dependency('mime-types')
-  s.add_development_dependency('bundler')
-  s.add_development_dependency('minitest')
-  s.add_development_dependency('simplecov')
-  s.add_development_dependency('rdoc')
-  s.add_development_dependency('sqlite3')
-  s.add_development_dependency('webmock')
-  s.add_development_dependency('coveralls')
-  s.add_development_dependency('appraisal')
+Gem::Specification.new do |spec|
+  spec.name = "acts_as_textcaptcha"
+  spec.version = ActsAsTextcaptcha::VERSION
+  spec.authors = ["Matthew Hutchinson"]
+  spec.email = ["matt@hiddenloop.com"]
+  spec.homepage = "http://github.com/matthutchinson/acts_as_textcaptcha"
+  spec.license = "MIT"
+  spec.summary = "A text-based logic question captcha for Rails"
+
+  spec.description = <<-DESCRIPTION
+  ActsAsTextcaptcha provides spam protection for Rails models with text-based
+  logic question captchas. Questions are fetched from Rob Tuley's
+  textcaptcha.com They can be solved easily by humans but are tough for robots
+  to crack.
+  DESCRIPTION
+
+  spec.metadata = {
+    "homepage_uri" => "https://github.com/matthutchinson/acts_as_textcaptcha",
+    "changelog_uri" => "https://github.com/matthutchinson/acts_as_textcaptcha/blob/master/CHANGELOG.md",
+    "source_code_uri" => "https://github.com/matthutchinson/acts_as_textcaptcha",
+    "bug_tracker_uri" => "https://github.com/matthutchinson/acts_as_textcaptcha/issues",
+    "allowed_push_host" => "https://rubygems.org"
+  }
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files = `git ls-files -- {test}/*`.split("\n")
+  spec.bindir = "bin"
+  spec.require_paths = ["lib"]
+
+  # documentation
+  spec.extra_rdoc_files = ["README.md", "LICENSE"]
+  spec.rdoc_options << "--title" << "ActAsTextcaptcha" << "--main" << "README.md" << "-ri"
+
+  # non-gem dependecies
+  spec.required_ruby_version = ">= 2.5"
+
+  # dev gems
+  spec.add_development_dependency("bundler")
+  spec.add_development_dependency("pry-byebug")
+  spec.add_development_dependency "rake"
+
+  # Lint
+  spec.add_development_dependency("rubocop")
+
+  # docs
+  spec.add_development_dependency("rdoc")
+
+  # testing
+  spec.add_development_dependency("appraisal")
+  spec.add_development_dependency("minitest")
+  spec.add_development_dependency("rails", "~> 6.0.3.4")
+  spec.add_development_dependency("simplecov", "~> 0.19.1")
+  spec.add_development_dependency("sqlite3")
+  spec.add_development_dependency("webmock")
 end

data/bin/console

@@ -1,11 +1,8 @@
 #!/usr/bin/env ruby
 
 require "bundler/setup"
+require "rails/all"
 require "acts_as_textcaptcha"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# start irb
 require "irb"
+
 IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+bundle exec rake rdoc

data/gemfiles/rails_3.gemfile

@@ -3,5 +3,6 @@
 source "https://rubygems.org"
 
 gem "rails", "3.2.22.5"
+gem "sqlite3", "~> 1.3.5"
 
 gemspec path: "../"

data/gemfiles/rails_4.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", "4.2.10"
+gem "rails", "4.2.11.3"
+gem "sqlite3", "~> 1.3.5"
 
 gemspec path: "../"

data/gemfiles/rails_5.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "rails", "5.1.4"
+gem "rails", "5.2.4.4"
+gem "sqlite3", "~> 1.4.2"
 
 gemspec path: "../"

data/gemfiles/rails_6.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "6.1.1"
+gem "sqlite3", "~> 1.4.2"
+
+gemspec path: "../"

data/lib/acts_as_textcaptcha.rb

@@ -1,4 +1,9 @@
-require 'acts_as_textcaptcha/version'
-require 'acts_as_textcaptcha/textcaptcha'
-require 'acts_as_textcaptcha/textcaptcha_helper'
-require 'acts_as_textcaptcha/framework/rails' if defined?(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)

data/lib/acts_as_textcaptcha/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActsAsTextcaptcha
+  class ResponseError < StandardError
+    def initialize(url, exception)
+      super("fetching '#{url}' failed - #{exception}")
+    end
+  end
+
+  class ApiKeyError < StandardError
+    def initialize(api_key, exception)
+      super("Api key '#{api_key}' is invalid - #{exception}")
+    end
+  end
+
+  class ParseError < StandardError
+    def initialize(url)
+      super("parsing JSON from '#{url}' failed")
+    end
+  end
+end

data/lib/acts_as_textcaptcha/framework/rails.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 ActiveSupport.on_load(:active_record) do
   extend ActsAsTextcaptcha::Textcaptcha
 end
 
 ActiveSupport.on_load(:action_view) do
   include ActsAsTextcaptcha::TextcaptchaHelper
-end                                                           
+end

data/lib/acts_as_textcaptcha/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActsAsTextcaptcha
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__), "/tasks/*.rake")].each { |f| load f }
+    end
+  end
+end

data/lib/acts_as_textcaptcha/tasks/textcaptcha.rake

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails"
+require "acts_as_textcaptcha/textcaptcha_config"
+
+namespace :textcaptcha do
+  desc "Creates an example textcaptcha config at config/textcaptcha.yml"
+  task :config do
+    path = File.join((Rails.root || "."), "config", "textcaptcha.yml")
+    if File.exist?(path)
+      puts "Ooops, a textcaptcha config file at #{path} already exists ... aborting."
+    else
+      ActsAsTextcaptcha::TextcaptchaConfig.create(path: path)
+      puts "Done, config generated at #{path}\nEdit this file to add your TextCaptcha API key (see https://textcaptcha.com)."
+    end
+  end
+end

data/lib/acts_as_textcaptcha/textcaptcha.rb

@@ -1,80 +1,63 @@
-require 'yaml'
-require 'net/http'
-require 'digest/md5'
-require 'acts_as_textcaptcha/textcaptcha_cache'
-require 'acts_as_textcaptcha/textcaptcha_api'
+# frozen_string_literal: true
 
-module ActsAsTextcaptcha
-
-  module Textcaptcha #:nodoc:
+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
+      attr_accessor :textcaptcha_question, :textcaptcha_answer, :textcaptcha_key
 
-      # Rails 3, ensure these attrs are accessible
-      if respond_to?(:accessible_attributes) && respond_to?(:attr_accessible)
-        attr_accessible :textcaptcha_answer, :textcaptcha_key
-      end
+      # ensure these attrs are accessible (Rails 3)
+      attr_accessible :textcaptcha_answer, :textcaptcha_key if respond_to?(:accessible_attributes) && respond_to?(:attr_accessible)
 
-      validate :validate_textcaptcha, :if => :perform_textcaptcha?
+      self.textcaptcha_config = build_textcaptcha_config(options).symbolize_keys!
 
-      if options.is_a?(Hash)
-        self.textcaptcha_config = options.symbolize_keys!
-      else
-        begin
-          self.textcaptcha_config = YAML.load(File.read("#{Rails.root ? Rails.root.to_s : '.'}/config/textcaptcha.yml"))[Rails.env].symbolize_keys!
-        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')
-        end
-      end
+      validate :validate_textcaptcha, if: :perform_textcaptcha?
 
       include InstanceMethods
     end
 
-
     module InstanceMethods
-
-      # override this method to toggle textcaptcha checking
-      # by default this will only allow new records to be
-      # protected with textcaptchas
+      # 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
 
-      # generate and assign textcaptcha
       def textcaptcha
-        if perform_textcaptcha? && textcaptcha_config
-          question = answers = nil
-
-          # get textcaptcha from api
-          if textcaptcha_config[:api_key]
-            question, answers = TextcaptchaApi.fetch(textcaptcha_config[:api_key], textcaptcha_config)
-          end
-
-          # fall back to config based textcaptcha
-          unless question && answers
-            question, answers = textcaptcha_config_questions
-          end
-
-          if question && answers
-            assign_textcaptcha(question, answers)
-          end
-        end
+        assign_textcaptcha(fetch_q_and_a || config_q_and_a) if perform_textcaptcha? && textcaptcha_config
       end
 
-
       private
 
-      def textcaptcha_config_questions
-        if textcaptcha_config[:questions]
-          random_question = textcaptcha_config[:questions][rand(textcaptcha_config[:questions].size)].symbolize_keys!
-          [random_question[:question], (random_question[:answers] || '').split(',').map!{ |answer| safe_md5(answer) }]
-        end
+      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
+
+      def should_fetch?
+        textcaptcha_config[:api_key] || textcaptcha_config[:api_endpoint]
       end
 
+      def config_q_and_a
+        return unless textcaptcha_config[:questions]
 
-      # check textcaptcha, if incorrect, regenerate a new textcaptcha
+        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
+
+      # check textcaptcha, if incorrect, generate a new textcaptcha
       def validate_textcaptcha
         valid_answers = textcaptcha_cache.read(textcaptcha_key) || []
         reset_textcaptcha
@@ -84,18 +67,20 @@ module ActsAsTextcaptcha
           textcaptcha_cache.write(textcaptcha_key, valid_answers, textcaptcha_cache_options)
           true
         else
-          if valid_answers.empty?
-            # took too long to answer
-            errors.add(:textcaptcha_answer, :expired, :message => 'was not submitted quickly enough, try another question instead')
-          else
-            # incorrect answer
-            errors.add(:textcaptcha_answer, :incorrect, :message => 'is incorrect, try another question instead')
-          end
+          add_textcaptcha_error(too_slow: valid_answers.empty?)
           textcaptcha
           false
         end
       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 reset_textcaptcha
         if textcaptcha_key
           textcaptcha_cache.delete(textcaptcha_key)
@@ -103,36 +88,54 @@ module ActsAsTextcaptcha
         end
       end
 
-      def assign_textcaptcha(question, answers)
-        self.textcaptcha_question = question
-        self.textcaptcha_key      = textcaptcha_random_key
-        textcaptcha_cache.write(textcaptcha_key, answers, textcaptcha_cache_options)
+      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)
       end
 
-      # strip whitespace pass through mb_chars (a multibyte
-      # safe proxy for string methods) then downcase
+      # 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 and random
+      # 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_options
         if textcaptcha_config[:cache_expiry_minutes]
-          { :expires_in => textcaptcha_config[:cache_expiry_minutes].to_f.minutes }
+          { expires_in: textcaptcha_config[:cache_expiry_minutes].to_f.minutes }
         else
           {}
         end
       end
 
-      # cache is used to persist textcaptcha questions and answers
-      # between requests
       def textcaptcha_cache
-        @@textcaptcha_cache ||= TextcaptchaCache.new
+        @textcaptcha_cache ||= TextcaptchaCache.new
       end
     end
+
+    private
+
+    # rubocop:disable Security/YAMLLoad
+    def build_textcaptcha_config(options)
+      if options.is_a?(Hash)
+        options
+      else
+        YAML.load(ERB.new(read_textcaptcha_config).result)[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
+    # rubocop:enable Security/YAMLLoad
+
+    def read_textcaptcha_config
+      File.read("#{Rails.root || "."}/config/textcaptcha.yml")
+    end
   end
 end