factorix 0.5.1 → 0.7.0

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"
 
@@ -29,11 +28,11 @@ module Factorix
           argument :mod_names, type: :array, required: false, default: [], desc: "MOD names to search"
 
           option :hide_deprecated, type: :boolean, default: true, desc: "Hide deprecated MOD(s)"
-          option :page, type: :integer, default: 1, desc: "Page number"
-          option :page_size, type: :integer, default: 25, desc: "Results per page (max 500)"
-          option :sort, type: :string, values: %w[name created_at updated_at], desc: "Sort field"
-          option :sort_order, type: :string, values: %w[asc desc], desc: "Sort order"
-          option :version, type: :string, desc: "Filter by Factorio version (default: installed version)"
+          option :page, default: "1", desc: "Page number"
+          option :page_size, default: "25", desc: "Results per page (max 500)"
+          option :sort, values: %w[name created_at updated_at], desc: "Sort field"
+          option :sort_order, values: %w[asc desc], desc: "Sort order"
+          option :version, desc: "Filter by Factorio version (default: installed version)"
           option :json, type: :flag, default: false, desc: "Output in JSON format"
 
           # Execute the search command
@@ -47,7 +46,9 @@ module Factorix
           # @param version [String, nil] Factorio version filter
           # @param json [Boolean] Output in JSON format
           # @return [void]
-          def call(mod_names: [], hide_deprecated: true, page: 1, page_size: 25, sort: nil, sort_order: nil, version: nil, json: false, **)
+          def call(mod_names: [], hide_deprecated: true, page: "1", page_size: "25", sort: nil, sort_order: nil, version: nil, json: false, **)
+            page = Integer(page)
+            page_size = Integer(page_size)
             version ||= default_factorio_version
 
             mods = portal.list_mods(*mod_names, hide_deprecated: hide_deprecated || nil, page:, page_size:, sort:, sort_order:, version:)
@@ -60,7 +61,7 @@ module Factorix
           end
 
           private def output_json(mods)
-            puts JSON.pretty_generate(mods.map {|mod| mod_to_hash(mod) })
+            out.puts JSON.pretty_generate(mods.map {|mod| mod_to_hash(mod) })
           end
 
           private def mod_to_hash(mod)
@@ -99,10 +100,10 @@ module Factorix
             headers = %w[NAME TITLE CATEGORY OWNER LATEST]
             widths = headers.map.with_index {|h, i| [h.length, *rows.map {|r| r[i].to_s.length }].max }
 
-            puts format_table_row(headers, widths)
+            out.puts format_table_row(headers, widths)
 
             rows.each do |row|
-              puts format_table_row(row, widths)
+              out.puts format_table_row(row, widths)
             end
 
             say "#{mods.size} MOD(s) found", prefix: :info

data/lib/factorix/cli/commands/mod/settings/dump.rb

@@ -22,8 +22,8 @@ module Factorix
               "/path/to/mod-settings.dat -o out.json   # Dump specific file"
             ]
 
-            argument :settings_file, type: :string, required: false, desc: "Path to mod-settings.dat file"
-            option :output, type: :string, aliases: ["-o"], desc: "Output file path"
+            argument :settings_file, required: false, desc: "Path to mod-settings.dat file"
+            option :output, aliases: ["-o"], desc: "Output file path"
 
             # Execute the dump command
             #
@@ -43,7 +43,7 @@ module Factorix
               if output
                 Pathname(output).write(output_string)
               else
-                puts output_string
+                out.puts output_string
               end
             end
 

data/lib/factorix/cli/commands/mod/settings/restore.rb

@@ -24,8 +24,8 @@ module Factorix
               "                        # Restore from stdin"
             ]
 
-            argument :settings_file, type: :string, required: false, desc: "Path to mod-settings.dat file to write"
-            option :input, type: :string, aliases: ["-i"], desc: "Input file path"
+            argument :settings_file, required: false, desc: "Path to mod-settings.dat file to write"
+            option :input, aliases: ["-i"], desc: "Input file path"
 
             # Execute the restore command
             #

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"
 
@@ -32,7 +31,7 @@ module Factorix
             "some-mod          # Show details for some-mod"
           ]
 
-          argument :mod_name, type: :string, required: true, desc: "MOD name to show"
+          argument :mod_name, required: true, desc: "MOD name to show"
 
           # Execute the show command
           #
@@ -75,10 +74,10 @@ module Factorix
           end
 
           private def display_header(mod_info)
