factorix 0.6.0 → 0.7.0

data/lib/factorix/http/cache_decorator.rb

@@ -50,9 +50,9 @@ module Factorix
         # Don't cache streaming requests
         return client.get(uri, headers:, &block) if block
 
-        key = cache.key_for(uri.to_s)
+        cache_key = uri.to_s
 
-        cached_body = cache.read(key)
+        cached_body = cache.read(cache_key)
         if cached_body
           logger.debug("Cache hit", uri: uri.to_s)
           publish("cache.hit", url: uri.to_s)
@@ -63,9 +63,9 @@ module Factorix
         publish("cache.miss", url: uri.to_s)
 
         # Locking prevents concurrent downloads of the same resource
-        cache.with_lock(key) do
+        cache.with_lock(cache_key) do
           # Double-check: another thread might have filled the cache
-          cached_body = cache.read(key)
+          cached_body = cache.read(cache_key)
           if cached_body
             publish("cache.hit", url: uri.to_s)
             return CachedResponse.new(cached_body)
@@ -77,7 +77,7 @@ module Factorix
             with_temporary_file do |temp|
               temp.write(response.body)
               temp.close
-              cache.store(key, Pathname(temp.path))
+              cache.store(cache_key, Pathname(temp.path))
             end
           end
 

data/lib/factorix/info_json.rb

@@ -49,19 +49,19 @@ module Factorix
     def self.from_zip(zip_path)
       cache = Container.resolve(:info_json_cache)
       logger = Container.resolve(:logger)
-      cache_key = cache.key_for(zip_path.to_s)
+      cache_key = zip_path.to_s
 
-      if (cached_json = cache.read(cache_key, encoding: Encoding::UTF_8))
+      if (cached_json = cache.read(cache_key))
         logger.debug("info.json cache hit", path: zip_path.to_s)
-        return from_json(cached_json)
+        return from_json((+cached_json).force_encoding(Encoding::UTF_8))
       end
 
       logger.debug("info.json cache miss", path: zip_path.to_s)
 
       cache.with_lock(cache_key) do
-        if (cached_json = cache.read(cache_key, encoding: Encoding::UTF_8))
+        if (cached_json = cache.read(cache_key))
           logger.debug("info.json cache hit (after lock)", path: zip_path.to_s)
