factorix 0.6.0 → 0.7.0

data/lib/factorix/cli/commands/cache/evict.rb

@@ -48,7 +48,6 @@ module Factorix
           def call(caches: nil, all: false, expired: false, older_than: nil, **)
             validate_options!(all, expired, older_than)
 
-            @now = Time.now
             @older_than_seconds = parse_age(older_than) if older_than
 
             cache_names = resolve_cache_names(caches)
@@ -114,25 +113,26 @@ module Factorix
           # @param expired [Boolean] remove expired entries only
           # @return [Hash] eviction result with :count and :size
           private def evict_cache(name, all:, expired:)
-            config = Factorix.config.cache.public_send(name)
-            cache_dir = config.dir
-            ttl = config.ttl
-
-            return {count: 0, size: 0} unless cache_dir.exist?
+            cache = Container.resolve(:"#{name}_cache")
 
             count = 0
             size = 0
 
-            cache_dir.glob("**/*").each do |path|
-              next unless path.file?
-              next if path.extname == ".lock"
+            # Collect keys to evict (we can't modify during iteration)
+            to_evict = []
+            cache.each do |key, entry|
+              next unless should_evict?(entry, all:, expired:)
+
+              to_evict << [key, entry.size]
+            end
 
-              next unless should_evict?(path, ttl, all:, expired:)
+            # Perform eviction
+            to_evict.each do |key, entry_size|
+              next unless cache.delete(key)
 
-              size += path.size
-              path.delete
               count += 1
-              logger.debug("Evicted cache entry", path: path.to_s)
+              size += entry_size
+              logger.debug("Evicted cache entry", key:)
             end
 
             logger.info("Evicted cache entries", cache: name, count:, size:)
@@ -141,23 +141,18 @@ module Factorix
 
           # Determine if a cache entry should be evicted
           #
-          # @param path [Pathname] path to cache entry
-          # @param ttl [Integer, nil] cache TTL
+          # @param entry [Cache::Entry] cache entry
           # @param all [Boolean] remove all entries
           # @param expired [Boolean] remove expired entries only
           # @return [Boolean] true if entry should be evicted
-          private def should_evict?(path, ttl, all:, expired:)
+          private def should_evict?(entry, all:, expired:)
             return true if all
 
-            age_seconds = @now - path.mtime
-
             if expired
-              return false if ttl.nil? # No TTL means never expires
-
-              age_seconds > ttl
+              entry.expired?
             else
               # --older-than
-              age_seconds > @older_than_seconds
+              entry.age > @older_than_seconds
             end
           end
 

data/lib/factorix/cli/commands/cache/stat.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "dry/inflector"
 require "json"
 
 module Factorix
@@ -8,13 +9,12 @@ module Factorix
       module Cache
         # Display cache statistics
         #
-        # This command outout.puts statistics for all cache stores
+        # This command outputs statistics for all cache stores
         # in a human-readable or JSON format.
         #
         # @example
         #   $ factorix cache stat
         #   download:
-        #     Directory:      ~/.cache/factorix/download
         #     TTL:            unlimited
         #     Entries:        42 / 42 (100.0% valid)
         #     ...
@@ -41,7 +41,6 @@ module Factorix
           def call(json:, **)
             logger.debug("Collecting cache statistics")
 
-            @now = Time.now
             cache_names = Factorix.config.cache.values.keys
             stats = cache_names.to_h {|name| [name, collect_stats(name)] }
 
@@ -52,52 +51,42 @@ module Factorix
             end
           end
 
+          # Collect statistics for a cache
+          #
+          # @param name [Symbol] cache name
+          # @return [Hash] cache statistics
           private def collect_stats(name)
+            cache = Container.resolve(:"#{name}_cache")
             config = Factorix.config.cache.public_send(name)
-            cache_dir = config.dir
 
-            entries = scan_entries(cache_dir, config.ttl)
+            entries = scan_entries(cache)
 
             {
-              directory: cache_dir.to_s,
               ttl: config.ttl,
-              max_file_size: config.max_file_size,
-              compression_threshold: config.compression_threshold,
               entries: build_entry_stats(entries),
               size: build_size_stats(entries),
               age: build_age_stats(entries),
-              stale_locks: count_stale_locks(cache_dir)
+              backend_info: cache.backend_info
             }
           end
 
-          # Scan cache directory and collect entry information
+          # Collect cache entries using the cache interface
           #
