veri 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac32f0c6d36a07d566aec8905648f0e27811876d52929ab1753f3109af5648b7
+  data.tar.gz: eaaec22fa0215df1896cf3baadf7b8ce5e7ff4ebcb61094443a020e54c63023c
+SHA512:
+  metadata.gz: d75c20d2484660914c53ead2394f376bc915c45833bfe8b643b7e4964dc104c94d64747ce8be312bae24930e27216296060f1971a8356c9ec4c347372106c080
+  data.tar.gz: 4166c688264ac0cfa34866487a2ac572deb70972656c59fd724608841ea50d8b5436e64d70c7a45990302e4a8111cf0e47b103aff78075f0d792d05953c5a2b7

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.1.0
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 enjaku4 (https://github.com/enjaku4)
+
+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,315 @@
+# Veri: Minimal Authentication Framework for Rails
+
+[![Gem Version](https://badge.fury.io/rb/veri.svg)](http://badge.fury.io/rb/veri)
+[![Github Actions badge](https://github.com/brownboxdev/veri/actions/workflows/ci.yml/badge.svg)](https://github.com/brownboxdev/veri/actions/workflows/ci.yml)
+
+Veri is a cookie-based authentication library for Ruby on Rails that provides essential authentication building blocks without imposing business logic. Unlike full-featured solutions, Veri gives you complete control over your authentication flow while handling the complex underlying mechanics of secure password storage and session management.
+
+**Key Features:**
+
+- Cookie-based authentication with database-stored sessions
+- Supports multiple password hashing algorithms (argon2, bcrypt, scrypt)
+- Granular session management and control
+- Flexible authentication callbacks
+- No pre-defined business logic, no views, controllers, or mailers — just the essential methods
+- Built-in return path handling
+
+> ⚠️ **Development Notice**<br>
+> Veri is functional but in early development. Breaking changes may occur in minor releases until v1.0!
+
+## Table of Contents
+
+**Gem Usage:**
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+  - [Password Management](#password-management)
+  - [Controller Integration](#controller-integration)
+  - [Authentication Sessions](#authentication-sessions)
+  - [View Helpers](#view-helpers)
+  - [Testing](#testing)
+
+**Community Resources:**
+  - [Contributing](#contributing)
+  - [License](#license)
+  - [Code of Conduct](#code-of-conduct)
+
+## Installation
+
+Add Veri to your Gemfile:
+
+```rb
+gem "veri"
+```
+
+Install the gem:
+
+```bash
+bundle install
+```
+
+Generate the migration for your user model (replace `users` with your user table name if different):
+
+```shell
+# For standard integer IDs
+rails generate veri:authentication users
+
+# For UUID primary keys
+rails generate veri:authentication users --uuid
+```
+
+Run the migration:
+
+```shell
+rails db:migrate
+```
+
+## Configuration
+
+If customization is required, configure Veri in an initializer:
+
+```rb
+# These are the default values; you can change them as needed
+Veri.configure do |config|
+  config.hashing_algorithm = :argon2       # Password hashing algorithm (:argon2, :bcrypt, or :scrypt)
+  config.inactive_session_lifetime = nil   # Session inactivity timeout (nil means sessions never expire due to inactivity)
+  config.total_session_lifetime = 14.days  # Maximum session duration regardless of activity
+  config.user_model_name = "User"          # Your user model name
+end
+```
+
+## Password Management
+
+Your user model is automatically extended with password management methods:
+
+```rb
+# Set or update a password
+user.update_password("new_password")
+
+# Verify a password
+user.verify_password("submitted_password")
+```
+
+## Controller Integration
+
+### Basic Setup
+
+Include the authentication module and configure protection:
+
+```rb
+class ApplicationController < ActionController::Base
+  include Veri::Authentication
+
+  with_authentication  # Require authentication by default
+end
+
+class PicturesController < ApplicationController
+  skip_authentication only: [:index, :show]  # Allow public access to index and show actions
+end
+```
+
+### Authentication Methods
+
+This is a simplified example of how to use Veri's authentication methods in your controllers:
+
+```rb
+class SessionsController < ApplicationController
+  skip_authentication except: [:destroy]
+
+  def create
+    user = User.find_by(email: params[:email])
+
+    if user&.verify_password(params[:password])
+      log_in(user)
+      redirect_to return_path || dashboard_path
+    else
+      flash.now[:alert] = "Invalid credentials"
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    log_out
+    redirect_to root_path
+  end
+end
+```
+
+Available methods:
+
+- `current_user` - returns the authenticated user or `nil`
+- `logged_in?` - returns `true` if user is authenticated
+- `log_in(user)` - authenticates the user and creates a session
+- `log_out` - terminates the current session
+- `return_path` - returns the path the user was trying to access before authentication
+- `current_session` - returns the current authentication session
+
+### Authentication Callbacks
+
+Override these private methods to customize authentication behavior:
+
+```rb
+class ApplicationController < ActionController::Base
+  include Veri::Authentication
+
+  with_authentication
+
+  # ...
+
+  private
+
+  # Called after successful login
+  def after_login(user)
+    Rails.logger.info "User #{user.id} logged in"
+    # Custom redirect logic, analytics, etc.
+  end
+
+  # Called after logout
+  def after_logout
+    Rails.logger.info "User logged out"
+    # Cleanup, analytics, etc.
+  end
+
+  # Customize unauthenticated user handling
+  def when_unauthenticated
+    # By default redirects back with a fallback to the root path if the request format is HTML,
+    # otherwise responds with 401 Unauthorized
+    redirect_to login_path
+  end
+end
+```
+
+## Authentication Sessions
+
+Veri stores authentication sessions in the database, enabling powerful session management:
+
+### Session Access
+
+```rb
+# Get all sessions for a user
+user.veri_sessions
+
+# Get current session in controller
+current_session
+```
+
+### Session Information
+
+```rb
+session.info
+# => {
+#   device: "Desktop",
+#   os: "macOS",
+#   browser: "Chrome",
+#   ip_address: "1.2.3.4",
+#   last_activity: "2023-10-01 12:00:00"
+# }
+```
+
+### Session Status
+
+```rb
+session.active?     # Session is active (neither expired nor inactive)
+session.inactive?   # Session exceeded inactivity timeout
+session.expired?    # Session exceeded maximum lifetime
+```
+
+### Session Management
+
+```rb
+# Terminate a specific session
+session.terminate
+
+# Terminate all sessions for a user
+Veri::Session.terminate_all(user)
+
+# Clean up expired/inactive sessions
+Veri::Session.prune           # All sessions
+Veri::Session.prune(user)     # Specific user's sessions
+```
+
+## View Helpers
+
+Access authentication state in your views:
+
+```erb
+<% if logged_in? %>
+  <p>Welcome, <%= current_user.name %>!</p>
+  <%= link_to "Logout", logout_path, method: :delete %>
+<% else %>
+  <%= link_to "Login", login_path %>
+<% end %>
+```
+
+## Testing
+
+Veri doesn't provide test helpers, but you can easily create your own:
+
+### Request Specs (Recommended)
+
+```rb
+module AuthenticationHelpers
+  def log_in(user)
+    password = "test_password"
+    user.update_password(password)
+    post login_path, params: { email: user.email, password: }
+  end
+
+  def log_out
+    delete logout_path
+  end
+end
+
+# In your spec_helper.rb
+RSpec.configure do |config|
+  config.include AuthenticationHelpers, type: :request
+end
+```
+
+### Controller Specs (Legacy)
+
+```rb
+module AuthenticationHelpers
+  def log_in(user)
+    controller.log_in(user)
+  end
+
+  def log_out
+    controller.log_out
+  end
+end
+
+# In your spec_helper.rb
+RSpec.configure do |config|
+  config.include AuthenticationHelpers, type: :controller
+end
+```
+
+## Contributing
+
+### Getting Help
+Have a question or need assistance? Open a discussion in our [discussions section](https://github.com/brownboxdev/veri/discussions) for:
+- Usage questions
+- Implementation guidance
+- Feature suggestions
+
+### Reporting Issues
+Found a bug? Please [create an issue](https://github.com/brownboxdev/veri/issues) with:
+- A clear description of the problem
+- Steps to reproduce the issue
+- Your environment details (Rails version, Ruby version, etc.)
+
+### Contributing Code
+Ready to contribute? You can:
+- Fix bugs by submitting pull requests
+- Improve documentation
+- Add new features (please discuss first in our [discussions section](https://github.com/brownboxdev/veri/discussions))
+
+Before contributing, please read the [contributing guidelines](https://github.com/brownboxdev/veri/blob/master/CONTRIBUTING.md)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://github.com/brownboxdev/veri/blob/main/LICENSE.txt).
+
+## Code of Conduct
+
+Everyone interacting in the Veri project is expected to follow the [code of conduct](https://github.com/brownboxdev/veri/blob/main/CODE_OF_CONDUCT.md).

data/lib/generators/veri/authentication_generator.rb

@@ -0,0 +1,21 @@
+require "rails/generators/migration"
+
+module Veri
+  class AuthenticationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.expand_path("templates", __dir__)
+
+    argument :table_name, type: :string, required: true
+
+    class_option :uuid, type: :boolean, default: false, desc: "Use UUIDs as primary keys"
+
+    def create_migrations
+      migration_template "add_veri_authentication.rb.erb", "db/migrate/add_veri_authentication.rb"
+    end
+
+    def self.next_migration_number(_path)
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+  end
+end

data/lib/generators/veri/templates/add_veri_authentication.rb.erb

@@ -0,0 +1,16 @@
+class AddVeriAuthentication < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version.to_s %>]
+  def change
+    add_column <%= table_name.to_sym.inspect %>, :hashed_password, :text
+
+    create_table :veri_sessions<%= ", id: :uuid" if options[:uuid] %> do |t|
+      t.string :hashed_token, null: false, index: { unique: true }
+      t.datetime :expires_at, null: false
+      t.belongs_to :authenticatable, null: false, foreign_key: { to_table: <%= table_name.to_sym.inspect %> }, index: true<%= ", type: :uuid" if options[:uuid] %>
+      t.datetime :last_seen_at, null: false
+      t.string :ip_address
+      t.string :user_agent
+
+      t.timestamps
+    end
+  end
+end

data/lib/veri/configuration.rb

@@ -0,0 +1,40 @@
+require "active_support/core_ext/numeric/time"
+require "dry-configurable"
+
+module Veri
+  module Configuration
+    extend Dry::Configurable
+
+    module_function
+
+    setting :hashing_algorithm,
+            default: :argon2,
+            reader: true,
+            constructor: -> (value) { Veri::Inputs.process(value, as: :hashing_algorithm, error: Veri::ConfigurationError) }
+    setting :inactive_session_lifetime,
+            default: nil,
+            reader: true,
+            constructor: -> (value) { Veri::Inputs.process(value, as: :duration, optional: true, error: Veri::ConfigurationError) }
+    setting :total_session_lifetime,
+            default: 14.days,
+            reader: true,
+            constructor: -> (value) { Veri::Inputs.process(value, as: :duration, error: Veri::ConfigurationError) }
+    setting :user_model_name,
+            default: "User",
+            reader: true,
+            constructor: -> (value) { Veri::Inputs.process(value, as: :string, error: Veri::ConfigurationError) }
+
+    def hasher
+      case hashing_algorithm
+      when :argon2 then Veri::Password::Argon2
+      when :bcrypt then Veri::Password::BCrypt
+      when :scrypt then Veri::Password::SCrypt
+      else raise Veri::Error, "Invalid hashing algorithm: #{hashing_algorithm}"
+      end
+    end
+
+    def user_model
+      Veri::Inputs.process(user_model_name, as: :model, error: Veri::ConfigurationError)
+    end
+  end
+end

data/lib/veri/controllers/concerns/authentication.rb

@@ -0,0 +1,73 @@
+module Veri
+  module Authentication
+    extend ActiveSupport::Concern
+
+    included do
+      include ActionController::Cookies unless self < ActionController::Cookies
+
+      helper_method(:current_user, :logged_in?) if respond_to?(:helper_method)
+    end
+
+    class_methods do
+      def with_authentication(options = {})
+        before_action :with_authentication, **options
+      rescue ArgumentError => e
+        raise Veri::InvalidArgumentError, e.message
+      end
+
+      def skip_authentication(options = {})
+        skip_before_action :with_authentication, **options
+      rescue ArgumentError => e
+        raise Veri::InvalidArgumentError, e.message
+      end
+    end
+
+    def current_user
+      @current_user ||= current_session&.authenticatable
+    end
+
+    def current_session
+      token = cookies.encrypted[:veri_token]
+      @current_session ||= token ? Session.find_by(hashed_token: Digest::SHA256.hexdigest(token)) : nil
+    end
+
+    def log_in(authenticatable)
+      token = Veri::Session.establish(Veri::Inputs.process(authenticatable, as: :authenticatable), request)
+      cookies.encrypted.permanent[:veri_token] = { value: token, httponly: true }
+      after_login
+    end
+
+    def log_out
+      current_session&.terminate
+      cookies.delete(:veri_token)
+      after_logout
+    end
+
+    def logged_in?
+      current_user.present?
+    end
+
+    def return_path
+      cookies.signed[:veri_return_path]
+    end
+
+    private
+
+    def with_authentication
+      current_session.update_info(request) and return if logged_in? && current_session.active?
+
+      current_session&.terminate
+
+      cookies.signed[:veri_return_path] = { value: request.fullpath, expires: 15.minutes.from_now } if request.get? && request.format.html?
+
+      when_unauthenticated
+    end
+
+    def when_unauthenticated
+      request.format.html? ? redirect_back(fallback_location: root_path) : head(:unauthorized)
+    end
+
+    def after_login = nil
+    def after_logout = nil
+  end
+end

data/lib/veri/inputs.rb

@@ -0,0 +1,27 @@
+require "dry-types"
+
+module Veri
+  module Inputs
+    extend self
+
+    include Dry.Types()
+
+    def process(value, as:, optional: false, error: Veri::InvalidArgumentError)
+      checker = send(as)
+      checker = checker.optional if optional
+
+      checker[value]
+    rescue Dry::Types::CoercionError => e
+      raise error, e.message
+    end
+
+    private
+
+    def hashing_algorithm = self::Strict::Symbol.enum(:argon2, :bcrypt, :scrypt)
+    def duration = self::Instance(ActiveSupport::Duration)
+    def string = self::Strict::String
+    def model = self::Strict::Class.constructor { _1.try(:safe_constantize) || _1 }.constrained(lt: ActiveRecord::Base)
+    def authenticatable = self::Instance(Veri::Configuration.user_model)
+    def request = self::Instance(ActionDispatch::Request)
+  end
+end

data/lib/veri/models/concerns/authenticatable.rb

@@ -0,0 +1,25 @@
+module Veri
+  module Authenticatable
+    extend ActiveSupport::Concern
+
+    included do
+      raise Veri::Error, "Veri::Authenticatable can only be included once" if defined?(@@included) && @@included != name
+
+      @@included = name
+
+      has_many :veri_sessions, class_name: "Veri::Session", foreign_key: :authenticatable_id, dependent: :destroy
+    end
+
+    def update_password(password)
+      update!(hashed_password: hasher.create(Veri::Inputs.process(password, as: :string)))
+    end
+
+    def verify_password(password)
+      hasher.verify(Veri::Inputs.process(password, as: :string), hashed_password)
+    end
+
+    private
+
+    def hasher = Veri::Configuration.hasher
+  end
+end

data/lib/veri/models/session.rb

@@ -0,0 +1,82 @@
+require "user_agent_parser"
+
+module Veri
+  class Session < ActiveRecord::Base
+    self.table_name = "veri_sessions"
+
+    belongs_to :authenticatable, class_name: Veri::Configuration.user_model_name # rubocop:disable Rails/ReflectionClassName
+
+    def active?
+      !expired? && !inactive?
+    end
+
+    def expired?
+      expires_at < Time.current
+    end
+
+    def inactive?
+      inactive_session_lifetime = Veri::Configuration.inactive_session_lifetime
+
+      return false unless inactive_session_lifetime
+
+      last_seen_at < Time.current - inactive_session_lifetime
+    end
+
+    alias terminate delete
+
+    def update_info(request)
+      processed_request = Veri::Inputs.process(request, as: :request, error: Veri::Error)
+
+      update!(
+        last_seen_at: Time.current,
+        ip_address: processed_request.remote_ip,
+        user_agent: processed_request.user_agent
+      )
+    end
+
+    def info
+      agent = UserAgentParser.parse(user_agent)
+
+      {
+        device: agent.device.to_s,
+        os: agent.os.to_s,
+        browser: agent.to_s,
+        ip_address:,
+        last_seen_at:
+      }
+    end
+
+    class << self
+      def establish(authenticatable, request)
+        token = SecureRandom.hex(32)
+        expires_at = Time.current + Veri::Configuration.total_session_lifetime
+
+        new(
+          hashed_token: Digest::SHA256.hexdigest(token),
+          expires_at:,
+          authenticatable: Veri::Inputs.process(authenticatable, as: :authenticatable, error: Veri::Error)
+        ).update_info(
+          Veri::Inputs.process(request, as: :request, error: Veri::Error)
+        )
+
+        token
+      end
+
+      def prune(authenticatable = nil)
+        processed_authenticatable = Veri::Inputs.process(authenticatable, as: :authenticatable, optional: true)
+        scope = processed_authenticatable ? where(authenticatable: processed_authenticatable) : all
+        to_be_pruned = scope.where(expires_at: ...Time.current)
+        if Veri::Configuration.inactive_session_lifetime
+          to_be_pruned = to_be_pruned.or(
+            scope.where(last_seen_at: ...(Time.current - Veri::Configuration.inactive_session_lifetime))
+          )
+        end
+        to_be_pruned.delete_all
+      end
+
+      def terminate_all(authenticatable)
+        Veri::Inputs.process(authenticatable, as: :authenticatable).veri_sessions.delete_all
+      end
+    end
+  end
+end

data/lib/veri/password/argon2.rb

@@ -0,0 +1,17 @@
+require "argon2"
+
+module Veri
+  module Password
+    module Argon2
+      module_function
+
+      def create(password)
+        ::Argon2::Password.create(password)
+      end
+
+      def verify(password, hashed_password)
+        ::Argon2::Password.verify_password(password, hashed_password)
+      end
+    end
+  end
+end

data/lib/veri/password/bcrypt.rb

@@ -0,0 +1,17 @@
+require "bcrypt"
+
+module Veri
+  module Password
+    module BCrypt
+      module_function
+
+      def create(password)
+        ::BCrypt::Password.create(password)
+      end
+
+      def verify(password, hashed_password)
+        ::BCrypt::Password.new(hashed_password) == password
+      end
+    end
+  end
+end

data/lib/veri/password/scrypt.rb

@@ -0,0 +1,17 @@
+require "scrypt"
+
+module Veri
+  module Password
+    module SCrypt
+      module_function
+
+      def create(password)
+        ::SCrypt::Password.create(password)
+      end
+
+      def verify(password, hashed_password)
+        ::SCrypt::Password.new(hashed_password) == password
+      end
+    end
+  end
+end

data/lib/veri/railtie.rb

@@ -0,0 +1,12 @@
+require "rails/railtie"
+
+module Veri
+  class Railtie < Rails::Railtie
+    initializer "veri.to_prepare" do |app|
+      app.config.to_prepare do
+        user_model = Veri::Configuration.user_model
+        user_model.include Veri::Authenticatable unless user_model < Veri::Authenticatable
+      end
+    end
+  end
+end

data/lib/veri/version.rb

@@ -0,0 +1,3 @@
+module Veri
+  VERSION = "0.1.0"
+end

data/lib/veri.rb

@@ -0,0 +1,26 @@
+require_relative "veri/version"
+
+require "active_record"
+require "active_support"
+
+require_relative "veri/password/argon2"
+require_relative "veri/password/bcrypt"
+require_relative "veri/password/scrypt"
+
+require_relative "veri/inputs"
+require_relative "veri/configuration"
+
+module Veri
+  class Error < StandardError; end
+  class ConfigurationError < Veri::Error; end
+  class InvalidArgumentError < Veri::Error; end
+
+  delegate :configure, to: Veri::Configuration
+  module_function :configure
+end
+
+require_relative "veri/models/session"
+require_relative "veri/controllers/concerns/authentication"
+require_relative "veri/models/concerns/authenticatable"
+
+require_relative "veri/railtie"

data/veri.gemspec

@@ -0,0 +1,29 @@
+require_relative "lib/veri/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "veri"
+  spec.version = Veri::VERSION
+  spec.authors = ["enjaku4"]
+  spec.homepage = "https://github.com/brownboxdev/veri"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.summary = "Minimal cookie-based authentication library for Ruby on Rails"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2", "< 3.5"
+
+  spec.files = [
+    "veri.gemspec", "README.md", "CHANGELOG.md", "LICENSE.txt"
+  ] + Dir.glob("lib/**/*")
+
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "argon2", "~> 2.0"
+  spec.add_dependency "bcrypt", "~> 3.0"
+  spec.add_dependency "dry-configurable", "~> 1.3"
+  spec.add_dependency "dry-types", "~> 1.8"
+  spec.add_dependency "rails", ">= 7.1", "< 8.1"
+  spec.add_dependency "scrypt", "~> 3.0"
+  spec.add_dependency "user_agent_parser", "~> 2.0"
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: veri
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- enjaku4
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: argon2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: scrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: user_agent_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/generators/veri/authentication_generator.rb
+- lib/generators/veri/templates/add_veri_authentication.rb.erb
+- lib/veri.rb
+- lib/veri/configuration.rb
+- lib/veri/controllers/concerns/authentication.rb
+- lib/veri/inputs.rb
+- lib/veri/models/concerns/authenticatable.rb
+- lib/veri/models/session.rb
+- lib/veri/password/argon2.rb
+- lib/veri/password/bcrypt.rb
+- lib/veri/password/scrypt.rb
+- lib/veri/railtie.rb
+- lib/veri/version.rb
+- veri.gemspec
+homepage: https://github.com/brownboxdev/veri
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/brownboxdev/veri
+  source_code_uri: https://github.com/brownboxdev/veri
+  changelog_uri: https://github.com/brownboxdev/veri/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '3.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Minimal cookie-based authentication library for Ruby on Rails
+test_files: []