verify_it 0.3.0 → 0.4.1.beta

data/lib/verify_it/verifier.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/security_utils"
+
 module VerifyIt
   class Verifier
     attr_reader :storage, :rate_limiter
@@ -10,157 +12,142 @@ module VerifyIt
     end
 
     def send_code(to:, record:, channel: nil, context: {})
-      channel ||= VerifyIt.configuration.delivery_channel
-
-      # Check send rate limit
-      limit_check = rate_limiter.check_send_limit(identifier: to, record: record)
-      unless limit_check[:allowed]
-        return Result.new(
-          success: false,
-          error: :rate_limited,
-          message: limit_check[:reason],
-          rate_limited: true
-        )
+      channel ||= config.delivery_channel
+
+      rate_limit_result = check_send_rate_limits(to: to, record: record)
+      return rate_limit_result if rate_limit_result
+
+      code_data = generate_and_store_code(to: to, record: record)
+
+      delivery_result = attempt_delivery(
+        to: to,
+        code: code_data[:code],
+        channel: channel,
+        context: context
+      )
+      return delivery_result if delivery_result
+
+      finalize_send(to: to, record: record, channel: channel, code_data: code_data)
+    end
+
+    def verify_code(to:, code:, record:, request: nil)
+      rate_limit_result = check_verification_rate_limit(to: to, record: record)
+      return rate_limit_result if rate_limit_result
+
+      stored_code = storage.fetch_code(identifier: to, record: record)
+      return code_not_found_result unless stored_code
+
+      current_attempts = rate_limiter.record_verification_attempt(identifier: to, record: record)
+
+      if code_matches?(code, stored_code)
+        handle_verification_success(to: to, record: record, attempts: current_attempts, request: request)
+      else
+        handle_verification_failure(to: to, record: record, attempts: current_attempts)
       end
+    end
+
+    def cleanup(to:, record:)
+      storage.cleanup(identifier: to, record: record)
+      success_result("Verification data cleaned up")
+    end
+
+    private
+
+    def config
+      VerifyIt.configuration
+    end
+
+    def check_send_rate_limits(to:, record:)
+      send_limit = rate_limiter.check_send_limit(identifier: to, record: record)
+      return rate_limited_result(send_limit[:reason]) unless send_limit[:allowed]
 
-      # Check identifier change limit
       change_limit = rate_limiter.check_identifier_change_limit(record: record)
-      unless change_limit[:allowed]
-        return Result.new(
-          success: false,
-          error: :rate_limited,
-          message: change_limit[:reason],
-          rate_limited: true
-        )
-      end
+      return rate_limited_result(change_limit[:reason]) unless change_limit[:allowed]
 
-      # Generate code
+      nil
+    end
+
+    def check_verification_rate_limit(to:, record:)
+      limit_check = rate_limiter.check_verification_limit(identifier: to, record: record)
+      return nil if limit_check[:allowed]
+
+      locked_result(
+        limit_check[:reason],
+        attempts: storage.attempts(identifier: to, record: record)
+      )
+    end
+
+    def generate_and_store_code(to:, record:)
       code = CodeGenerator.generate(
-        length: VerifyIt.configuration.code_length,
-        format: VerifyIt.configuration.code_format
+        length: config.code_length,
+        format: config.code_format
       )
-      expires_at = Time.now + VerifyIt.configuration.code_ttl
+      expires_at = Time.now + config.code_ttl
+      hashed_code = CodeHasher.digest(code, secret: config.secret_key_base)
 
-      # Store hashed code
-      hashed_code = CodeHasher.digest(code, secret: VerifyIt.configuration.secret_key_base)
       storage.store_code(
         identifier: to,
         record: record,
         code: hashed_code,
         expires_at: expires_at
       )
-
-      # Reset verification attempts for new code
       storage.reset_attempts(identifier: to, record: record)
 
-      # Record send attempt
-      rate_limiter.record_send(identifier: to, record: record)
-
-      # Track identifier change if needed
-      rate_limiter.record_identifier_change(record: record, identifier: to)
+      { code: code, expires_at: expires_at }
+    end
 
-      # Deliver code
-      begin
-        delivery = get_delivery_adapter(channel)
-        delivery.deliver(to: to, code: code, context: context)
-      rescue StandardError => e
-        return Result.new(
-          success: false,
-          error: :delivery_failed,
-          message: "Failed to deliver verification code: #{e.message}"
-        )
-      end
+    def attempt_delivery(to:, code:, channel:, context:)
+      delivery = get_delivery_adapter(channel)
+      delivery.deliver(to: to, code: code, context: context)
+      nil
+    rescue StandardError => e
+      delivery_failed_result
+    end
 