-          # @param cache_dir [Pathname] cache directory path
-          # @param ttl [Integer, nil] time-to-live in seconds
-          # @return [Array<Hash>] array of entry info hashes
-          private def scan_entries(cache_dir, ttl)
-            return [] unless cache_dir.exist?
-
+          # @param cache [Cache::Base] cache instance
+          # @return [Array<Cache::Entry>] array of cache entries
+          private def scan_entries(cache)
             entries = []
-            cache_dir.glob("**/*").each do |path|
-              next unless path.file?
-              next if path.extname == ".lock"
-
-              age_seconds = @now - path.mtime
-              expired = ttl ? age_seconds > ttl : false
-
-              entries << {size: path.size, age: age_seconds, expired:}
-            end
+            cache.each {|_key, entry| entries << entry }
             entries
           end
 
           # Build entry count statistics
           #
-          # @param entries [Array<Hash>] entry info array
+          # @param entries [Array<Cache::Entry>] entry array
           # @return [Hash] entry statistics
           private def build_entry_stats(entries)
             total = entries.size
-            valid = entries.count {|e| !e[:expired] }
+            valid = entries.count {|e| !e.expired? }
             expired = total - valid
 
             {total:, valid:, expired:}
@@ -105,37 +94,26 @@ module Factorix
 
           # Build size statistics
           #
-          # @param entries [Array<Hash>] entry info array
+          # @param entries [Array<Cache::Entry>] entry array
           # @return [Hash] size statistics
           private def build_size_stats(entries)
             return {total: 0, avg: 0, min: 0, max: 0} if entries.empty?
 
-            sizes = entries.map {|e| e[:size] }
+            sizes = entries.map(&:size)
             {total: sizes.sum, avg: sizes.sum / sizes.size, min: sizes.min, max: sizes.max}
           end
 
           # Build age statistics
           #
-          # @param entries [Array<Hash>] entry info array
+          # @param entries [Array<Cache::Entry>] entry array
           # @return [Hash] age statistics
           private def build_age_stats(entries)
             return {oldest: nil, newest: nil, avg: nil} if entries.empty?
 
-            ages = entries.map {|e| e[:age] }
+            ages = entries.map(&:age)
             {oldest: ages.max, newest: ages.min, avg: ages.sum / ages.size}
           end
 
-          # Count stale lock files
-          #
-          # @param cache_dir [Pathname] cache directory path
-          # @return [Integer] number of stale lock files
-          private def count_stale_locks(cache_dir)
-            return 0 unless cache_dir.exist?
-
-            lock_lifetime = Factorix::Cache::FileSystem::LOCK_FILE_LIFETIME
-            cache_dir.glob("**/*.lock").count {|path| @now - path.mtime > lock_lifetime }
-          end
-
           # Output statistics in text format (ccache-style)
           #
           # @param stats [Hash] statistics for all caches
@@ -153,10 +131,7 @@ module Factorix
           # @param data [Hash] cache statistics
           # @return [void]
           private def output_cache_stats(data)
-            out.puts "  Directory:      #{data[:directory]}"
             out.puts "  TTL:            #{format_ttl(data[:ttl])}"
-            out.puts "  Max file size:  #{format_size(data[:max_file_size])}"
-            out.puts "  Compression:    #{format_compression(data[:compression_threshold])}"
 
             entries = data[:entries]
             valid_pct = entries[:total] > 0 ? (Float(entries[:valid]) / entries[:total] * 100) : 0.0
@@ -172,7 +147,43 @@ module Factorix
               out.puts "  Age:            -"
             end
 
-            out.puts "  Stale locks:    #{data[:stale_locks]}"
+            output_backend_info(data[:backend_info])
+          end
+
+          INFLECTOR = Dry::Inflector.new do |inflections|
+            inflections.acronym("URL")
+          end
+          private_constant :INFLECTOR
+
+          # Output backend-specific information
+          #
+          # @param info [Hash] backend-specific information
+          # @return [void]
+          private def output_backend_info(info)
+            return if info.empty?
+
+            out.puts "  Backend:"
+            info.each do |key, value|
+              label = INFLECTOR.humanize(key)
+              formatted_value = format_backend_value(key, value)
+              out.puts "    %-20s %s" % [label + ":", formatted_value]
+            end
+          end
+
+          # Format a backend info value for display
+          #
+          # @param key [Symbol] the key name
+          # @param value [Object] the value to format
+          # @return [String] formatted value
+          private def format_backend_value(key, value)
+            case key
+            when :max_file_size, :compression_threshold
+              value.nil? ? "unlimited" : format_size(value)
+            when :lock_timeout
+              format_duration(value)
+            else
+              value.to_s
+            end
           end
 
           # Format TTL value for display
