fbe 0.20.0 → 0.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c33c559724c991d4aabc2ad9c097170e53de0002e362dcfadfe956d77eed7ec
-  data.tar.gz: 787dbc8ce12ebacbd0b96cd8174ced19aa11665f29d3d410fb93c397dbb80d87
+  metadata.gz: 10045af8e71603e4647d934f3b10afa96385ebca7dc678911ff5e443be0af638
+  data.tar.gz: c8fe68b60de2232967d242733764f1025b2c9d0b8884114c6480c7b345d0fd3b
 SHA512:
-  metadata.gz: ca43bc96f5c8f426a72fb3ab722684d36b67613526b9d2e1be175abae03581c4fc0318314e92628c9064d2c7ba8637814ed950e349ba86b64caedc768619be8f
-  data.tar.gz: 81d737f13af364095e871df44000f6293d1c062929d7f859cd3836d23c3cf602a1362a9653fd739f1726c4d1004e0bad1806e3cb3fde23dc4aef081e39dfbd6a
+  metadata.gz: fd3fc1d0b158be59858edf4292027e71c73bffd8c1cbc7ef45ae743c9e9b521fe4faf4ab1995999fad3e3c798107d75925d74cc3ae8fd130cc535901259d68fc
+  data.tar.gz: d7d494cf9f5c5f4b5899be7caad9d4fdaa5203483c8bdd450117ea86241b0894df164d16d2c42505fda6c7e50627c803ed58f5e9d7910c7406f77cd4cc601dfb

data/Gemfile.lock

@@ -180,7 +180,7 @@ GEM
     regexp_parser (2.10.0)
     retries (0.0.5)
     rexml (3.4.1)
