tina4ruby 3.11.15 → 3.11.17

data/lib/tina4/session_handlers/database_handler.rb

@@ -1,72 +1,72 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Tina4
-  module SessionHandlers
-    class DatabaseHandler
-      TABLE_NAME = "tina4_session"
-
-      CREATE_TABLE_SQL = <<~SQL
-        CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
-            session_id VARCHAR(255) PRIMARY KEY,
-            data TEXT NOT NULL,
-            expires_at REAL NOT NULL
-        )
-      SQL
-
-      def initialize(options = {})
-        @ttl = options[:ttl] || 86400
-        @db = options[:db] || Tina4::Database.new(ENV["DATABASE_URL"])
-        ensure_table
-      end
-
-      def read(session_id)
-        row = @db.fetch_one("SELECT data, expires_at FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
-        return nil unless row
-
-        expires_at = (row[:expires_at] || row["expires_at"]).to_f
-        if expires_at > 0 && expires_at < Time.now.to_f
-          destroy(session_id)
-          return nil
-        end
-
-        JSON.parse(row[:data] || row["data"])
-      rescue JSON::ParserError
-        nil
-      end
-
-      def write(session_id, data)
-        expires_at = @ttl > 0 ? Time.now.to_f + @ttl : 0.0
-        json_data = JSON.generate(data)
-
-        existing = @db.fetch_one("SELECT session_id FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
-        if existing
-          @db.execute("UPDATE #{TABLE_NAME} SET data = ?, expires_at = ? WHERE session_id = ?", [json_data, expires_at, session_id])
-        else
-          @db.execute("INSERT INTO #{TABLE_NAME} (session_id, data, expires_at) VALUES (?, ?, ?)", [session_id, json_data, expires_at])
-        end
-      end
-
-      def destroy(session_id)
-        @db.execute("DELETE FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
-      end
-
-      def cleanup
-        @db.execute("DELETE FROM #{TABLE_NAME} WHERE expires_at > 0 AND expires_at < ?", [Time.now.to_f])
-      end
-
-      # Garbage-collect expired sessions. Matches the Python interface.
-      # @param max_age [Integer] maximum session age in seconds (unused — expiry is absolute)
-      def gc(max_age)
-        @db.execute("DELETE FROM #{TABLE_NAME} WHERE expires_at > 0 AND expires_at < ?", [Time.now.to_f])
-      end
-
-      private
-
-      def ensure_table
-        @db.execute(CREATE_TABLE_SQL)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+
+module Tina4
+  module SessionHandlers
+    class DatabaseHandler
+      TABLE_NAME = "tina4_session"
+
+      CREATE_TABLE_SQL = <<~SQL
+        CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
+            session_id VARCHAR(255) PRIMARY KEY,
+            data TEXT NOT NULL,
+            expires_at REAL NOT NULL
+        )
+      SQL
+
+      def initialize(options = {})
+        @ttl = options[:ttl] || 86400
+        @db = options[:db] || Tina4::Database.new(ENV["DATABASE_URL"])
+        ensure_table
+      end
+
+      def read(session_id)
+        row = @db.fetch_one("SELECT data, expires_at FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
+        return nil unless row
+
+        expires_at = (row[:expires_at] || row["expires_at"]).to_f
+        if expires_at > 0 && expires_at < Time.now.to_f
+          destroy(session_id)
+          return nil
+        end
+
+        JSON.parse(row[:data] || row["data"])
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write(session_id, data)
+        expires_at = @ttl > 0 ? Time.now.to_f + @ttl : 0.0
+        json_data = JSON.generate(data)
+
+        existing = @db.fetch_one("SELECT session_id FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
+        if existing
+          @db.execute("UPDATE #{TABLE_NAME} SET data = ?, expires_at = ? WHERE session_id = ?", [json_data, expires_at, session_id])
+        else
+          @db.execute("INSERT INTO #{TABLE_NAME} (session_id, data, expires_at) VALUES (?, ?, ?)", [session_id, json_data, expires_at])
+        end
+      end
+
+      def destroy(session_id)
+        @db.execute("DELETE FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
+      end
+
+      def cleanup
+        @db.execute("DELETE FROM #{TABLE_NAME} WHERE expires_at > 0 AND expires_at < ?", [Time.now.to_f])
+      end
+
+      # Garbage-collect expired sessions. Matches the Python interface.
+      # @param max_age [Integer] maximum session age in seconds (unused — expiry is absolute)
+      def gc(max_age)
+        @db.execute("DELETE FROM #{TABLE_NAME} WHERE expires_at > 0 AND expires_at < ?", [Time.now.to_f])
+      end
+
+      private
+
+      def ensure_table
+        @db.execute(CREATE_TABLE_SQL)
+      end
+    end
+  end
+end

data/lib/tina4/session_handlers/file_handler.rb

@@ -1,67 +1,67 @@
-# frozen_string_literal: true
-require "json"
-require "fileutils"
-
-module Tina4
-  module SessionHandlers
-    class FileHandler
-      def initialize(options = {})
-        @dir = options[:dir] || File.join(Dir.pwd, "sessions")
-        @ttl = options[:ttl] || 86400
-        FileUtils.mkdir_p(@dir)
-      end
-
-      def read(session_id)
-        path = session_path(session_id)
-        return nil unless File.exist?(path)
-
-        # Check expiry
-        if File.mtime(path) + @ttl < Time.now
-          File.delete(path)
-          return nil
-        end
-
-        data = File.read(path)
-        JSON.parse(data)
-      rescue JSON::ParserError
-        nil
-      end
-
-      def write(session_id, data)
-        path = session_path(session_id)
-        File.write(path, JSON.generate(data))
-      end
-
-      def destroy(session_id)
-        path = session_path(session_id)
-        File.delete(path) if File.exist?(path)
-      end
-
-      def cleanup
-        return unless Dir.exist?(@dir)
-        Dir.glob(File.join(@dir, "sess_*")).each do |file|
-          File.delete(file) if File.mtime(file) + @ttl < Time.now
-        end
-      end
-
-      # Garbage-collect expired sessions. Matches the Python interface.
-      # @param max_age [Integer] maximum session age in seconds
-      def gc(max_age)
-        return unless Dir.exist?(@dir)
-        now = Time.now
-        Dir.glob(File.join(@dir, "sess_*")).each do |file|
-          File.delete(file) if File.mtime(file) + max_age < now
-        rescue StandardError
-          # Corrupt or locked file — skip
-        end
-      end
-
-      private
-
-      def session_path(session_id)
-        safe_id = session_id.gsub(/[^a-zA-Z0-9_-]/, "")
-        File.join(@dir, "sess_#{safe_id}.json")
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require "json"
+require "fileutils"
+
+module Tina4
+  module SessionHandlers
+    class FileHandler
+      def initialize(options = {})
+        @dir = options[:dir] || File.join(Dir.pwd, "sessions")
+        @ttl = options[:ttl] || 86400
+        FileUtils.mkdir_p(@dir)
+      end
+
+      def read(session_id)
+        path = session_path(session_id)
+        return nil unless File.exist?(path)
+
+        # Check expiry
+        if File.mtime(path) + @ttl < Time.now
+          File.delete(path)
+          return nil
+        end
+
+        data = File.read(path)
+        JSON.parse(data)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write(session_id, data)
+        path = session_path(session_id)
+        File.write(path, JSON.generate(data))
+      end
+
+      def destroy(session_id)
+        path = session_path(session_id)
+        File.delete(path) if File.exist?(path)
+      end
+
+      def cleanup
+        return unless Dir.exist?(@dir)
+        Dir.glob(File.join(@dir, "sess_*")).each do |file|
+          File.delete(file) if File.mtime(file) + @ttl < Time.now
+        end
+      end
+
+      # Garbage-collect expired sessions. Matches the Python interface.
+      # @param max_age [Integer] maximum session age in seconds
+      def gc(max_age)
+        return unless Dir.exist?(@dir)
+        now = Time.now
+        Dir.glob(File.join(@dir, "sess_*")).each do |file|
+          File.delete(file) if File.mtime(file) + max_age < now
+        rescue StandardError
+          # Corrupt or locked file — skip
+        end
+      end
+
+      private
+
+      def session_path(session_id)
+        safe_id = session_id.gsub(/[^a-zA-Z0-9_-]/, "")
+        File.join(@dir, "sess_#{safe_id}.json")
+      end
+    end
+  end
+end

data/lib/tina4/session_handlers/mongo_handler.rb

@@ -1,49 +1,49 @@
-# frozen_string_literal: true
-require "json"
-
-module Tina4
-  module SessionHandlers
-    class MongoHandler
-      def initialize(options = {})
-        require "mongo"
-        @ttl = options[:ttl] || 86400
-        client = Mongo::Client.new(
-          options[:uri] || "mongodb://localhost:27017",
-          database: options[:database] || "tina4_sessions"
-        )
-        @collection = client[options[:collection] || "sessions"]
-        # Ensure TTL index
-        @collection.indexes.create_one(
-          { updated_at: 1 },
-          expire_after_seconds: @ttl
-        )
-      rescue LoadError
-        raise "MongoDB session handler requires the 'mongo' gem. Install with: gem install mongo"
-      rescue Mongo::Error => e
-        Tina4::Log.error("MongoDB session setup failed: #{e.message}")
-      end
-
-      def read(session_id)
-        doc = @collection.find(_id: session_id).first
-        return nil unless doc
-        doc["data"]
-      end
-
-      def write(session_id, data)
-        @collection.update_one(
-          { _id: session_id },
-          { "$set" => { data: data, updated_at: Time.now } },
-          upsert: true
-        )
-      end
-
-      def destroy(session_id)
-        @collection.delete_one(_id: session_id)
-      end
-
-      def cleanup
-        # MongoDB TTL index handles cleanup
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  module SessionHandlers
+    class MongoHandler
+      def initialize(options = {})
+        require "mongo"
+        @ttl = options[:ttl] || 86400
+        client = Mongo::Client.new(
+          options[:uri] || "mongodb://localhost:27017",
+          database: options[:database] || "tina4_sessions"
+        )
+        @collection = client[options[:collection] || "sessions"]
+        # Ensure TTL index
+        @collection.indexes.create_one(
+          { updated_at: 1 },
+          expire_after_seconds: @ttl
+        )
+      rescue LoadError
+        raise "MongoDB session handler requires the 'mongo' gem. Install with: gem install mongo"
+      rescue Mongo::Error => e
+        Tina4::Log.error("MongoDB session setup failed: #{e.message}")
+      end
+
+      def read(session_id)
+        doc = @collection.find(_id: session_id).first
+        return nil unless doc
+        doc["data"]
+      end
+
+      def write(session_id, data)
+        @collection.update_one(
+          { _id: session_id },
+          { "$set" => { data: data, updated_at: Time.now } },
+          upsert: true
+        )
+      end
+
+      def destroy(session_id)
+        @collection.delete_one(_id: session_id)
+      end
+
+      def cleanup
+        # MongoDB TTL index handles cleanup
+      end
+    end
+  end
+end

data/lib/tina4/session_handlers/redis_handler.rb

@@ -1,43 +1,43 @@
-# frozen_string_literal: true
-require "json"
-
-module Tina4
-  module SessionHandlers
-    class RedisHandler
-      def initialize(options = {})
-        require "redis"
-        @prefix = options[:prefix] || "tina4:session:"
-        @ttl = options[:ttl] || 86400
-        @redis = Redis.new(
-          host: options[:host] || "localhost",
-          port: options[:port] || 6379,
-          db: options[:db] || 0,
-          password: options[:password]
-        )
-      rescue LoadError
-        raise "Redis session handler requires the 'redis' gem. Install with: gem install redis"
-      end
-
-      def read(session_id)
-        data = @redis.get("#{@prefix}#{session_id}")
-        return nil unless data
-        JSON.parse(data)
-      rescue JSON::ParserError
-        nil
-      end
-
-      def write(session_id, data)
-        key = "#{@prefix}#{session_id}"
-        @redis.setex(key, @ttl, JSON.generate(data))
-      end
-
-      def destroy(session_id)
-        @redis.del("#{@prefix}#{session_id}")
-      end
-
-      def cleanup
-        # Redis handles TTL automatically
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  module SessionHandlers
+    class RedisHandler
+      def initialize(options = {})
+        require "redis"
+        @prefix = options[:prefix] || "tina4:session:"
+        @ttl = options[:ttl] || 86400
+        @redis = Redis.new(
+          host: options[:host] || "localhost",
+          port: options[:port] || 6379,
+          db: options[:db] || 0,
+          password: options[:password]
+        )
+      rescue LoadError
+        raise "Redis session handler requires the 'redis' gem. Install with: gem install redis"
+      end
+
+      def read(session_id)
+        data = @redis.get("#{@prefix}#{session_id}")
+        return nil unless data
+        JSON.parse(data)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write(session_id, data)
+        key = "#{@prefix}#{session_id}"
+        @redis.setex(key, @ttl, JSON.generate(data))
+      end
+
+      def destroy(session_id)
+        @redis.del("#{@prefix}#{session_id}")
+      end
+
+      def cleanup
+        # Redis handles TTL automatically
+      end
+    end
+  end
+end

data/lib/tina4/session_handlers/valkey_handler.rb

@@ -1,43 +1,43 @@
-# frozen_string_literal: true
-require "json"
-
-module Tina4
-  module SessionHandlers
-    class ValkeyHandler
-      def initialize(options = {})
-        require "redis"
-        @prefix = options[:prefix] || ENV["TINA4_SESSION_VALKEY_PREFIX"] || "tina4:session:"
-        @ttl = options[:ttl] || (ENV["TINA4_SESSION_VALKEY_TTL"] ? ENV["TINA4_SESSION_VALKEY_TTL"].to_i : 86400)
-        @redis = Redis.new(
-          host: options[:host] || ENV["TINA4_SESSION_VALKEY_HOST"] || "localhost",
-          port: options[:port] || (ENV["TINA4_SESSION_VALKEY_PORT"] ? ENV["TINA4_SESSION_VALKEY_PORT"].to_i : 6379),
-          db: options[:db] || (ENV["TINA4_SESSION_VALKEY_DB"] ? ENV["TINA4_SESSION_VALKEY_DB"].to_i : 0),
-          password: options[:password] || ENV["TINA4_SESSION_VALKEY_PASSWORD"]
-        )
-      rescue LoadError
-        raise "Valkey session handler requires the 'redis' gem (Valkey uses the RESP protocol). Install with: gem install redis"
-      end
-
-      def read(session_id)
-        data = @redis.get("#{@prefix}#{session_id}")
-        return nil unless data
-        JSON.parse(data)
-      rescue JSON::ParserError
-        nil
-      end
-
-      def write(session_id, data)
-        key = "#{@prefix}#{session_id}"
-        @redis.setex(key, @ttl, JSON.generate(data))
-      end
-
-      def destroy(session_id)
-        @redis.del("#{@prefix}#{session_id}")
-      end
-
-      def cleanup
-        # Valkey handles TTL automatically (same as Redis)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  module SessionHandlers
+    class ValkeyHandler
+      def initialize(options = {})
+        require "redis"
+        @prefix = options[:prefix] || ENV["TINA4_SESSION_VALKEY_PREFIX"] || "tina4:session:"
+        @ttl = options[:ttl] || (ENV["TINA4_SESSION_VALKEY_TTL"] ? ENV["TINA4_SESSION_VALKEY_TTL"].to_i : 86400)
+        @redis = Redis.new(
+          host: options[:host] || ENV["TINA4_SESSION_VALKEY_HOST"] || "localhost",
+          port: options[:port] || (ENV["TINA4_SESSION_VALKEY_PORT"] ? ENV["TINA4_SESSION_VALKEY_PORT"].to_i : 6379),
+          db: options[:db] || (ENV["TINA4_SESSION_VALKEY_DB"] ? ENV["TINA4_SESSION_VALKEY_DB"].to_i : 0),
+          password: options[:password] || ENV["TINA4_SESSION_VALKEY_PASSWORD"]
+        )
+      rescue LoadError
+        raise "Valkey session handler requires the 'redis' gem (Valkey uses the RESP protocol). Install with: gem install redis"
+      end
+
+      def read(session_id)
+        data = @redis.get("#{@prefix}#{session_id}")
+        return nil unless data
+        JSON.parse(data)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write(session_id, data)
+        key = "#{@prefix}#{session_id}"
+        @redis.setex(key, @ttl, JSON.generate(data))
+      end
+
+      def destroy(session_id)
+        @redis.del("#{@prefix}#{session_id}")
+      end
+
+      def cleanup
+        # Valkey handles TTL automatically (same as Redis)
+      end
+    end
+  end
+end