@@ -182,18 +193,6 @@ module Factorix
           private def format_ttl(ttl)
             ttl.nil? ? "unlimited" : format_duration(ttl)
           end
-
-          # Format compression threshold for display
-          #
-          # @param threshold [Integer, nil] compression threshold in bytes
-          # @return [String] formatted compression setting
-          private def format_compression(threshold)
-            case threshold
-            when nil then "disabled"
-            when 0 then "enabled (always)"
-            else "enabled (>= #{format_size(threshold)})"
-            end
-          end
         end
       end
     end

data/lib/factorix/cli/commands/download_support.rb

@@ -97,18 +97,13 @@ module Factorix
 
           futures = targets.map {|target|
             Concurrent::Future.execute(executor: pool) do
-              thread_portal = Container[:portal]
-              thread_downloader = thread_portal.mod_download_api.downloader
-
               presenter = multi_presenter.register(
                 target[:mod].name,
                 title: target[:release].file_name
               )
               handler = Progress::DownloadHandler.new(presenter)
 
-              thread_downloader.subscribe(handler)
-              thread_portal.download_mod(target[:release], target[:output_path])
-              thread_downloader.unsubscribe(handler)
+              portal.download_mod(target[:release], target[:output_path], handler:)
             end
           }
 

data/lib/factorix/cli/commands/mod/download.rb

@@ -10,14 +10,13 @@ module Factorix
         # Download MOD files from Factorio MOD Portal
         class Download < Base
           include DownloadSupport
+          include PortalSupport
           # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
           #   # @return [Dry::Logger::Dispatcher]
           #   attr_reader :logger
           #   # @return [Runtime]
           #   attr_reader :runtime
-          include Import[:portal, :logger, :runtime]
+          include Import[:logger, :runtime]
 
           desc "Download MOD files from Factorio MOD Portal"
 

data/lib/factorix/cli/commands/mod/edit.rb

@@ -6,10 +6,7 @@ module Factorix
       module MOD
         # Edit MOD metadata on Factorio MOD Portal
         class Edit < Base
-          # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
-          include Import[:portal]
+          include PortalSupport
 
           desc "Edit MOD metadata on Factorio MOD Portal"
 

data/lib/factorix/cli/commands/mod/image/add.rb

@@ -7,10 +7,7 @@ module Factorix
         module Image
           # Add an image to a MOD on Factorio MOD Portal
           class Add < Base
-            # @!parse
-            #   # @return [Portal]
-            #   attr_reader :portal
-            include Import[:portal]
+            include PortalSupport
 
             desc "Add an image to a MOD"
 

data/lib/factorix/cli/commands/mod/image/edit.rb

@@ -7,10 +7,7 @@ module Factorix
         module Image
           # Edit MOD's image list on Factorio MOD Portal
           class Edit < Base
-            # @!parse
-            #   # @return [Portal]
-            #   attr_reader :portal
-            include Import[:portal]
+            include PortalSupport
 
             desc "Edit MOD's image list (reorder/remove images)"
 

data/lib/factorix/cli/commands/mod/image/list.rb

@@ -7,10 +7,7 @@ module Factorix
         module Image
           # List images for a MOD on Factorio MOD Portal
           class List < Base
-            # @!parse
-            #   # @return [Portal]
-            #   attr_reader :portal
-            include Import[:portal]
+            include PortalSupport
 
             desc "List images for a MOD"
 

data/lib/factorix/cli/commands/mod/install.rb

@@ -14,15 +14,14 @@ module Factorix
           backup_support!
 
           include DownloadSupport
+          include PortalSupport
 
           # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
           #   # @return [Dry::Logger::Dispatcher]
           #   attr_reader :logger
           #   # @return [Factorix::Runtime]
           #   attr_reader :runtime
-          include Import[:portal, :logger, :runtime]
+          include Import[:logger, :runtime]
 
           desc "Install MOD(s) from Factorio MOD Portal (downloads to MOD directory and enables)"
 

data/lib/factorix/cli/commands/mod/search.rb