-    rubocop (1.76.1)
+    rubocop (1.76.2)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -188,7 +188,7 @@ GEM
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.45.0, < 2.0)
+      rubocop-ast (>= 1.45.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
     rubocop-ast (1.45.1)

data/lib/fbe/middleware/sqlite_store.rb

@@ -6,26 +6,66 @@
 require 'time'
 require 'json'
 require 'sqlite3'
+require 'loog'
 require_relative '../../fbe'
 require_relative '../../fbe/middleware'
 
 # Persisted SQLite store for Faraday::HttpCache
 #
+# This class provides a persistent cache store backed by SQLite for use with
+# Faraday::HttpCache middleware. It's designed to cache HTTP responses from
+# GitHub API calls to reduce API rate limit consumption and improve performance.
+#
+# Key features:
+# - Automatic version management to invalidate cache on version changes
+# - Size-based cache eviction (configurable, defaults to 10MB)
+# - Thread-safe SQLite transactions
+# - JSON serialization for cached values
+# - Filtering of non-cacheable requests (non-GET, URLs with query parameters)
+#
+# Usage example:
+#   store = Fbe::Middleware::SqliteStore.new(
+#     '/path/to/cache.db',
+#     '1.0.0',
+#     loog: logger,
+#     maxsize: 50 * 1024 * 1024  # 50MB max size
+#   )
+#
+#   # Use with Faraday
+#   Faraday.new do |builder|
+#     builder.use Faraday::HttpCache, store: store
+#   end
+#
+# The store automatically manages the SQLite database schema and handles
+# cleanup operations when the database grows too large. Old entries are
+# deleted based on their last access time to maintain the configured size limit.
+#
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2024-2025 Zerocracy
 # License:: MIT
 class Fbe::Middleware::SqliteStore
   attr_reader :path
 
-  def initialize(path, version)
+  # Initialize the SQLite store.
+  # @param path [String] Path to the SQLite database file
+  # @param version [String] Version identifier for cache compatibility
+  # @param loog [Loog] Logger instance (optional, defaults to Loog::NULL)
+  # @param maxsize [Integer] Maximum database size in bytes (optional, defaults to 10MB)
+  # @raise [ArgumentError] If path is nil/empty, directory doesn't exist, or version is nil/empty
+  def initialize(path, version, loog: Loog::NULL, maxsize: 10 * 1024 * 1024)
     raise ArgumentError, 'Database path cannot be nil or empty' if path.nil? || path.empty?
     dir = File.dirname(path)
     raise ArgumentError, "Directory #{dir} does not exist" unless File.directory?(dir)
     raise ArgumentError, 'Version cannot be nil or empty' if version.nil? || version.empty?
     @path = File.absolute_path(path)
     @version = version
+    @loog = loog
+    @maxsize = maxsize
   end
 
+  # Read a value from the cache.
+  # @param key [String] The cache key to read
+  # @return [Object, nil] The cached value parsed from JSON, or nil if not found
   def read(key)
     value = perform do |t|
       t.execute('UPDATE cache SET touched_at = ?2 WHERE key = ?1;', [key, Time.now.utc.iso8601])
@@ -34,11 +74,20 @@ class Fbe::Middleware::SqliteStore
     JSON.parse(value) if value
   end
 
+  # Delete a key from the cache.
+  # @param key [String] The cache key to delete
+  # @return [nil]
   def delete(key)
     perform { _1.execute('DELETE FROM cache WHERE key = ?', [key]) }
     nil
   end
 
+  # Write a value to the cache.
+  # @param key [String] The cache key to write
+  # @param value [Object] The value to cache (will be JSON encoded)
+  # @return [nil]
+  # @note Values larger than 10KB are not cached
+  # @note Non-GET requests and URLs with query parameters are not cached
   def write(key, value)
     return if value.is_a?(Array) && value.any? do |vv|
       req = JSON.parse(vv[0])
@@ -55,6 +104,8 @@ class Fbe::Middleware::SqliteStore
     nil
   end
 
+  # Clear all entries from the cache.
+  # @return [void]
   def clear
     perform do |t|
       t.execute 'DELETE FROM cache;'
@@ -63,6 +114,8 @@ class Fbe::Middleware::SqliteStore
     @db.execute 'VACUUM;'
   end
 
+  # Get all entries from the cache.
+  # @return [Array<Array>] Array of [key, value] pairs
   def all
     perform { _1.execute('SELECT key, value FROM cache') }
   end
@@ -73,26 +126,44 @@ class Fbe::Middleware::SqliteStore
     @db ||=
       SQLite3::Database.new(@path).tap do |d|
         d.transaction do |t|
-          t.execute <<~SQL
-            CREATE TABLE IF NOT EXISTS cache(
-              key TEXT UNIQUE NOT NULL, value TEXT, touched_at TEXT NOT NULL
-            );
-          SQL
+          t.execute 'CREATE TABLE IF NOT EXISTS cache(key TEXT UNIQUE NOT NULL, value TEXT);'
           t.execute 'CREATE INDEX IF NOT EXISTS cache_key_idx ON cache(key);'
-          t.execute 'CREATE INDEX IF NOT EXISTS cache_touched_at_idx ON cache(touched_at);'
           t.execute 'CREATE TABLE IF NOT EXISTS meta(key TEXT UNIQUE NOT NULL, value TEXT);'
           t.execute 'CREATE INDEX IF NOT EXISTS meta_key_idx ON meta(key);'
           t.execute "INSERT INTO meta(key, value) VALUES('version', ?) ON CONFLICT(key) DO NOTHING;", [@version]
         end
-        if d.execute("SELECT value FROM meta WHERE key = 'version' LIMIT 1;").dig(0, 0) != @version
+        if d.execute("SELECT 1 FROM pragma_table_info('cache') WHERE name = 'touched_at';").dig(0, 0) != 1
+          d.transaction do |t|
+            t.execute 'ALTER TABLE cache ADD COLUMN touched_at TEXT;'
+            t.execute 'UPDATE cache set touched_at = ?;', [Time.now.utc.iso8601]
+            t.execute 'ALTER TABLE cache RENAME TO cache_old;'
+            t.execute <<~SQL
+              CREATE TABLE IF NOT EXISTS cache(
+                key TEXT UNIQUE NOT NULL, value TEXT, touched_at TEXT NOT NULL
+              );
+            SQL
+            t.execute 'INSERT INTO cache SELECT * FROM cache_old;'
+            t.execute 'DROP TABLE cache_old;'
+            t.execute 'CREATE INDEX IF NOT EXISTS cache_touched_at_idx ON cache(touched_at);'
+          end
+          d.execute 'VACUUM;'
+        end
+        found = d.execute("SELECT value FROM meta WHERE key = 'version' LIMIT 1;").dig(0, 0)
+        if found != @version
+          @loog.info("Version mismatch in SQLite cache: stored '#{found}' != current '#{@version}', cleaning up")
           d.transaction do |t|
             t.execute 'DELETE FROM cache;'
             t.execute "UPDATE meta SET value = ? WHERE key = 'version';", [@version]
           end
           d.execute 'VACUUM;'
         end
-        if File.size(@path) > 10 * 1024 * 1024
-          while d.execute(<<~SQL).dig(0, 0) > 10 * 1024 * 1024
+        if File.size(@path) > @maxsize
+          @loog.info(
+            "SQLite cache file size (#{File.size(@path)} bytes) exceeds " \
+            "#{@maxsize / 1024 / 1024}MB, cleaning up old entries"
+          )
+          deleted = 0
+          while d.execute(<<~SQL).dig(0, 0) > @maxsize
             SELECT (page_count - freelist_count) * page_size AS size
             FROM pragma_page_count(), pragma_freelist_count(), pragma_page_size();
           SQL
@@ -101,9 +172,11 @@ class Fbe::Middleware::SqliteStore
                 DELETE FROM cache
                 WHERE key IN (SELECT key FROM cache ORDER BY touched_at LIMIT 50)
               SQL
+              deleted += t.changes
             end
           end
           d.execute 'VACUUM;'
+          @loog.info("Deleted #{deleted} old cache entries, new file size: #{File.size(@path)} bytes")
         end
         at_exit { @db&.close }
       end

data/lib/fbe/octo.rb

@@ -25,6 +25,10 @@ require_relative 'middleware/sqlite_store'
 # logging, and caching.
 #
 # @param [Judges::Options] options The options available globally
+# @option options [String] :github_token GitHub API token for authentication
+# @option options [Boolean] :testing When true, uses FakeOctokit for testing
+# @option options [String] :sqlite_cache Path to SQLite cache file for HTTP responses
+# @option options [Integer] :sqlite_cache_maxsize Maximum size of SQLite cache in bytes (default: 10MB)
 # @param [Hash] global Hash of global options
 # @param [Loog] loog Logging facility
 # @return [Hash] Usually returns a JSON, as it comes from the GitHub API
@@ -77,11 +81,12 @@ def Fbe.octo(options: $options, global: $global, loog: $loog)
               backoff_factor: 2
             )
             if options.sqlite_cache
