active_recall 2.1.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1145dd0124d31f1cd1d200170e3956b20818e73bd2d1fedb4ceacf4f82a8f4ba
-  data.tar.gz: b4b8e2c1d1edd66cc0c756200b525aec806468c7f95626c257bd95f369d56037
+  metadata.gz: 63a48f6351a76013bbf2922ca75b507b6dccb1ab23867896217b53bc6a77e26f
+  data.tar.gz: 9d8e3189bb8f5b1f15b284168e5973e87070bf223c0427b5a574cacd38c8e4b0
 SHA512:
-  metadata.gz: e94584e1041b5f695ab3ec0d24a87a7c3a4abf200fb11c7951917f98cbd84f9e24225b52a6c45d393fe31beb76e08a9ac683266cd191f7ec5cacd78644b8ed68
-  data.tar.gz: 6979b3ac85b8cd12751566161bfa2d55ca5832fc82693a92469f3844ec481d86c4bda05fc709fcbb2ea8f3dbc84959a8d342a683ce6e936a05ab235c278a66df
+  metadata.gz: efe496383029f35391f1b54533f525451c5ee8a02e440316b990b812923b2061fc94eeff2ed1d691b17a1838b2d266b51ec9dde7d3305d511b484edb53b606b7
+  data.tar.gz: ff9f67e94b77d93175af60926ad889655862989c18a9b2fb07b8e75503526b8281f32cd3a982ab1d70933363454e40461a10dd2be72784bc5097243173ff5b1e

data/.github/workflows/tests.yml

@@ -21,6 +21,8 @@ jobs:
         ruby:
           - 3.2
           - 3.3
+          - 3.4
+          - 4.0
         allow_failures:
           - false
     env:
@@ -35,7 +37,9 @@ jobs:
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
+          bundler-cache: false
+      - name: Bundle Install
+        run: bundle install
       - name: Install Appraisal Dependencies
         run: bundle exec appraisal install
       - name: Test with Rails 7.0

data/.tool-versions

@@ -1 +1 @@
-ruby 3.3.0
+ruby 3.4.8

data/CLAUDE.md