@@ -8,12 +8,11 @@ module Factorix
       module MOD
         # Search MODs on Factorio MOD Portal
         class Search < Base
+          include PortalSupport
           # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
           #   # @return [Runtime]
           #   attr_reader :runtime
-          include Import[:portal, :runtime]
+          include Import[:runtime]
 
           desc "Search MOD(s) on Factorio MOD Portal"
 

data/lib/factorix/cli/commands/mod/show.rb

@@ -20,11 +20,10 @@ module Factorix
           INCOMPATIBLE_MOD_STYLE = TIntMe[:red]
           private_constant :INCOMPATIBLE_MOD_STYLE
           # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
           #   # @return [Runtime]
           #   attr_reader :runtime
-          include Import[:portal, :runtime]
+          include Import[:runtime]
+          include PortalSupport
 
           desc "Show MOD details from Factorio MOD Portal"
 

data/lib/factorix/cli/commands/mod/sync.rb

@@ -14,15 +14,14 @@ module Factorix
           backup_support!
 
           include DownloadSupport
+          include PortalSupport
 
           # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
           #   # @return [Dry::Logger::Dispatcher]
           #   attr_reader :logger
           #   # @return [Factorix::Runtime]
           #   attr_reader :runtime
-          include Import[:portal, :logger, :runtime]
+          include Import[:logger, :runtime]
 
           desc "Sync MOD states and startup settings from a save file"
 

data/lib/factorix/cli/commands/mod/update.rb

@@ -13,14 +13,14 @@ module Factorix
           require_game_stopped!
           backup_support!
 
+          include PortalSupport
+          include DownloadSupport
           # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
           #   # @return [Dry::Logger::Dispatcher]
           #   attr_reader :logger
           #   # @return [Factorix::Runtime]
           #   attr_reader :runtime
-          include Import[:portal, :logger, :runtime]
+          include Import[:logger, :runtime]
 
           desc "Update MOD(s) to their latest versions"
 
@@ -141,7 +141,7 @@ module Factorix
               mod:,
               mod_info:,
               current_version:,
-              latest_release:,
+              release: latest_release,
               output_path: runtime.mod_dir / latest_release.file_name
             }
           rescue MODNotOnPortalError
@@ -156,7 +156,7 @@ module Factorix
           private def show_plan(targets)
             say "Planning to update #{targets.size} MOD(s):", prefix: :info
             targets.each do |target|
-              say "  - #{target[:mod]}: #{target[:current_version]} -> #{target[:latest_release].version}"
+              say "  - #{target[:mod]}: #{target[:current_version]} -> #{target[:release].version}"
             end
           end
 
@@ -176,46 +176,13 @@ module Factorix
                 current_enabled = mod_list.enabled?(mod)
                 mod_list.remove(mod)
                 mod_list.add(mod, enabled: current_enabled)
-                say "Updated #{mod} to #{target[:latest_release].version}", prefix: :success
+                say "Updated #{mod} to #{target[:release].version}", prefix: :success
               else
                 mod_list.add(mod, enabled: true)
                 say "Added #{mod} to mod-list.json", prefix: :success
               end
             end
           end
-
-          # Download MODs in parallel
-          #
-          # @param targets [Array<Hash>] Update targets
-          # @param jobs [Integer] Number of parallel jobs
-          # @return [void]
-          private def download_mods(targets, jobs)
-            multi_presenter = Progress::MultiPresenter.new(title: "\u{1F4E5}\u{FE0E} Downloads", output: err)
-
-            pool = Concurrent::FixedThreadPool.new(jobs)
-
-            futures = targets.map {|target|
-              Concurrent::Future.execute(executor: pool) do
-                thread_portal = Container[:portal]
-                thread_downloader = thread_portal.mod_download_api.downloader
-
-                presenter = multi_presenter.register(
-                  target[:mod].name,
-                  title: target[:latest_release].file_name
-                )
-                handler = Progress::DownloadHandler.new(presenter)
-
-                thread_downloader.subscribe(handler)
-                thread_portal.download_mod(target[:latest_release], target[:output_path])
-                thread_downloader.unsubscribe(handler)
-              end
-            }
-
-            futures.each(&:wait!)
-          ensure
-            pool&.shutdown
-            pool&.wait_for_termination
-          end
         end
       end
     end

data/lib/factorix/cli/commands/mod/upload.rb