-              store = Fbe::Middleware::SqliteStore.new(options.sqlite_cache, Fbe::VERSION)
+              maxsize = options.sqlite_cache_maxsize || (10 * 1024 * 1024)
+              store = Fbe::Middleware::SqliteStore.new(options.sqlite_cache, Fbe::VERSION, loog:, maxsize:)
               loog.info(
                 "Using HTTP cache in SQLite file: #{store.path} (" \
-                "#{File.exist?(store.path) ? "#{File.size(store.path)} bytes" : 'file is absent'}" \
-                ')'
+                "#{File.exist?(store.path) ? "#{File.size(store.path)} bytes" : 'file is absent'}, " \
+                "max size: #{maxsize / 1024 / 1024}MB)"
               )
               builder.use(
                 Faraday::HttpCache,

data/lib/fbe.rb

@@ -10,5 +10,5 @@
 # License:: MIT
 module Fbe
   # Current version of the gem (changed by +.rultor.yml+ on every release)
-  VERSION = '0.20.0' unless const_defined?(:VERSION)
+  VERSION = '0.21.1' unless const_defined?(:VERSION)
 end

data/test/fbe/middleware/test_sqlite_store.rb

@@ -182,6 +182,26 @@ class SqliteStoreTest < Fbe::Test
     end
   end
 
+  def test_upgrade_sqlite_schema_for_add_touched_at_column
+    with_tmpfile('a.db') do |f|
+      SQLite3::Database.new(f).tap do |d|
+        d.execute 'CREATE TABLE IF NOT EXISTS cache(key TEXT UNIQUE NOT NULL, value TEXT);'
+        [
+          ['key1', JSON.dump('value1')],
+          ['key2', JSON.dump('value2')]
+        ].each { d.execute 'INSERT INTO cache(key, value) VALUES(?1, ?2);', _1 }
+        d.execute 'CREATE TABLE IF NOT EXISTS meta(key TEXT UNIQUE NOT NULL, value TEXT);'
+        d.execute "INSERT INTO meta(key, value) VALUES('version', ?);", ['0.0.1']
+      end
+      Fbe::Middleware::SqliteStore.new(f, '0.0.1').then do |store|
+        assert_equal('value1', store.read('key1'))
+        assert_equal('value2', store.read('key2'))
+      rescue SQLite3::SQLException => e
+        assert_nil(e)
+      end
+    end
+  end
+
   private
 
   def with_tmpfile(name = 'test.db', &)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fbe
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.1
 platform: ruby
 authors:
 - Yegor Bugayenko