-            puts TITLE_STYLE[mod_info.title]
-            puts
-            puts mod_info.summary unless mod_info.summary.empty?
-            puts
+            out.puts TITLE_STYLE[mod_info.title]
+            out.puts
+            out.puts mod_info.summary unless mod_info.summary.empty?
+            out.puts
           end
 
           private def display_basic_info(mod_info, local_status)
@@ -103,9 +102,9 @@ module Factorix
 
             max_label_width = rows.map {|label, _| label.length }.max
             rows.each do |label, value|
-              puts "#{label.ljust(max_label_width)}  #{value}"
+              out.puts "#{label.ljust(max_label_width)}  #{value}"
             end
-            puts
+            out.puts
           end
 
           private def format_status(local_status)
@@ -123,18 +122,18 @@ module Factorix
           end
 
           private def display_links(mod_info)
-            puts HEADER_STYLE["Links"]
-            puts "  MOD Portal: https://mods.factorio.com/mod/#{mod_info.name}"
+            out.puts HEADER_STYLE["Links"]
+            out.puts "  MOD Portal: https://mods.factorio.com/mod/#{mod_info.name}"
 
             if mod_info.detail
               if mod_info.detail.source_url
-                puts "  Source: #{mod_info.detail.source_url}"
+                out.puts "  Source: #{mod_info.detail.source_url}"
               end
               if mod_info.detail.homepage
-                puts "  Homepage: #{mod_info.detail.homepage}"
+                out.puts "  Homepage: #{mod_info.detail.homepage}"
               end
             end
-            puts
+            out.puts
           end
 
           private def display_dependencies(mod_info)
@@ -149,16 +148,16 @@ module Factorix
             optional = parsed.select {|d| d[:type] == :optional }
 
             unless required.empty?
-              puts HEADER_STYLE["Dependencies"]
+              out.puts HEADER_STYLE["Dependencies"]
               required.each {|dep| display_dependency(dep) }
-              puts
+              out.puts
             end
 
             return if optional.empty?
 
-            puts HEADER_STYLE["Optional Dependencies"]
+            out.puts HEADER_STYLE["Optional Dependencies"]
             optional.each {|dep| display_dependency(dep) }
-            puts
+            out.puts
           end
 
           private def parse_dependency(dep_str)
@@ -178,7 +177,7 @@ module Factorix
           end
 
           private def display_dependency(dep)
-            puts "  #{dep[:spec]}"
+            out.puts "  #{dep[:spec]}"
           end
 
           private def display_incompatibilities(mod_info)
@@ -191,9 +190,9 @@ module Factorix
 
             return if incompatible.empty?
 
-            puts HEADER_STYLE["Incompatibilities"]
-            incompatible.each {|dep| puts "  #{INCOMPATIBLE_MOD_STYLE[dep[:spec]]}" }
-            puts
+            out.puts HEADER_STYLE["Incompatibilities"]
+            incompatible.each {|dep| out.puts "  #{INCOMPATIBLE_MOD_STYLE[dep[:spec]]}" }
+            out.puts
           end
         end
       end

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"
 
@@ -31,15 +30,16 @@ module Factorix
             "-j 8 save.zip      # Use 8 parallel downloads"
           ]
 
-          argument :save_file, type: :string, required: true, desc: "Path to Factorio save file (.zip)"
-          option :jobs, type: :integer, aliases: ["-j"], default: 4, desc: "Number of parallel downloads"
+          argument :save_file, required: true, desc: "Path to Factorio save file (.zip)"
+          option :jobs, aliases: ["-j"], default: "4", desc: "Number of parallel downloads"
 
           # Execute the sync command
           #
           # @param save_file [String] Path to save file
           # @param jobs [Integer] Number of parallel downloads
           # @return [void]
-          def call(save_file:, jobs: 4, **)
+          def call(save_file:, jobs: "4", **)
+            jobs = Integer(jobs)
             # Load save file
             say "Loading save file: #{save_file}", prefix: :info
             save_data = SaveFile.load(Pathname(save_file))
@@ -47,7 +47,7 @@ module Factorix
 
             # Load current state
             mod_list = MODList.load
-            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: $stderr)
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: err)
             handler = Progress::ScanHandler.new(presenter)
             installed_mods = InstalledMOD.all(handler:)
             graph = Dependency::Graph::Builder.build(installed_mods:, mod_list:)
@@ -109,7 +109,7 @@ module Factorix
           # @return [Array<Hash>] Installation targets with MOD info and releases
           private def plan_installation(mods_to_install, graph, jobs)
             # Create progress presenter for info fetching
