remind_me 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f76a53f49a07d6a0e777ef236281f87dff2e4881f83b8edcd7b18c5fb99dce3
-  data.tar.gz: c6e765928f9020b17c035429dac9cb941e717c67fd07b700790e4c49f4f15129
+  metadata.gz: 7fa0e33f33da3bbe35b1245625c5c605c5e20d14e90f5c710676224245a456fa
+  data.tar.gz: 0bea7706ce46a895d36203bff906e245c5d42adf23c8b68d6e6f7a8de4255ec8
 SHA512:
-  metadata.gz: 736d8b964280e45d6300c53c76ba476fc6bffc68262341d4fbc59f1cb139ac3333e327bdc9e680a1c4a94f0131e8ab1762e93649e18a13f5728f380cbbdc1c49
-  data.tar.gz: 7e3fa1d5760d38f9d77e0172dc082e21c7b236d74451f57d0cdb00ad477cbca4c28113ff96d4dd5196f5c9d70b5269995926c66681c396042c5b8eb2e2f20576
+  metadata.gz: 4d59df0fa184b0166e0b246eca2e58b3e2ec3bdbf86a16d07f54298001a4b99c98410e3c6a41de5b57c46837ea875a651a5e520ac91bce78e8832977892babaf
+  data.tar.gz: 10e9483a5de777738edc140fd88db75d49a5133c466798e2212e670fcabd358995744e8c2e6e882559caa85817f1ea30b4e6c45823076e8544689e9714f3d862

data/.github/workflows/main.yml

@@ -1,40 +1,27 @@
 name: Tests
 
-on: [push,pull_request]
+on: [push]
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ "2.3.7", "2.4.10", "2.5.9", "2.6.8", "2.7.4", "3.0.6", "3.1.4", "3.2.2", "jruby-9.2", "jruby-9.3", "jruby-9.4" ]
-        include:
-          - ruby: "2.3.7"
-            requires-older-rubygems: true
-            requires-older-bundler: true
-          - ruby: "2.4.10"
-            requires-older-rubygems: true
-            requires-older-bundler: true
-          - ruby: "jruby-9.2"
-            requires-older-bundler: true
-          - ruby: "jruby-9.3"
-            requires-older-bundler: true
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-14]
+        # TODO: Add Ruby 4.0 and 4.1 once Magnus gem releases official support
+        ruby: ["2.7.8", "3.0.7", "3.1.7", "3.2.10", "3.3.10", "3.4.8"]
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
-    - if: ${{ matrix.requires-older-rubygems }}
-      run: gem update --system 3.2.3
-    - if: ${{ matrix.requires-older-bundler }}
-      run: gem install bundler -v 2.3.26
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
     - name: Bundle install
       run: bundle install --jobs=3
-    - name: Run tests (MRI)
+    - name: Compile native extension
+      run: bundle exec rake compile
+    - name: Run tests
       run: bundle exec rake spec
-      if: "!startsWith(matrix.ruby, 'jruby')"
-    - name: Run tests (JRuby)
-      run: JRUBY_OPTS=--debug bundle exec rake spec
-      if: startsWith(matrix.ruby, 'jruby')

data/.gitignore