@@ -0,0 +1,194 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+ActiveRecall is a Ruby gem that implements a spaced-repetition system (SRS) for ActiveRecord models. It allows treating arbitrary ActiveRecord models as flashcards with configurable scheduling algorithms. The gem is backwards-compatible with the okubo gem and requires Rails 6+ and Ruby 3+.
+
+## Common Commands
+
+### Testing
+```bash
+# Run all tests (PREFERRED - handles appraisal automatically)
+bin/spec
+
+# Run tests against a specific Rails version
+bin/spec rails-7-0
+bin/spec rails-7-1
+bin/spec rails-8-0
+
+# Note: Direct bundle exec commands may encounter sqlite3 version conflicts
+# The bin/spec wrapper handles this by using the appropriate appraisal gemfiles
+```
+
+### Linting
+```bash
+# Run StandardRB linter
+bin/lint
+# or
+bundle exec standardrb
+
+# Auto-fix issues
+bundle exec standardrb --fix
+```
+
+### Development Setup
+```bash
+# Install dependencies and set up database
+bin/setup
+
+# Launch interactive console
+bin/console
+```
+
+### Testing Against Multiple Rails Versions
+```bash
+# Generate gemfiles for different Rails versions (run after Gemfile changes)
+bundle exec appraisal install
+
+# Run tests against specific Rails version manually
+bundle exec appraisal rails-7-0 rake spec
+bundle exec appraisal rails-7-1 rake spec
+bundle exec appraisal rails-8-0 rake spec
+
+# Note: bin/spec runs tests against all Rails versions automatically
+# This is defined in the Appraisals file and creates separate gemfiles in gemfiles/
+```
+
+### Gem Management
+```bash
+# Build the gem
+bundle exec rake build
+
+# Install gem locally
+bundle exec rake install
+
+# Release new version (requires updating lib/active_recall/version.rb first)
+bundle exec rake release
+```
+
+## Architecture
+
+### Core Components
+
+1. **ActiveRecall::Base** (lib/active_recall/base.rb)
+   - Provides `has_deck` class method that makes any ActiveRecord model a deck owner
+   - Mixes in DeckMethods and ItemMethods when invoked
+   - Sets up polymorphic relationship between users and their decks
+
+2. **ActiveRecall::Deck** (lib/active_recall/models/deck.rb)
+   - Polymorphic model representing a collection of items to review
+   - Belongs to a user (polymorphic), has many items
+   - Key methods: `review`, `next`, `untested`, `failed`, `known`, `expired`, `box(n)`
+   - Handles database adapter differences (MySQL vs others) for random ordering
+
+3. **ActiveRecall::Item** (lib/active_recall/models/item.rb)
+   - Represents individual flashcard items in a deck
+   - Polymorphic association to source objects (the actual flashcard content)
+   - Methods: `score!(grade)`, `right!`, `wrong!`
+   - Delegates to configured algorithm for calculating next review dates
+
+4. **Algorithms** (lib/active_recall/algorithms/)
+   - Each algorithm class implements: `type`, `required_attributes`, `right`, `wrong`, and optionally `score`
+   - Algorithm types: `:binary` (right/wrong only) or `:gradable` (accepts scores)
+   - Binary algorithms: LeitnerSystem (default), SoftLeitnerSystem, FibonacciSequence
+   - Gradable algorithm: SM2
+   - All algorithms are stateless; they accept current state and return new state as a hash
+
+5. **Configuration** (lib/active_recall/configuration.rb)
+   - Global configuration via `ActiveRecall.configure`
+   - Primary setting: `algorithm_class` (defaults to LeitnerSystem)
+   - Configuration should be set in Rails initializers
+
+### Data Flow
+
+1. A model calls `has_deck :items_name` to enable SRS functionality
+2. This creates a Deck record (polymorphic, user_id/user_type)
+3. Items are added to deck with `<<` operator, creating Item records
+4. Item records store: box number, review dates, times_right/times_wrong, easiness_factor (for SM2)
+5. User calls `right_answer_for!(item)` or `wrong_answer_for!(item)` (or `score!(grade, item)` for gradable algorithms)
+6. This delegates to Item's `right!`/`wrong!`/`score!` which calls the configured algorithm
+7. Algorithm returns hash of updated attributes (box, next_review, etc.)
+8. Deck provides query methods that filter items by state and return source objects
+
+### Key Design Patterns
+
+- **Polymorphic associations**: Decks belong to any "user" model, Items reference any "source" model
+- **Strategy pattern**: Algorithms are swappable via configuration
+- **Delegation**: Deck methods delegate to Item scopes, which use the configured algorithm
+- **Stateless algorithms**: All algorithm classes are stateless with class methods only (except FibonacciSequence which caches Fibonacci numbers in instances)
+
+## Database Schema
+
+The gem creates two tables via generators:
+- `active_recall_decks`: id, user_id (polymorphic), user_type, created_at, updated_at
+- `active_recall_items`: id, deck_id, source_id (polymorphic), source_type, box, times_right, times_wrong, last_reviewed, next_review, easiness_factor, created_at, updated_at
+
+## Migration from Okubo
+
+The gem includes a migration template (`migrate_okubo_to_active_recall.rb`) that renames tables from okubo_* to active_recall_*. Use `rails generate active_recall --migrate_data true` to generate this migration.
+
+## Code Style
+
+- Uses StandardRB for linting (config in standard.yml)
+- All files have `# frozen_string_literal: true` pragma
+- Ruby 3.2+ syntax required
+
+## Testing Conventions
+
+### Test File Structure
+- Spec files mirror lib/ directory structure (e.g., `lib/active_recall/foo.rb` → `spec/active_recall/foo_spec.rb`)
+- All spec files start with `# frozen_string_literal: true` and `require "spec_helper"`
+- Use `describe ClassName` for top-level blocks
+- Use `context` blocks to organize different scenarios
+- Use `subject { described_class.new }` for the class under test
+
+### Common Patterns
+```ruby
+# Basic structure
+describe ActiveRecall::SomeClass do
+  subject { described_class.new }
+
+  describe "#method_name" do
+    it "describes expected behavior" do
+      expect(subject.method_name).to eq(expected_value)
+    end
+  end
+
+  context "when specific condition" do
+    it "behaves differently" do
+      # test implementation
+    end
+  end
+end
+```
+
+### Shared Examples
+- Algorithm specs use shared examples for common behavior (see spec/active_recall/algorithms/algorithm_spec.rb)
+- Binary algorithms share: `it_behaves_like "binary spaced repetition algorithms"`
+- This ensures consistent testing across algorithm implementations
+
+### Test Data Setup
+- Use `let` blocks for test data that needs to be created
+- Use `before` blocks for setup that must run before each test
+- The spec_helper.rb defines Word and User models for testing deck functionality
+
+### Running Specific Tests
+While `bin/spec` is preferred for full test runs, you can run individual specs during development:
+```bash
+# During active development, you may need to specify the appraisal
+bundle exec appraisal rails-8-0 rspec spec/active_recall/configuration_spec.rb
+
+# Or run all specs via bin/spec which handles all Rails versions
+bin/spec
+```
+
+### Test Infrastructure Notes
+- Tests use an in-memory SQLite database (`:memory:`) configured in spec/spec_helper.rb
+- Different Rails versions require different sqlite3 gem versions:
+  - Rails 7.0/7.1 use sqlite3 ~> 1.4
+  - Rails 8.0 uses sqlite3 >= 2.1
+- The appraisal system manages these version conflicts via separate gemfiles
+- Always use `bin/spec` to avoid sqlite3 version conflict errors
+- Direct `bundle exec rspec` commands will fail with "can't activate sqlite3" errors