-          return from_json(cached_json)
+          return from_json((+cached_json).force_encoding(Encoding::UTF_8))
         end
 
         json_string = Zip::File.open(zip_path) {|zip_file|

data/lib/factorix/portal.rb

@@ -72,12 +72,13 @@ module Factorix
     #
     # @param release [API::Release] release object containing download_url and sha1
     # @param output [Pathname] output file path
+    # @param handler [Object, nil] event handler for download progress (optional)
     # @return [void]
     # @raise [DigestMismatchError] if SHA1 verification fails
-    def download_mod(release, output)
+    def download_mod(release, output, handler: nil)
       # Extract path from URI::HTTPS
       download_path = release.download_url.path
-      mod_download_api.download(download_path, output, expected_sha1: release.sha1)
+      mod_download_api.download(download_path, output, expected_sha1: release.sha1, handler:)
     end
 
     # Upload a MOD file to the portal

data/lib/factorix/transfer/downloader.rb

@@ -53,9 +53,9 @@ module Factorix
         end
 
         logger.info("Starting download", output: output.to_s)
-        key = cache.key_for(url.to_s)
+        cache_key = strip_query(url)
 
-        case try_cache_hit(key, output, expected_sha1:)
+        case try_cache_hit(cache_key, output, expected_sha1:)
         when :hit
           return
         when :miss
@@ -68,14 +68,14 @@ module Factorix
           raise RuntimeError, "Unexpected cache state"
         end
 
-        cache.with_lock(key) do
-          return if try_cache_hit(key, output, expected_sha1:) == :hit
+        cache.with_lock(cache_key) do
+          return if try_cache_hit(cache_key, output, expected_sha1:) == :hit
 
           with_temporary_file do |temp_file|
             download_file_with_progress(url, temp_file)
             verify_sha1(temp_file, expected_sha1) if expected_sha1
-            cache.store(key, temp_file)
-            cache.fetch(key, output)
+            cache.store(cache_key, temp_file)
+            cache.write_to(cache_key, output)
           end
         end
       end
@@ -112,21 +112,21 @@ module Factorix
       # If the cached file exists but fails SHA1 verification, the cache entry
       # is invalidated and :corrupted is returned to trigger re-download.
       #
-      # @param key [String] cache key
+      # @param cache_key [String] logical cache key (URL string)
       # @param output [Pathname] path to save the cached file
       # @param expected_sha1 [String, nil] expected SHA1 digest for verification (optional)
       # @return [Symbol] :hit if cache hit with valid SHA1, :miss if not cached, :corrupted if SHA1 mismatch
-      private def try_cache_hit(key, output, expected_sha1:)
-        return :miss unless cache.fetch(key, output)
+      private def try_cache_hit(cache_key, output, expected_sha1:)
+        return :miss unless cache.write_to(cache_key, output)
 
         logger.info("Cache hit", output: output.to_s)
         verify_sha1(output, expected_sha1) if expected_sha1
-        total_size = cache.size(key)
+        total_size = cache.size(cache_key)
         publish("cache.hit", output: output.to_s, total_size:)
         :hit
       rescue DigestMismatchError => e
         logger.warn("Cache corrupted, invalidating", output: output.to_s, error: e.message)
-        cache.delete(key)
+        cache.delete(cache_key)
         :corrupted
       end
 
@@ -144,6 +144,14 @@ module Factorix
         raise DigestMismatchError, "SHA1 mismatch: expected #{expected_sha1}, got #{actual_sha1}"
       end
 
+      # Strip query parameters from a URI to create a safe cache key.
+      # This prevents sensitive data (e.g., authentication tokens) from being
+      # stored in cache metadata.
+      #
+      # @param uri [URI] the URI to strip
+      # @return [String] URI string without query parameters
+      private def strip_query(uri) = uri.dup.tap {|u| u.query = nil }.to_s
+
       # Create a temporary file for downloading, ensuring cleanup after use.
       #
       # @yield [Pathname] the temporary file path

data/lib/factorix/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Factorix
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
   public_constant :VERSION
 end

data/lib/factorix.rb

@@ -35,29 +35,65 @@ module Factorix
   end
 
   # Cache settings
+  # Each cache type can have its own backend with hierarchical configuration.
+  # Common settings (backend, ttl) apply to all backends.
+  # Backend-specific settings are nested under the backend name.
   setting :cache do
     # Download cache settings (for MOD files)
     setting :download do
-      setting :dir, constructor: ->(value) { Pathname(value) }
+      setting :backend, default: :file_system
       setting :ttl, default: nil # nil for unlimited (MOD files are immutable)
-      setting :max_file_size, default: nil # nil for unlimited
-      setting :compression_threshold, default: nil # nil for no compression (binary files)
+      setting :file_system do
+        setting :max_file_size, default: nil # nil for unlimited
+        setting :compression_threshold, default: nil # nil for no compression (binary files)
+      end
+      setting :redis do
+        setting :url, default: nil # nil falls back to REDIS_URL env, then localhost:6379
+        setting :lock_timeout, default: 30
+      end
+      setting :s3 do
+        setting :bucket, default: nil # required when using S3 backend
+        setting :region, default: nil # nil falls back to AWS_REGION env or SDK default
+        setting :lock_timeout, default: 30
+      end
     end
 
     # API cache settings (for API responses)
     setting :api do
-      setting :dir, constructor: ->(value) { Pathname(value) }
+      setting :backend, default: :file_system
       setting :ttl, default: 3600 # 1 hour (API responses may change)
-      setting :max_file_size, default: 10 * 1024 * 1024 # 10MiB (JSON responses)
-      setting :compression_threshold, default: 0 # always compress (JSON is highly compressible)
+      setting :file_system do
+        setting :max_file_size, default: 10 * 1024 * 1024 # 10MiB (JSON responses)
+        setting :compression_threshold, default: 0 # always compress (JSON is highly compressible)
+      end
+      setting :redis do
+        setting :url, default: nil # nil falls back to REDIS_URL env, then localhost:6379
+        setting :lock_timeout, default: 30
+      end
+      setting :s3 do
+        setting :bucket, default: nil # required when using S3 backend
+        setting :region, default: nil # nil falls back to AWS_REGION env or SDK default
+        setting :lock_timeout, default: 30
+      end
     end
 
     # info.json cache settings (for MOD metadata from ZIP files)
     setting :info_json do
-      setting :dir, constructor: ->(value) { Pathname(value) }
+      setting :backend, default: :file_system
       setting :ttl, default: nil # nil for unlimited (info.json is immutable within a MOD ZIP)
-      setting :max_file_size, default: nil # nil for unlimited (info.json is small)
-      setting :compression_threshold, default: 0 # always compress (JSON is highly compressible)
+      setting :file_system do
+        setting :max_file_size, default: nil # nil for unlimited (info.json is small)
+        setting :compression_threshold, default: 0 # always compress (JSON is highly compressible)
+      end
+      setting :redis do
+        setting :url, default: nil # nil falls back to REDIS_URL env, then localhost:6379
+        setting :lock_timeout, default: 30
+      end
+      setting :s3 do
+        setting :bucket, default: nil # required when using S3 backend
+        setting :region, default: nil # nil falls back to AWS_REGION env or SDK default
+        setting :lock_timeout, default: 30
+      end
     end
   end
 
@@ -108,48 +144,4 @@ module Factorix
 
   Import = Dry::AutoInject(Container)
   public_constant :Import
-
-  # Initialize cache directory defaults after Container is loaded
-  runtime = Container.resolve(:runtime)
-  config.cache.download.dir = runtime.factorix_cache_dir / "download"
-  config.cache.api.dir = runtime.factorix_cache_dir / "api"
-  config.cache.info_json.dir = runtime.factorix_cache_dir / "info_json"
-
-  # @deprecated Use {Container} for DI and {Factorix} for configuration. Will be removed in v1.0.
-  class Application
-    # @!method [](key)
-    #   @deprecated Use {Container.[]} instead
-    def self.[](key)
-      warn "[factorix] Factorix::Application is deprecated, use Factorix::Container for DI"
-      Container[key]
-    end
-
-    # @!method resolve(key)
-    #   @deprecated Use {Container.resolve} instead
-    def self.resolve(key)
-      warn "[factorix] Factorix::Application is deprecated, use Factorix::Container for DI"
-      Container.resolve(key)
-    end
-
-    # @!method register(...)
-    #   @deprecated Use {Container.register} instead
-    def self.register(...)
-      warn "[factorix] Factorix::Application is deprecated, use Factorix::Container for DI"
-      Container.register(...)
-    end
-
-    # @!method config
-    #   @deprecated Use {Factorix.config} instead
-    def self.config
-      warn "[factorix] Factorix::Application is deprecated, use Factorix.config for configuration"
-      Factorix.config
-    end
-
-    # @!method configure(&block)
-    #   @deprecated Use {Factorix.configure} instead
-    def self.configure(&)
-      warn "[factorix] Factorix::Application is deprecated, use Factorix.configure for configuration"
-      Factorix.configure(&)
-    end
-  end
 end

data/sig/factorix/api/mod_download_api.rbs

@@ -7,12 +7,11 @@ module Factorix
     class MODDownloadAPI
       BASE_URL: String
 
-      attr_reader downloader: Transfer::Downloader
       attr_reader logger: Dry::Logger::Dispatcher
 
       def initialize: (**untyped deps) -> void
 
-      def download: (String download_url, Pathname output, ?expected_sha1: String?) -> void
+      def download: (String download_url, Pathname output, ?expected_sha1: String?, ?handler: untyped?) -> void
     end
   end
 end

data/sig/factorix/cache/base.rbs

@@ -0,0 +1,28 @@
+# RBS type signature file
+
+module Factorix
+  module Cache
+    class Base
+      attr_reader ttl: Integer?
+
+      def initialize: (?ttl: Integer?) -> void
+
+      def exist?: (String key) -> bool
+      def read: (String key) -> String?
+      def store: (String key, Pathname src) -> bool
+      def delete: (String key) -> bool
+      def clear: () -> void
+
+      def with_lock: (String key) { () -> void } -> void
+
+      def age: (String key) -> Float?
+      def expired?: (String key) -> bool
+      def size: (String key) -> Integer?
+
+      def each: () -> Enumerator[[String, Entry], void]
+              | () { ([String, Entry]) -> void } -> void
+
+      def backend_info: () -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/factorix/cache/entry.rbs

@@ -0,0 +1,14 @@
+# RBS type signature file
+
+module Factorix
+  module Cache
+    class Entry
+      attr_reader size: Integer
+      attr_reader age: Float
+
+      def expired?: () -> bool
+
+      def initialize: (size: Integer, age: Float, expired: bool) -> void
+    end
+  end
+end

data/sig/factorix/cache/file_system.rbs

@@ -4,18 +4,16 @@
 
 module Factorix
   module Cache
-    class FileSystem
+    class FileSystem < Base
       LOCK_FILE_LIFETIME: Integer
 
-      def initialize: (Pathname cache_dir, ?ttl: Integer?, ?max_file_size: Integer?, ?compression_threshold: Integer?) -> void
-
-      def key_for: (String url_string) -> String
+      def initialize: (cache_type: Symbol, ?ttl: Integer?, ?max_file_size: Integer?, ?compression_threshold: Integer?) -> void
 
       def exist?: (String key) -> bool
 
-      def fetch: (String key, Pathname output) -> bool
+      def write_to: (String key, Pathname output) -> bool
 
-      def read: (String key, ?encoding: Encoding | String) -> String?
+      def read: (String key) -> String?
 
       def store: (String key, Pathname src) -> bool
 
@@ -30,6 +28,9 @@ module Factorix
       def size: (String key) -> Integer?
 
       def with_lock: [T] (String key) { () -> T } -> T
+
+      def each: () { (String, Entry) -> void } -> void
+              | () -> Enumerator[[String, Entry], void]
     end
   end
 end

data/sig/factorix/cache/redis.rbs

@@ -0,0 +1,36 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Cache
+    class Redis < Base
+      DEFAULT_LOCK_TIMEOUT: Integer
+
+      def initialize: (?url: String?, cache_type: String | Symbol, ?lock_timeout: Integer, ?ttl: Integer?) -> void
+
+      def exist?: (String key) -> bool
+
+      def read: (String key) -> String?
+
+      def write_to: (String key, Pathname output) -> bool
+
+      def store: (String key, Pathname src) -> bool
+
+      def delete: (String key) -> bool
+
+      def clear: () -> void
+
+      def age: (String key) -> Integer?
+
+      def expired?: (String key) -> bool
+
+      def size: (String key) -> Integer?
+
+      def with_lock: [T] (String key) { () -> T } -> T
+
+      def each: () { (String, Entry) -> void } -> void
+              | () -> Enumerator[[String, Entry], void]
+    end
+  end
+end

data/sig/factorix/cache/s3.rbs

@@ -0,0 +1,38 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Cache
+    class S3 < Base
+      DEFAULT_LOCK_TIMEOUT: Integer
+
+      def initialize: (bucket: String, cache_type: String | Symbol, ?region: String?, ?lock_timeout: Integer, ?ttl: Integer?) -> void
+
+      def exist?: (String key) -> bool
+
+      def read: (String key) -> String?
+
+      def write_to: (String key, Pathname output) -> bool
+
+      def store: (String key, Pathname src) -> bool
+
+      def delete: (String key) -> bool
+
+      def clear: () -> void
+
+      def age: (String key) -> Integer?
+
+      def expired?: (String key) -> bool
+
+      def size: (String key) -> Integer?
+
+      def with_lock: [T] (String key) { () -> T } -> T
+
+      def each: () { (String, Entry) -> void } -> void
+              | () -> Enumerator[[String, Entry], void]
+
+      def backend_info: () -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/factorix/errors.rbs

@@ -49,6 +49,9 @@ module Factorix
   class HTTPServerError < HTTPError
   end
 
+  class LockTimeoutError < InfrastructureError
+  end
+
   class DigestMismatchError < InfrastructureError
   end
 

data/sig/factorix/portal.rbs

@@ -18,7 +18,7 @@ module Factorix
 
     def get_mod_full: (String name) -> API::MODInfo
 
-    def download_mod: (API::Release release, Pathname output) -> void
+    def download_mod: (API::Release release, Pathname output, ?handler: untyped?) -> void
 
     def upload_mod: (String mod_name, Pathname file_path, **untyped metadata) -> void
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factorix
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - OZAWA Sakuro
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-18 00:00:00.000000000 Z
+date: 2026-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: dry-logger
   requirement: !ruby/object:Gem::Requirement
@@ -221,7 +235,11 @@ files:
 - lib/factorix/api/release.rb
 - lib/factorix/api/tag.rb
 - lib/factorix/api_credential.rb
+- lib/factorix/cache/base.rb
+- lib/factorix/cache/entry.rb
 - lib/factorix/cache/file_system.rb
+- lib/factorix/cache/redis.rb
+- lib/factorix/cache/s3.rb
 - lib/factorix/cli.rb
 - lib/factorix/cli/commands/backup_support.rb
 - lib/factorix/cli/commands/base.rb
@@ -252,6 +270,7 @@ files:
 - lib/factorix/cli/commands/mod/update.rb
 - lib/factorix/cli/commands/mod/upload.rb
 - lib/factorix/cli/commands/path.rb
+- lib/factorix/cli/commands/portal_support.rb
 - lib/factorix/cli/commands/requires_game_stopped.rb
 - lib/factorix/cli/commands/version.rb
 - lib/factorix/container.rb
@@ -322,7 +341,11 @@ files:
 - sig/factorix/api/release.rbs
 - sig/factorix/api/tag.rbs
 - sig/factorix/api_credential.rbs
+- sig/factorix/cache/base.rbs
+- sig/factorix/cache/entry.rbs
 - sig/factorix/cache/file_system.rbs
+- sig/factorix/cache/redis.rbs
+- sig/factorix/cache/s3.rbs
 - sig/factorix/cli.rbs
 - sig/factorix/cli/commands/base.rbs
 - sig/factorix/cli/commands/cache/evict.rbs