@@ -12,4 +12,6 @@
 .rspec_status
 .ruby-version
 /*.gem
-/target/
+/target/
+ext/remind_me/target/
+lib/remind_me/remind_me_native.*

data/CLAUDE.md

@@ -0,0 +1,57 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`remind_me` is a Ruby gem that provides a non-invasive code reminder system. It scans Ruby files for special `REMIND_ME:` comments (written as Ruby hash syntax) and checks whether specified conditions are met (gem versions, Ruby versions, missing gems). Designed to run in CI pipelines so developers revisit code when conditions are satisfied. Comments don't affect runtime behavior.
+
+## Common Commands
+
+```bash
+bundle exec rake spec      # Run tests
+bundle exec rake rubocop   # Run linter only
+bundle exec rspec spec/remind_me/runner_spec.rb           # Single test file
+bundle exec rspec spec/remind_me/runner_spec.rb:42        # Single test by line
+bundle exec rake compile   # Compile Rust native extension
+bundle exec rake install   # Install gem locally
+cargo test --manifest-path ext/remind_me/Cargo.toml       # Run Rust unit tests
+```
+
+Note: On Ruby 2.7 with bundler version conflicts, use `bundle _2.4.22_` prefix.
+
+## Architecture
+
+**Entry point:** `lib/remind_me.rb` → loads `Runner` and optional `Railtie`
+
+**Core flow:** `Runner.check_reminders()` → scans for `REMIND_ME:` comments → `Generator.generate()` creates reminder objects → `ResultPrinter.print_results()` reports or exits with error.
+
+**Native Rust extension (optional):** When compiled (`rake compile`), a Rust extension (`ext/remind_me/`) using `ignore` (parallel dir walking) and `memchr` (fast string search) replaces the Ruby file scanning. Exposed as `RemindMe::Native.scan_for_remind_me_comments(path)` via Magnus. Falls back to pure Ruby (`parser` gem) if the extension isn't available (JRuby, no Rust toolchain). The data contract between scanning and processing is `[source_location_string, comment_text_string]` tuples.
+
+**Plugin system with self-registration:** `BaseReminder` subclasses auto-register via `inherited` hook into `Generator`'s registry. New reminder types are added by subclassing `BaseReminder` and using the hash AST DSL (`apply_to_hash_with`, `validate_hash_ast`).
+
+**Built-in reminder types:**
+- `GemVersionReminder` — `{ gem: 'rails', version: '6', condition: :gte, message: '...' }`
+- `RubyVersionReminder` — `{ ruby_version: '3', condition: :gte, message: '...' }`
+- `MissingGemReminder` — `{ missing_gem: 'thor', message: '...' }`
+
+**Key modules:**
+- `HashAstManipulations` — DSL for declaring/validating hash keys in parsed AST nodes; generates accessor and validation methods dynamically
+- `BailOut` — error handling mixin used across reminder classes
+- `Utils::Versions` — version comparison logic supporting operators: `lt`, `lte`, `gt`, `gte`, `eq`
+
+**Parallel processing:** Uses `parallel` gem for concurrent reminder processing. Handles older parallel gem API differences. File scanning parallelism is handled by the Rust extension (or `parallel` in fallback mode).
+
+**Rails integration:** `Railtie` auto-loads `remind_me:check_reminders` rake task when Rails is present.
+
+## Test Structure
+
+Tests use RSpec with SimpleCov (90% overall minimum, 80% per-file). Fixture files live in `spec/testing_grounds/` organized by `single_line/` and `multi_line/` comment styles. The `runner_spec.rb` is the main integration test; unit tests are organized by reminder type under `spec/remind_me/reminder/`.
+
+## Style
+
+RuboCop config: single quotes (double for interpolation), 120-char line limit, 14 method length limit. Documentation cop disabled for specs.
+
+## CI
+
+GitHub Actions has two jobs: `build` (pure Ruby, all Ruby versions 2.3.7–3.2.2 + JRuby 9.2–9.4) and `build-native` (with Rust extension, Ruby 2.7.4–3.2.2).

data/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["ext/remind_me"]
+resolver = "2"

data/Gemfile

@@ -3,3 +3,6 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'rake-compiler'
+gem 'rb_sys'

data/README.md

@@ -126,7 +126,7 @@ require 'remind_me'
 
 desc 'picks up REMIND_ME comments from codebase and checks if their conditions are met'
 task custom_check_reminders: :environment do
-  RemindMe::Runner.new.check_reminders(check_path: '/some/other/directory/')
+  RemindMe::Runner.check_reminders(check_path: '/some/other/directory/')
 end
 ```
 

data/Rakefile

@@ -9,4 +9,13 @@ require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 
+begin
+  require 'rb_sys/extensiontask'
+  RbSys::ExtensionTask.new('remind_me_native') do |ext|
+    ext.lib_dir = 'lib/remind_me'
+  end
+rescue LoadError
+  # rb_sys not available, skip native extension compilation task
+end
+
 task default: %i[spec rubocop]

data/ext/remind_me/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "remind_me_native"
+version = "0.7.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[[bin]]
+name = "bench"
+path = "src/bench.rs"
+required-features = []
+
+[features]
+default = ["ruby"]
+ruby = ["magnus"]
+
+[dependencies]
+magnus = { version = "0.7", features = ["rb-sys"], optional = true }
+ignore = "0.4"
+memchr = "2"

data/ext/remind_me/extconf.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+if system('cargo --version > /dev/null 2>&1')
+  require 'rb_sys/mkmf'
+  create_rust_makefile('remind_me/remind_me_native')
+else
+  File.write('Makefile', "all:\ninstall:\n")
+  $stderr.puts 'WARNING: Rust toolchain not found, skipping native extension build. Using pure-Ruby fallback.'
+end

data/ext/remind_me/src/bench.rs

@@ -0,0 +1,35 @@
+use std::env;
+use std::time::Instant;
+
+use remind_me_native::scanner;
+
+fn main() {
+    let path = env::args()
+        .nth(1)
+        .unwrap_or_else(|| ".".to_string());
+    let iterations: usize = env::args()
+        .nth(2)
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(100);
+
+    println!("Scanning: {}", path);
+    println!("Iterations: {}", iterations);
+
+    // Warmup
+    let results = scanner::scan_for_remind_me_comments(&path);
+    println!("Found {} REMIND_ME comments", results.len());
+    for (loc, text) in &results {
+        println!("  {} {}", loc, text.trim());
+    }
+    println!();
+
+    // Benchmark
+    let start = Instant::now();
+    for _ in 0..iterations {
+        let _ = scanner::scan_for_remind_me_comments(&path);
+    }
+    let elapsed = start.elapsed();
+
+    println!("Total: {:.3}s ({} iterations)", elapsed.as_secs_f64(), iterations);
+    println!("Per iteration: {:.4}s", elapsed.as_secs_f64() / iterations as f64);
+}

data/ext/remind_me/src/lib.rs

@@ -0,0 +1,21 @@
+pub mod scanner;
+
+#[cfg(feature = "ruby")]
+use magnus::{function, prelude::*, Error, Ruby};
+
+#[cfg(feature = "ruby")]
+fn scan_for_remind_me_comments(path: String) -> Result<Vec<(String, String)>, Error> {
+    Ok(scanner::scan_for_remind_me_comments(&path))
+}
+
+#[cfg(feature = "ruby")]
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("RemindMe")?;
+    let native = module.define_module("Native")?;
+    native.define_module_function(
+        "scan_for_remind_me_comments",
+        function!(scan_for_remind_me_comments, 1),
+    )?;
+    Ok(())
+}

data/ext/remind_me/src/scanner.rs

@@ -0,0 +1,206 @@
+use memchr::memmem;
+use std::fs;
+use std::path::Path;
+use std::sync::Mutex;
+
+const MARKER: &str = "REMIND_ME:";
+const MARKER_LEN: usize = 10; // "REMIND_ME:".len()
+
+/// A single REMIND_ME comment match with its source location and text.
+pub struct Match {
+    pub source_location: String,
+    pub comment_text: String,
+}
+
+/// Scan a single file for REMIND_ME comments.
+///
+/// Handles both single-line (`# REMIND_ME: ...`) and block (`=begin`/`=end`) comments.
+/// Returns matches as (source_location, comment_text) where:
+/// - source_location is "path:line:1"
+/// - comment_text is everything after "REMIND_ME:" on the matching line
+pub fn scan_file(file_path: &str) -> Vec<Match> {
+    let content = match fs::read_to_string(file_path) {
+        Ok(c) => c,
+        Err(_) => return Vec::new(),
+    };
+
+    // Quick check: skip file entirely if no REMIND_ME: present
+    if memmem::find(content.as_bytes(), MARKER.as_bytes()).is_none() {
+        return Vec::new();
+    }
+
+    let lines: Vec<&str> = content.lines().collect();
+
+    // First pass: identify =begin/=end block comment boundaries
+    let mut block_ranges: Vec<(usize, usize)> = Vec::new();
+    let mut current_begin: Option<usize> = None;
+    for (i, line) in lines.iter().enumerate() {
+        if line.starts_with("=begin") && current_begin.is_none() {
+            current_begin = Some(i + 1); // 1-indexed
+        } else if line.starts_with("=end") {
+            if let Some(begin_line) = current_begin {
+                block_ranges.push((begin_line, i + 1));
+                current_begin = None;
+            }
+        }
+    }
+
+    // Second pass: find REMIND_ME: on each line
+    let finder = memmem::Finder::new(MARKER);
+    let mut results = Vec::new();
+
+    for (i, line) in lines.iter().enumerate() {
+        let line_num = i + 1; // 1-indexed
+
+        if let Some(pos) = finder.find(line.as_bytes()) {
+            let comment_text = &line[pos + MARKER_LEN..];
+
+            // Determine if this match is inside a comment
+            let in_block = block_ranges
+                .iter()
+                .any(|(begin, end)| line_num >= *begin && line_num <= *end);
+
+            if in_block {
+                // Block comment: report the =begin line number
+                let begin_line = block_ranges
+                    .iter()
+                    .find(|(begin, end)| line_num >= *begin && line_num <= *end)
+                    .map(|(begin, _)| *begin)
+                    .unwrap();
+
+                results.push(Match {
+                    source_location: format!("{}:{}:1", file_path, begin_line),
+                    comment_text: comment_text.to_string(),
+                });
+            } else if line[..pos].contains('#') {
+                // Single-line comment: # appears before REMIND_ME:
+                results.push(Match {
+                    source_location: format!("{}:{}:1", file_path, line_num),
+                    comment_text: comment_text.to_string(),
+                });
+            }
+            // Otherwise: REMIND_ME: in code/string, skip it
+        }
+    }
+
+    results
+}
+
+/// Walk a directory (or scan a single file) for REMIND_ME comments in .rb files.
+/// Returns a Vec of (source_location, comment_text) tuples.
+pub fn scan_for_remind_me_comments(path: &str) -> Vec<(String, String)> {
+    let p = Path::new(path);
+
+    if p.is_file() {
+        return scan_file(path)
+            .into_iter()
+            .map(|m| (m.source_location, m.comment_text))
+            .collect();
+    }
+
+    // Directory mode: parallel walk with ignore crate
+    let results: Mutex<Vec<(String, String)>> = Mutex::new(Vec::new());
+
+    ignore::WalkBuilder::new(path)
+        .hidden(false)
+        .git_ignore(false)
+        .git_global(false)
+        .git_exclude(false)
+        .build_parallel()
+        .run(|| {
+            Box::new(|entry| {
+                if let Ok(entry) = entry {
+                    let entry_path = entry.path();
+                    if entry_path.is_file()
+                        && entry_path.extension().map_or(false, |ext| ext == "rb")
+                    {
+                        if let Some(path_str) = entry_path.to_str() {
+                            let matches = scan_file(path_str);
+                            if !matches.is_empty() {
+                                let mut r = results.lock().unwrap();
+                                for m in matches {
+                                    r.push((m.source_location, m.comment_text));
+                                }
+                            }
+                        }
+                    }
+                }
+                ignore::WalkState::Continue
+            })
+        });
+
+    results.into_inner().unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_single_line_comment() {
+        let content = "# some comment\n# REMIND_ME: { gem: 'rails' }\ncode here\n";
+        let tmp = std::env::temp_dir().join("test_single_line.rb");
+        fs::write(&tmp, content).unwrap();
+        let matches = scan_file(tmp.to_str().unwrap());
+        assert_eq!(matches.len(), 1);
+        assert!(matches[0].source_location.ends_with(":2:1"));
+        assert_eq!(matches[0].comment_text, " { gem: 'rails' }");
+        fs::remove_file(&tmp).ok();
+    }
+
+    #[test]
+    fn test_block_comment() {
+        let content = "=begin\n  some text\n  REMIND_ME: { gem: 'rails' }\n=end\n";
+        let tmp = std::env::temp_dir().join("test_block_comment.rb");
+        fs::write(&tmp, content).unwrap();
+        let matches = scan_file(tmp.to_str().unwrap());
+        assert_eq!(matches.len(), 1);
+        assert!(matches[0].source_location.ends_with(":1:1")); // points to =begin
+        assert_eq!(matches[0].comment_text, " { gem: 'rails' }");
+        fs::remove_file(&tmp).ok();
+    }
+
+    #[test]
+    fn test_remind_me_in_string_skipped() {
+        let content = "puts \"REMIND_ME: something\"\n";
+        let tmp = std::env::temp_dir().join("test_in_string.rb");
+        fs::write(&tmp, content).unwrap();
+        let matches = scan_file(tmp.to_str().unwrap());
+        assert_eq!(matches.len(), 0);
+        fs::remove_file(&tmp).ok();
+    }
+
+    #[test]
+    fn test_no_matches() {
+        let content = "# just a comment\nputs 'hello'\n";
+        let tmp = std::env::temp_dir().join("test_no_match.rb");
+        fs::write(&tmp, content).unwrap();
+        let matches = scan_file(tmp.to_str().unwrap());
+        assert_eq!(matches.len(), 0);
+        fs::remove_file(&tmp).ok();
+    }
+
+    #[test]
+    fn test_multiple_matches() {
+        let content = "# REMIND_ME: { gem: 'a' }\n# regular\n# REMIND_ME: { gem: 'b' }\n";
+        let tmp = std::env::temp_dir().join("test_multiple.rb");
+        fs::write(&tmp, content).unwrap();
+        let matches = scan_file(tmp.to_str().unwrap());
+        assert_eq!(matches.len(), 2);
+        assert!(matches[0].source_location.ends_with(":1:1"));
+        assert!(matches[1].source_location.ends_with(":3:1"));
+        fs::remove_file(&tmp).ok();
+    }
+
+    #[test]
+    fn test_mixed_comment_types() {
+        let content = "# REMIND_ME: { gem: 'a' }\n=begin\n  REMIND_ME: { gem: 'b' }\n=end\n";
+        let tmp = std::env::temp_dir().join("test_mixed.rb");
+        fs::write(&tmp, content).unwrap();
+        let matches = scan_file(tmp.to_str().unwrap());
+        assert_eq!(matches.len(), 2);
+        assert!(matches[0].source_location.ends_with(":1:1")); // single-line
+        assert!(matches[1].source_location.ends_with(":2:1")); // block, points to =begin
+        fs::remove_file(&tmp).ok();
+    }
+}

data/lib/remind_me/runner.rb

@@ -10,6 +10,13 @@ require_relative 'reminder/generator'
 require_relative 'utils/logger'
 require_relative 'utils/result_printer'
 
+begin
+  require 'remind_me/remind_me_native'
+  REMIND_ME_NATIVE_AVAILABLE = true
+rescue LoadError
+  REMIND_ME_NATIVE_AVAILABLE = false
+end
+
 module RemindMe
   class Runner
     extend BailOut
@@ -33,6 +40,27 @@ module RemindMe
     end
 
     def self.collect_reminders(path)
+      if REMIND_ME_NATIVE_AVAILABLE
+        collect_reminders_native(path)
+      else
+        # :nocov:
+        collect_reminders_ruby(path)
+        # :nocov:
+      end
+    end
+
+    def self.collect_reminders_native(path)
+      raw_comments = RemindMe::Native.scan_for_remind_me_comments(path)
+      return if raw_comments.empty?
+
+      Parallel.flat_map(in_groups(raw_comments, processor_count, false)) do |comments|
+        parser = silent_parser
+        comments.flat_map { |raw_comment| RemindMe::Reminder::Generator.generate(raw_comment[0], raw_comment[1], parser) }
+      end
+    end
+
+    # :nocov:
+    def self.collect_reminders_ruby(path)
       files = relevant_ruby_files(path)
       return if files.empty?
 
@@ -42,6 +70,7 @@ module RemindMe
         raw_comments.flat_map { |raw_comment| RemindMe::Reminder::Generator.generate(raw_comment[0], raw_comment[1], parser) }
       end
     end
+    # :nocov:
 
     def self.silent_parser
       parser = Parser::CurrentRuby.new
@@ -65,6 +94,7 @@ module RemindMe
            .map { |x| [x[0], x[1][1].split("\n").first] }
     end
 
+    # :nocov:
     def self.relevant_ruby_files(parse_path)
       Parallel.flat_map(in_groups(collect_ruby_files(parse_path), processor_count, false)) do |files|
         files.select do |file|
@@ -84,6 +114,7 @@ module RemindMe
       end
       files
     end
+    # :nocov:
 
     def self.in_groups(array, number, fill_with = nil)
       division = array.size.div number
@@ -111,7 +142,9 @@ module RemindMe
 
     private_class_method :in_groups,
                          :collect_ruby_files,
-                         :collect_relevant_comments
+                         :collect_relevant_comments,
+                         :collect_reminders_native,
+                         :collect_reminders_ruby
   end
 end
 

data/lib/remind_me/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RemindMe
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/remind_me.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = spec.summary
   spec.homepage      = 'https://github.com/nikola-maric/remind_me'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage
@@ -26,8 +26,11 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
+  spec.extensions = ['ext/remind_me/extconf.rb']
 
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'rb_sys'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'simplecov'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remind_me
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Nikola Marić
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-30 00:00:00.000000000 Z
+date: 2026-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -99,20 +127,28 @@ description: Processor of REMIND_ME comments in the code, reminding us to revisi
 email:
 - nkl.maric@gmail.net
 executables: []
-extensions: []
+extensions:
+- ext/remind_me/extconf.rb
 extra_rdoc_files: []
 files:
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- CLAUDE.md
 - CODE_OF_CONDUCT.md
+- Cargo.toml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- ext/remind_me/Cargo.toml
+- ext/remind_me/extconf.rb
+- ext/remind_me/src/bench.rs
+- ext/remind_me/src/lib.rs
+- ext/remind_me/src/scanner.rs
 - lib/remind_me.rb
 - lib/remind_me/bail_out.rb
 - lib/remind_me/railtie.rb
@@ -137,7 +173,7 @@ metadata:
   homepage_uri: https://github.com/nikola-maric/remind_me
   source_code_uri: https://github.com/nikola-maric/remind_me
   changelog_uri: https://github.com/nikola-maric/remind_me
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -145,15 +181,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.4.14
+signing_key:
 specification_version: 4
 summary: Processor of REMIND_ME comments in the code, reminding us to revisit parts
   of code