data/Gemfile

@@ -4,5 +4,18 @@ source "https://rubygems.org"
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
-# Specify your gem's dependencies in active_recall.gemspec
 gemspec
+
+# TODO: Remove conditional dependency after dropping support for Ruby 3.2
+begin
+  ruby_version = Gem::Version.new(RUBY_VERSION)
+  if ruby_version >= Gem::Version.new("3.4.0")
+    gem "nokogiri", ">= 1.16.2"
+  end
+  if ruby_version >= Gem::Version.new("4.0.0")
+    gem "benchmark"
+    gem "ostruct"
+    gem "logger"
+  end
+rescue
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_recall (2.1.0)
+    active_recall (2.3.0)
       activerecord (>= 7.0, < 9.0)
       activesupport (>= 7.0, < 9.0)
 
@@ -119,7 +119,7 @@ GEM
       net-smtp
     marcel (1.0.2)
     mini_mime (1.1.5)
-    mini_portile2 (2.8.5)
+    mini_portile2 (2.8.9)
     minitest (5.18.1)
     mutex_m (0.2.0)
     net-imap (0.4.9.1)
@@ -132,10 +132,14 @@ GEM
     net-smtp (0.4.0.1)
       net-protocol
     nio4r (2.7.0)
-    nokogiri (1.16.0)
+    nokogiri (1.18.7)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.16.0-x86_64-linux)
+    nokogiri (1.18.7-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.18.7-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.18.7-x86_64-linux-gnu)
       racc (~> 1.4)
     parallel (1.24.0)
     parser (3.3.1.0)
@@ -219,6 +223,8 @@ GEM
     ruby2_keywords (0.0.5)
     sqlite3 (2.5.0)
       mini_portile2 (~> 2.8.0)
+    sqlite3 (2.5.0-arm64-darwin)
+    sqlite3 (2.5.0-x86_64-darwin)
     sqlite3 (2.5.0-x86_64-linux-gnu)
     standard (1.35.1)
       language_server-protocol (~> 3.17.0.2)
@@ -244,12 +250,15 @@ GEM
     zeitwerk (2.6.12)
 
 PLATFORMS
+  arm64-darwin
   ruby
+  x86_64-darwin
   x86_64-linux
 
 DEPENDENCIES
   active_recall!
   appraisal
+  nokogiri (>= 1.16.2)
   rails (>= 7.0, < 9.0)
   rake (>= 12.0)
   rdoc

data/README.md

@@ -1,7 +1,7 @@
 # ActiveRecall
 
 **ActiveRecall** is a spaced-repetition system that allows you to treat arbitrary [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord) models as if they were flashcards to be learned and reviewed.