-            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Fetching MOD info", output: $stderr)
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Fetching MOD info", output: err)
 
             # Fetch info for MODs to install
             target_infos = fetch_target_mod_info(mods_to_install, jobs, presenter)

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

@@ -45,7 +45,7 @@ module Factorix
 
             # Load current state (without validation to allow fixing issues)
             mod_list = MODList.load
-            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: $stderr)
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: err)
             handler = Progress::ScanHandler.new(presenter)
             installed_mods = InstalledMOD.all(handler:)
             graph = Dependency::Graph::Builder.build(installed_mods:, mod_list:)

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"
 
@@ -32,15 +32,16 @@ module Factorix
           ]
 
           argument :mod_names, type: :array, required: false, desc: "MOD names to update (all if not specified)"
-          option :jobs, type: :integer, aliases: ["-j"], default: 4, desc: "Number of parallel downloads"
+          option :jobs, aliases: ["-j"], default: "4", desc: "Number of parallel downloads"
 
           # Execute the update command
           #
           # @param mod_names [Array<String>] MOD names to update
           # @param jobs [Integer] Number of parallel downloads
           # @return [void]
-          def call(mod_names: [], jobs: 4, **)
-            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: $stderr)
+          def call(mod_names: [], jobs: "4", **)
+            jobs = Integer(jobs)
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: err)
             handler = Progress::ScanHandler.new(presenter)
             installed_mods = InstalledMOD.all(handler:)
             mod_list = MODList.load
@@ -98,7 +99,7 @@ module Factorix
           # @param jobs [Integer] Number of parallel jobs
           # @return [Array<Hash>] Update targets with current and latest versions
           private def find_update_targets(target_mods, installed_mods, jobs)
-            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Checking for updates", output: $stderr)
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Checking for updates", output: err)
             presenter.start(total: target_mods.size)
 
             pool = Concurrent::FixedThreadPool.new(jobs)
@@ -140,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
@@ -155,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
 
@@ -175,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")
-
-            pool = Concurrent::FixedThreadPool.new(jobs)
-
-            futures = targets.map {|target|
-              Concurrent::Future.execute(executor: pool) do
-                thread_portal = Application[: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)"
 
@@ -18,11 +15,11 @@ module Factorix
             "my-mod_1.0.0.zip --category automation     # Upload with category"
           ]
 
-          argument :file, type: :string, required: true, desc: "Path to MOD zip file"
-          option :description, type: :string, desc: "Markdown description"
-          option :category, type: :string, desc: "MOD category"
-          option :license, type: :string, desc: "License identifier"
-          option :source_url, type: :string, desc: "Repository URL"
+          argument :file, required: true, desc: "Path to MOD zip file"
+          option :description, desc: "Markdown description"
+          option :category, desc: "MOD category"
+          option :license, desc: "License identifier"
+          option :source_url, desc: "Repository URL"
 
           # Execute the upload command
           #
@@ -44,7 +41,7 @@ module Factorix
             mod_name = extract_mod_name(file_path)
             metadata = build_metadata(description:, category:, license:, source_url:)
 
-            presenter = Progress::Presenter.new(title: "\u{1F4E4} Uploading #{file_path.basename}", output: $stderr)
+            presenter = Progress::Presenter.new(title: "\u{1F4E4} Uploading #{file_path.basename}", output: err)
 
             uploader = portal.mod_management_api.uploader
             handler = Progress::UploadHandler.new(presenter)

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

@@ -61,7 +61,7 @@ module Factorix
           result = PATH_TYPES.transform_values {|method_name| runtime.public_send(method_name).to_s }
 
           if json
-            puts JSON.pretty_generate(result)
+            out.puts JSON.pretty_generate(result)
           else
             output_table(result)
           end
@@ -70,7 +70,7 @@ module Factorix
         private def output_table(result)
           key_width = result.keys.map(&:length).max
           result.each do |key, value|
-            puts "%-#{key_width}s  %s" % [key, value]
+            out.puts "%-#{key_width}s  %s" % [key, value]
           end
         end
       end

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/cli/commands/version.rb

@@ -18,7 +18,7 @@ module Factorix
         # Outputs the current version of the Factorix gem to stdout.
         #
         # @return [void]
-        def call(**) = puts VERSION
+        def call(**) = out.puts VERSION
       end
     end
   end