-      # Call on_send callback if configured
-      callback = VerifyIt.configuration.on_send
-      callback&.call(record: record, identifier: to, channel: channel)
+    def finalize_send(to:, record:, channel:, code_data:)
+      rate_limiter.record_send(identifier: to, record: record)
+      rate_limiter.record_identifier_change(record: record, identifier: to)
 
-      # Build result
-      result_data = {
-        success: true,
-        message: "Verification code sent successfully",
-        expires_at: expires_at
-      }
+      invoke_callback(config.on_send, record: record, identifier: to, channel: channel)
 
-      # Include code in test mode
-      result_data[:code] = code if VerifyIt.configuration.test_mode
+      build_send_success_result(code_data)
+    end
 
-      Result.new(**result_data)
+    def code_matches?(code, stored_code)
+      ActiveSupport::SecurityUtils.secure_compare(
+        stored_code,
+        CodeHasher.digest(code, secret: config.secret_key_base)
+      )
     end
 
-    def verify_code(to:, code:, record:)
-      # Check verification rate limit
-      limit_check = rate_limiter.check_verification_limit(identifier: to, record: record)
-      unless limit_check[:allowed]
-        return Result.new(
-          success: false,
-          error: :locked,
-          message: limit_check[:reason],
-          locked: true,
-          attempts: storage.attempts(identifier: to, record: record)
-        )
-      end
+    def handle_verification_success(to:, record:, attempts:, request: nil)
+      storage.delete_code(identifier: to, record: record)
+      storage.reset_attempts(identifier: to, record: record)
+      storage.reset_send_count(identifier: to, record: record)
 
-      # Fetch stored code
-      stored_code = storage.fetch_code(identifier: to, record: record)
+      invoke_callback(config.on_verify_success, record: record, identifier: to, request: request)
 
-      unless stored_code
-        return Result.new(
-          success: false,
-          error: :code_not_found,
-          message: "No verification code found or code has expired"
-        )
-      end
+      success_result("Verification successful", verified: true, attempts: attempts)
+    end
 
-      # Increment attempts
-      current_attempts = rate_limiter.record_verification_attempt(identifier: to, record: record)
+    def handle_verification_failure(to:, record:, attempts:)
+      max_attempts = config.max_verification_attempts
+      locked = attempts >= max_attempts
 
-      # Verify code
-      if stored_code == CodeHasher.digest(code, secret: VerifyIt.configuration.secret_key_base)
-        # Success - cleanup
-        storage.delete_code(identifier: to, record: record)
-        storage.reset_attempts(identifier: to, record: record)
-        storage.reset_send_count(identifier: to, record: record)
-
-        # Call success callback if configured
-        callback = VerifyIt.configuration.on_verify_success
-        callback&.call(record: record, identifier: to)
-
-        Result.new(
-          success: true,
-          message: "Verification successful",
-          verified: true,
-          attempts: current_attempts
-        )
-      else
-        # Failure
-        max_attempts = VerifyIt.configuration.max_verification_attempts
-        locked = current_attempts >= max_attempts
-
-        # Call failure callback if configured
-        callback = VerifyIt.configuration.on_verify_failure
-        callback&.call(record: record, identifier: to, attempts: current_attempts)
-
-        Result.new(
-          success: false,
-          error: :invalid_code,
-          message: locked ? "Maximum verification attempts exceeded" : "Invalid verification code",
-          attempts: current_attempts,
-          locked: locked
-        )
-      end
-    end
+      invoke_callback(
+        config.on_verify_failure,
+        record: record,
+        identifier: to,
+        attempts: attempts
+      )
 