-It it based on, and is intended to be backwards compatible with, the [okubo](https://github.com/rgravina/okubo) gem.
+It is based on, and is intended to be backwards compatible with, the [okubo](https://github.com/rgravina/okubo) gem.
 The primary differentiating features are that it lets the user specify the scheduling algorithm and is fully compatible with (and requires) Rails 6+ and Ruby 3+.
 
 ## Installation
@@ -28,17 +28,13 @@ Or install it yourself as:
 
     $ gem install active_recall
 
-## Usage
-You can configure the desired SRS algorithm during runtime:
-```ruby
-ActiveRecall.configure do |config|
-  config.algorithm_class = ActiveRecall::FibonacciSequence
-end
-```
-Algorithms include `FibonacciSequence`, `LeitnerSystem`, `SoftLeitnerSystem`, and `SM2` (see [here](https://en.wikipedia.org/wiki/SuperMemo#Description_of_SM-2_algorithm)).
-For Rails applications, try doing this from within an [initializer file](https://guides.rubyonrails.org/configuring.html#using-initializer-files).
+The generator creates all the migrations any algorithm needs (including the `easiness_factor` column for SM2 and the FSRS-specific columns), so you don't have to revisit migrations when you switch algorithms later.
 
-Assume you have an application allowing your users to study words in a foreign language. Using the `has_deck` method you can set up a deck of flashcards that the user will study:
+## Quick Start
+
+The fastest way to get going — no algorithm choice, no grade scale, just right/wrong feedback. This uses the default `LeitnerSystem`.
+
+Suppose you have an application allowing your users to study words in a foreign language. Use `has_deck` to set up a deck of flashcards:
 
 ```ruby
 class Word < ActiveRecord::Base
@@ -48,18 +44,76 @@ class User < ActiveRecord::Base
   has_deck :words
 end
 
-user = User.create!(:name => "Robert")
-word = Word.create!(:kanji => "日本語", :kana => "にほんご", :translation => "Japanese language")
+user = User.create!(name: "Robert")
+word = Word.create!(kanji: "日本語", kana: "にほんご", translation: "Japanese language")
+
+user.words << word
+user.words.untested  #=> [word]
+
+user.right_answer_for!(word)
+user.words.known     #=> [word]
+
+user.wrong_answer_for!(word)
+user.words.failed    #=> [word]
+```
+
+That's it. Want graded feedback (Again/Hard/Good/Easy) or modern scheduling? See [Choosing an Algorithm](#choosing-an-algorithm) below.
+
+## Choosing an Algorithm
+
+> **Not sure which to pick?** Stick with the default `LeitnerSystem` — it works out of the box and only needs right/wrong feedback. Reach for `FSRS` when you want modern, evidence-based scheduling and are willing to collect 1–4 ratings ("Again / Hard / Good / Easy") from users.
+
+The full menu, in increasing order of sophistication:
+
+| Algorithm | Type | How you grade | Reach for it when |
+|---|---|---|---|
+| **`LeitnerSystem`** *(default — start here)* | binary | `right_answer_for!` / `wrong_answer_for!` | You want the simplest thing that works |
+| `SoftLeitnerSystem` | binary | `right_answer_for!` / `wrong_answer_for!` | Leitner is too punishing on occasional lapses |
+| `FibonacciSequence` | binary | `right_answer_for!` / `wrong_answer_for!` | You want faster-growing intervals than Leitner |
+| `SM2` | gradable | `score!(0..5, item)` | You want the classic SuperMemo behavior users know from Anki |
+| **`FSRS`** *(modern recommendation)* | gradable | `score!(1..4, item)` | You're building something serious and want best-in-class retention |
+
+**Binary** algorithms expect right-or-wrong feedback (`user.right_answer_for!(item)` / `user.wrong_answer_for!(item)`). **Gradable** algorithms expect a numeric grade per review (`user.score!(grade, item)`). Mixing them — e.g. calling `right_answer_for!` while configured to use SM2 — raises `ActiveRecall::IncompatibleAlgorithmError`.
+
+## Configuration
+
+Skip this section if you're sticking with the default `LeitnerSystem` — there's nothing to configure.
+
+To switch algorithms, set `algorithm_class` from a Rails [initializer file](https://guides.rubyonrails.org/configuring.html#using-initializer-files):
+
+```ruby
+# config/initializers/active_recall.rb
+ActiveRecall.configure do |config|
+  config.algorithm_class = ActiveRecall::FSRS  # or SM2, SoftLeitnerSystem, FibonacciSequence
+end
+```
+
+### FSRS-specific configuration
+
+FSRS exposes three optional knobs. All have sensible defaults; tune only if you have a reason to:
+
+- `fsrs_request_retention` — target retention probability (default `0.9`). Lower → longer intervals, more forgetting tolerated.
+- `fsrs_maximum_interval` — caps the scheduled interval, in days.
+- `fsrs_weights` — array of FSRS weights for advanced tuning.
+
+```ruby
+ActiveRecall.configure do |config|
+  config.algorithm_class       = ActiveRecall::FSRS
+  config.fsrs_request_retention = 0.85
+  config.fsrs_maximum_interval  = 365
+end
 ```
 
-You can add words and record attempts to guess the word as right or wrong. Various methods exist to allow you to access subsets of this collection:
+## Usage with binary algorithms
+
+Applies to `LeitnerSystem`, `SoftLeitnerSystem`, and `FibonacciSequence`.
 
 ```ruby
 # Initially adding a word
 user.words << word
 user.words.untested #=> [word]
 
-# Guessing a word correctly (when using a binary algorithm)
+# Guessing a word correctly
 user.right_answer_for!(word)
 user.words.known #=> [word]
 
@@ -75,11 +129,11 @@ As time passes, words need to be reviewed to keep them fresh in memory:
 
 ```ruby
 # Three days later...
-user.words.known #=> []
+user.words.known   #=> []
 user.words.expired #=> [word]
 ```
 
-Guessing a word correctly several times in a row results in the word taking longer to expire, and demonstrates mastery of that word.
+Guessing a word correctly several times in a row makes the word take longer to expire, demonstrating mastery:
 
 ```ruby
 user.right_answer_for!(word)
@@ -93,21 +147,55 @@ user.right_answer_for!(word)
 user.words.expired #=> [word]
 ```
 
-When using a gradable algorithm (rather than binary) such as the SM2 algorithm, you will need to supply your own grade along with the item:
+## Usage with SM2
+
+[SM2](https://en.wikipedia.org/wiki/SuperMemo#Description_of_SM-2_algorithm) uses a 0–5 grade scale:
+
+| Grade | Meaning |
+|---|---|
+| `5` | Perfect response |
+| `4` | Correct response after a hesitation |
+| `3` | Correct response recalled with serious difficulty |
+| `2` | Incorrect response, but close |
+| `1` | Incorrect response with familiarity |
+| `0` | Complete blackout |
+
+Grades **≥ 3** count as a success: the box advances and `times_right` increments. Grades **< 3** reset the box to `0` and increment `times_wrong`. Each item's `easiness_factor` starts at `2.5` and is clamped to a minimum of `1.3`.
+
+```ruby
+user.words << word
+
+user.score!(5, word)  # perfect recall — box advances, EF rises
+user.score!(2, word)  # incorrect — box resets to 0
+```
+
+Calling `user.right_answer_for!(word)` while SM2 is configured raises `ActiveRecall::IncompatibleAlgorithmError` — use `score!` instead.
+
+## Usage with FSRS
+
+[FSRS](https://github.com/open-spaced-repetition/fsrs4anki) uses a 1–4 grade scale matching the familiar Anki buttons:
+
+| Grade | Meaning |
+|---|---|
+| `1` | Again (lapse) |
+| `2` | Hard |
+| `3` | Good |
+| `4` | Easy |
+
+FSRS tracks `stability`, `difficulty`, `state`, and `lapses` per item. Those columns are added automatically by `rails generate active_recall` — no extra setup needed.
+
 ```ruby
-grade = 3
-user.score!(grade, word)
+user.words << word
 
-# Using the binary-only methods will raise an error
-user.right_answer_for!(word)
-=> ActiveRecall::IncompatibleAlgorithmError
+user.score!(3, word)  # "Good" — typical successful recall
+user.score!(1, word)  # "Again" — counts as a lapse
 ```
 
-Reviewing
----------
+Calling `user.right_answer_for!(word)` while FSRS is configured raises `ActiveRecall::IncompatibleAlgorithmError` — use `score!` instead.
+
+## Reviewing
 
-In addition to an `expired` method, ActiveRecall provides a suggested reviewing sequence for all unknown words in the deck.
-Words are randomly chosen from all untested words, failed, and finally expired in order of precedence.
+In addition to the `expired` scope, ActiveRecall provides a suggested reviewing sequence for all unknown words in the deck. Words are randomly chosen from `untested`, `failed`, and `expired` items, in that order of precedence. This works the same for every algorithm.
 
 ```ruby
 user.words.review #=> [word]

data/VENDORED_LICENSES.md

@@ -0,0 +1,54 @@
+# Vendored Licenses
+
+This file records third-party source code that has been vendored into this
+repository, along with the upstream license terms. ActiveRecall's own license
+is in [LICENSE](LICENSE).
+
+## rb-fsrs
+
+- **Vendored at:** [`lib/active_recall/algorithms/fsrs/internal.rb`](lib/active_recall/algorithms/fsrs/internal.rb)
+- **Upstream:** https://github.com/open-spaced-repetition/rb-fsrs
+- **Version:** 0.9.0 (commit pulled from the published gem)
+- **License:** MIT
+- **Reason for vendoring:** The published `fsrs` 0.9.0 gem pins
+  `activesupport ~> 7.0`, which excludes Rails 8. ActiveRecall supports
+  Rails 8, so the code was vendored under `ActiveRecall::FSRS::Internal`.
+  The constraint has been widened on rb-fsrs `master`; revisit the
+  dependency-vs-vendoring decision once a release with the wider
+  constraint ships.
+
+### Local divergences from upstream
+
+- `Scheduler#schedule_new_state` uses `1.minute` / `5.minutes` /
+  `10.minutes` in place of upstream's bare integer arithmetic
+  (`now + 60`, `now + (5 * 60)`, `now + (10 * 60)`). With `now` as a
+  `DateTime`, the upstream form adds days, not seconds, scheduling new
+  cards rated Again/Hard/Good 60 / 300 / 600 days out instead of
+  1 / 5 / 10 minutes. Tracks upstream PR
+  https://github.com/open-spaced-repetition/rb-fsrs/pull/9.
+
+### Upstream license text
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2024 clayton
+
+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/gemfiles/rails_7_0.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
+gem "nokogiri", ">= 1.16.2"
 gem "rails", "~> 7.0"
 gem "sqlite3", "~> 1.4"
 

data/gemfiles/rails_7_0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    active_recall (2.1.0)
+    active_recall (2.3.0)
       activerecord (>= 7.0, < 9.0)
       activesupport (>= 7.0, < 9.0)
 
@@ -119,6 +119,7 @@ GEM
       net-smtp
     marcel (1.0.2)
     mini_mime (1.1.5)
+    mini_portile2 (2.8.8)
     minitest (5.21.2)
     mutex_m (0.2.0)
     net-imap (0.4.9.1)
@@ -131,7 +132,14 @@ GEM
     net-smtp (0.4.0.1)
       net-protocol
     nio4r (2.7.0)
-    nokogiri (1.16.0-arm64-darwin)
+    nokogiri (1.18.7)
+      mini_portile2 (~> 2.8.2)
+      racc (~> 1.4)
+    nokogiri (1.18.7-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.18.7-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.18.7-x86_64-linux-gnu)
       racc (~> 1.4)
     parallel (1.24.0)
     parser (3.3.1.0)
@@ -216,7 +224,8 @@ GEM
       rubocop-ast (>= 1.30.0, < 2.0)
     ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)
-    sqlite3 (1.7.3-arm64-darwin)
+    sqlite3 (1.7.3)
+      mini_portile2 (~> 2.8.0)
     standard (1.35.1)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.0)
@@ -242,11 +251,15 @@ GEM
     zeitwerk (2.6.12)
 
 PLATFORMS
-  arm64-darwin-23
+  arm64-darwin
+  ruby
+  x86_64-darwin
+  x86_64-linux
 
 DEPENDENCIES
   active_recall!
   appraisal
+  nokogiri (>= 1.16.2)
   rails (~> 7.0)
   rake (>= 12.0)
   rdoc

data/gemfiles/rails_7_1.gemfile

@@ -2,6 +2,7 @@
 
 source "https://rubygems.org"
 
+gem "nokogiri", ">= 1.16.2"
 gem "rails", "~> 7.1"
 gem "sqlite3", "~> 1.4"