data/lib/factorix/container.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "dry/core"
+require "dry/inflector"
+require "dry/logger"
+
+module Factorix
+  # DI container for dependency injection
+  #
+  # Provides dependency injection container using dry-core's Container.
+  #
+  # @example Resolve dependencies
+  #   runtime = Factorix::Container[:runtime]
+  class Container
+    extend Dry::Core::Container::Mixin
+
+    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).
+    # 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
+      Runtime.detect
+    end
+
+    # Register logger
+    register(:logger, memoize: true) do
+      runtime = resolve(:runtime)
+      log_path = runtime.factorix_log_path
+
+      # Ensure log directory exists
+      log_path.dirname.mkpath unless log_path.dirname.exist?
+
+      # Create logger with file backend
+      # Dispatcher level set to DEBUG to allow all messages through
+      # Backend controls filtering based on --log-level option
+      Dry.Logger(:factorix, level: :debug) do |dispatcher|
+        dispatcher.add_backend(level: Factorix.config.log_level, stream: log_path.to_s, template: "[%<time>s] %<severity>s: %<message>s %<payload>s")
+      end
+    end
+
+    # Register retry strategy for network operations
+    register(:retry_strategy, memoize: true) do
+      HTTP::RetryStrategy.new
+    end
+
+    # Register download cache
+    register(:download_cache, memoize: true) do
+      build_cache(:download, Factorix.config.cache.download)
+    end
+
+    # Register API cache (with compression for JSON responses)
+    register(:api_cache, memoize: true) do
+      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
+      build_cache(:info_json, Factorix.config.cache.info_json)
+    end
+
+    # Register base HTTP client
+    register(:http_client, memoize: true) do
+      HTTP::Client.new(masked_params: %w[username token secure])
+    end
+
+    # Register decorated HTTP client for downloads (with retry only)
+    # Note: Caching is handled by Downloader, not at HTTP client level
+    register(:download_http_client, memoize: true) do
+      client = resolve(:http_client)
+      retry_strategy = resolve(:retry_strategy)
+
+      # Decorate: Client -> Retry (no cache, handled by Downloader)
+      HTTP::RetryDecorator.new(client:, retry_strategy:)
+    end
+
+    # Register decorated HTTP client for API calls (with retry + cache)
+    register(:api_http_client, memoize: true) do
+      client = resolve(:http_client)
+      api_cache = resolve(:api_cache)
+      retry_strategy = resolve(:retry_strategy)
+
+      # Decorate: Client -> Cache -> Retry
+      cached = HTTP::CacheDecorator.new(client:, cache: api_cache)
+      HTTP::RetryDecorator.new(client: cached, retry_strategy:)
+    end
+
+    # Register decorated HTTP client for uploads (with retry only, no cache)
+    register(:upload_http_client, memoize: true) do
+      client = resolve(:http_client)
+      retry_strategy = resolve(:retry_strategy)
+
+      # Decorate: Client -> Retry (no cache for uploads)
+      HTTP::RetryDecorator.new(client:, retry_strategy:)
+    end
+
+    # Register downloader
+    register(:downloader, memoize: false) do
+      Transfer::Downloader.new
+    end
+
+    # Register uploader
+    register(:uploader, memoize: true) do
+      Transfer::Uploader.new
+    end
+
+    # Register service credential
+    register(:service_credential, memoize: true) { ServiceCredential.load }
+
+    # Register MOD Portal API client
+    register(:mod_portal_api, memoize: true) do
+      API::MODPortalAPI.new
+    end
+
+    # Register MOD Download API client
+    register(:mod_download_api, memoize: true) do
+      API::MODDownloadAPI.new
+    end
+
+    # Register API credential (for MOD upload/management)
+    register(:api_credential, memoize: true) { APICredential.load }
+
+    # Register MOD Management API client
+    register(:mod_management_api, memoize: true) do
+      api = API::MODManagementAPI.new
+      # Subscribe mod_portal_api to invalidate cache when MOD is changed on portal
+      api.subscribe(resolve(:mod_portal_api))
+      api
+    end
+
+    # Register portal (high-level API wrapper)
+    register(:portal, memoize: true) do
+      Portal.new
+    end
+  end
+end

data/lib/factorix/dependency/parser.rb

@@ -128,7 +128,7 @@ module Factorix
         MODVersionRequirement[operator:, version:]
       rescue VersionParseError => e
         # Skip version requirements with out-of-range version components
-        Application[:logger].warn("Skipping version requirement '#{version_string}': #{e.message}")
+        Container[:logger].warn("Skipping version requirement '#{version_string}': #{e.message}")
         nil
       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