-    def cleanup(to:, record:)
-      storage.cleanup(identifier: to, record: record)
-      Result.new(
-        success: true,
-        message: "Verification data cleaned up"
+      verification_failed_result(
+        message: locked ? "Maximum verification attempts exceeded" : "Invalid verification code",
+        attempts: attempts,
+        locked: locked
       )
     end
 
-    private
-
     def get_delivery_adapter(channel)
       case channel
       when :sms
@@ -171,5 +158,67 @@ module VerifyIt
         raise ArgumentError, "Invalid delivery channel: #{channel}"
       end
     end
+
+    def invoke_callback(callback, **args)
+      callback&.call(**args)
+    end
+
+    # Result builders
+    def success_result(message, **options)
+      Result.new(success: true, message: message, **options)
+    end
+
+    def rate_limited_result(reason)
+      Result.new(
+        success: false,
+        error: :rate_limited,
+        message: reason,
+        rate_limited: true
+      )
+    end
+
+    def locked_result(reason, attempts:)
+      Result.new(
+        success: false,
+        error: :locked,
+        message: reason,
+        locked: true,
+        attempts: attempts
+      )
+    end
+
+    def code_not_found_result
+      Result.new(
+        success: false,
+        error: :code_not_found,
+        message: "No verification code found or code has expired"
+      )
+    end
+
+    def delivery_failed_result
+      Result.new(success: false, error: :delivery_failed, message: "Failed to deliver verification code")
+    end
+
+    def verification_failed_result(message:, attempts:, locked:)
+      Result.new(
+        success: false,
+        error: :invalid_code,
+        message: message,
+        attempts: attempts,
+        locked: locked
+      )
+    end
+
+    def build_send_success_result(code_data)
+      result_data = {
+        success: true,
+        message: "Verification code sent successfully",
+        expires_at: code_data[:expires_at]
+      }
+
+      result_data[:code] = code_data[:code] if config.test_mode
+
+      Result.new(**result_data)
+    end
   end
 end

data/lib/verify_it/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VerifyIt
-  VERSION = "0.3.0"
+  VERSION = "0.4.1.beta"
 end

data/lib/verify_it.rb

@@ -37,8 +37,8 @@ module VerifyIt
       verifier.send_code(to: to, record: record, channel: channel, context: context)
     end
 
-    def verify_code(to:, code:, record:)
-      verifier.verify_code(to: to, code: code, record: record)
+    def verify_code(to:, code:, record:, request: nil)
+      verifier.verify_code(to: to, code: code, record: record, request: request)
     end
 
     def cleanup(to:, record:)
@@ -62,6 +62,8 @@ module VerifyIt
     end
 
     def build_storage
+      configuration.validate!
+
       case configuration.storage
       when :memory
         Storage::MemoryStorage.new
@@ -81,4 +83,4 @@ module VerifyIt
 end
 
 # Load Rails integration if Rails is present
-require_relative "verify_it/railtie" if defined?(Rails)
+require_relative "verify_it/engine" if defined?(Rails::Engine)

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: verify_it
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1.beta
 platform: ruby
 authors:
 - Jeremias Ramirez
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -37,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,82 +94,67 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.12'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.50'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.50'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '1.50'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '1.50'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: '0.21'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: '0.21'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: logger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
 description: A storage-agnostic verification system for Ruby applications. VerifyIt
   provides a flexible framework for implementing SMS and email verifications with
   built-in rate limiting and multiple storage backends.
 email:
 - iguanadejere4@googlemail.com
-executables:
-- verify_it
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -153,16 +166,21 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- exe/verify_it
+- app/controllers/verify_it/application_controller.rb
+- app/controllers/verify_it/verifications_controller.rb
+- config/locales/en.yml
+- config/routes.rb
+- lib/generators/verify_it/install/install_generator.rb
+- lib/generators/verify_it/install/templates/create_verify_it_tables.rb
+- lib/generators/verify_it/install/templates/initializer.rb.erb
 - lib/verify_it.rb
-- lib/verify_it/cli.rb
 - lib/verify_it/code_generator.rb
 - lib/verify_it/code_hasher.rb
 - lib/verify_it/configuration.rb
 - lib/verify_it/delivery/base.rb
 - lib/verify_it/delivery/email_delivery.rb
 - lib/verify_it/delivery/sms_delivery.rb
-- lib/verify_it/railtie.rb
+- lib/verify_it/engine.rb
 - lib/verify_it/rate_limiter.rb
 - lib/verify_it/result.rb
 - lib/verify_it/storage/base.rb
@@ -172,12 +190,9 @@ files:
 - lib/verify_it/storage/models/code.rb
 - lib/verify_it/storage/models/identifier_change.rb
 - lib/verify_it/storage/redis_storage.rb
-- lib/verify_it/templates/initializer.rb.erb
-- lib/verify_it/templates/migration.rb.erb
 - lib/verify_it/verifiable.rb
 - lib/verify_it/verifier.rb
 - lib/verify_it/version.rb
-- pkg/verify_it-0.1.0.gem
 - sig/verify_it.rbs
 homepage: https://github.com/JeremasPosta/verify_it
 licenses:
@@ -195,7 +210,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/exe/verify_it

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "verify_it"
-require "verify_it/cli"
-
-VerifyIt::CLI.start(ARGV)