@@ -6,10 +6,7 @@ module Factorix
       module MOD
         # Upload MOD to Factorio MOD Portal (handles both new and update)
         class Upload < Base
-          # @!parse
-          #   # @return [Portal]
-          #   attr_reader :portal
-          include Import[:portal]
+          include PortalSupport
 
           desc "Upload MOD to Factorio MOD Portal (handles both new and update)"
 

data/lib/factorix/cli/commands/portal_support.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      # Provides lazy Portal resolution for CLI commands
+      #
+      # This module defers Portal dependency resolution until first use,
+      # allowing configuration to be loaded before cache backends are resolved.
+      #
+      # @example
+      #   class Show < Base
+      #     include PortalSupport
+      #
+      #     def call(mod_name:, **)
+      #       mod_info = portal.get_mod(mod_name)
+      #     end
+      #   end
+      module PortalSupport
+        # Lazily resolve Portal from Container
+        #
+        # @return [Portal] the portal instance
+        private def portal = @portal ||= Container[:portal]
+      end
+    end
+  end
+end

data/lib/factorix/container.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "dry/core"
+require "dry/inflector"
 require "dry/logger"
 
 module Factorix
@@ -13,12 +14,28 @@ module Factorix
   class Container
     extend Dry::Core::Container::Mixin
 
-    # Some items are registered with memoize: false to support independent event handlers
+    INFLECTOR = Dry::Inflector.new do |inflections|
+      inflections.uncountable("redis")
+    end
+    private_constant :INFLECTOR
+
+    # Build a cache instance from configuration.
+    #
+    # @param cache_type [Symbol] cache type (:download, :api, :info_json)
+    # @param config [Dry::Configurable::Config] cache configuration
+    # @return [Cache::Base] cache instance
+    def self.build_cache(cache_type, config)
+      backend = config.backend
+      backend_config = config.public_send(backend).to_h
+      backend_class = Cache.const_get(INFLECTOR.classify(backend.to_s))
+      backend_class.new(cache_type:, ttl: config.ttl, **backend_config)
+    end
+    private_class_method :build_cache
+
+    # :downloader is registered with memoize: false to support independent event handlers
     # for each parallel download task (e.g., progress tracking).
-    # Items registered with memoize: false:
-    # - :downloader (event handlers for progress tracking)
-    # - :mod_download_api (contains :downloader)
-    # - :portal (contains :mod_download_api)
+    # MODDownloadAPI resolves :downloader lazily per download call, allowing
+    # :mod_download_api and :portal to be safely memoized.
 
     # Register runtime detector
     register(:runtime, memoize: true) do
@@ -48,20 +65,17 @@ module Factorix
 
     # Register download cache
     register(:download_cache, memoize: true) do
-      c = Factorix.config.cache.download
-      Cache::FileSystem.new(c.dir, **c.to_h.except(:dir))
+      build_cache(:download, Factorix.config.cache.download)
     end
 
     # Register API cache (with compression for JSON responses)
     register(:api_cache, memoize: true) do
-      c = Factorix.config.cache.api
-      Cache::FileSystem.new(c.dir, **c.to_h.except(:dir))
+      build_cache(:api, Factorix.config.cache.api)
     end
 
     # Register info.json cache (for MOD metadata from ZIP files)
     register(:info_json_cache, memoize: true) do
-      c = Factorix.config.cache.info_json
-      Cache::FileSystem.new(c.dir, **c.to_h.except(:dir))
+      build_cache(:info_json, Factorix.config.cache.info_json)
     end
 
     # Register base HTTP client
@@ -118,7 +132,7 @@ module Factorix
     end
 
     # Register MOD Download API client
-    register(:mod_download_api, memoize: false) do
+    register(:mod_download_api, memoize: true) do
       API::MODDownloadAPI.new
     end
 
@@ -134,7 +148,7 @@ module Factorix
     end
 
     # Register portal (high-level API wrapper)
-    register(:portal, memoize: false) do
+    register(:portal, memoize: true) do
       Portal.new
     end
   end

data/lib/factorix/errors.rb

@@ -48,6 +48,9 @@ module Factorix
   class HTTPNotFoundError < HTTPClientError; end
   class HTTPServerError < HTTPError; end
 
+  # Cache lock timeout errors
+  class LockTimeoutError < InfrastructureError; end
+
   # Digest verification errors
   class DigestMismatchError < InfrastructureError; end