evilution 0.27.0 → 0.29.0

data/lib/evilution/reporter/suggestion/templates.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../suggestion"
+
+module Evilution::Reporter::Suggestion::Templates
+end

data/lib/evilution/result/error_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+class Evilution::Result::ErrorInfo
+  attr_reader :message, :klass, :backtrace
+
+  def self.from_fields(message: nil, klass: nil, backtrace: nil)
+    return nil if message.nil? && klass.nil? && backtrace.nil?
+
+    new(message: message, klass: klass, backtrace: backtrace)
+  end
+
+  def initialize(message: nil, klass: nil, backtrace: nil)
+    @message = message
+    @klass = klass
+    @backtrace = backtrace.nil? ? nil : backtrace.dup.freeze
+    freeze
+  end
+end

data/lib/evilution/result/memory_stats.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+class Evilution::Result::MemoryStats
+  attr_reader :child_rss_kb, :memory_delta_kb, :parent_rss_kb
+
+  def self.from_fields(child_rss_kb: nil, memory_delta_kb: nil, parent_rss_kb: nil)
+    return nil if child_rss_kb.nil? && memory_delta_kb.nil? && parent_rss_kb.nil?
+
+    new(child_rss_kb: child_rss_kb, memory_delta_kb: memory_delta_kb, parent_rss_kb: parent_rss_kb)
+  end
+
+  def initialize(child_rss_kb: nil, memory_delta_kb: nil, parent_rss_kb: nil)
+    @child_rss_kb = child_rss_kb
+    @memory_delta_kb = memory_delta_kb
+    @parent_rss_kb = parent_rss_kb
+    freeze
+  end
+end

data/lib/evilution/result/mutation_result.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "../result"
+require_relative "error_info"
+require_relative "memory_stats"
 
 class Evilution::Result::MutationResult
   STATUSES = %i[killed survived timeout error neutral equivalent unresolved unparseable].freeze
 
-  attr_reader :mutation, :status, :duration, :killing_test, :test_command,
-              :child_rss_kb, :memory_delta_kb, :parent_rss_kb,
-              :error_message, :error_class, :error_backtrace
+  attr_reader :mutation, :status, :duration, :killing_test, :test_command, :memory, :error
 
-  # rubocop:disable Metrics/ParameterLists
   def initialize(mutation:, status:, duration: 0.0, killing_test: nil,
-                 test_command: nil, child_rss_kb: nil, memory_delta_kb: nil,
-                 parent_rss_kb: nil, error_message: nil, error_class: nil,
-                 error_backtrace: nil)
-    # rubocop:enable Metrics/ParameterLists
+                 test_command: nil, memory: nil, error: nil)
     raise ArgumentError, "invalid status: #{status}" unless STATUSES.include?(status)
 
     @mutation = mutation
@@ -22,15 +18,35 @@ class Evilution::Result::MutationResult
     @duration = duration
     @killing_test = killing_test
     @test_command = test_command
-    @child_rss_kb = child_rss_kb
-    @memory_delta_kb = memory_delta_kb
-    @parent_rss_kb = parent_rss_kb
-    @error_message = error_message
-    @error_class = error_class
-    @error_backtrace = error_backtrace.nil? ? nil : error_backtrace.dup.freeze
+    @memory = memory
+    @error = error
     freeze
   end
 
+  def child_rss_kb
+    @memory.nil? ? nil : @memory.child_rss_kb
+  end
+
+  def memory_delta_kb
+    @memory.nil? ? nil : @memory.memory_delta_kb
+  end
+
+  def parent_rss_kb
+    @memory.nil? ? nil : @memory.parent_rss_kb
+  end
+
+  def error_message
+    @error.nil? ? nil : @error.message
+  end
+
+  def error_class
+    @error.nil? ? nil : @error.klass
+  end
+
+  def error_backtrace
+    @error.nil? ? nil : @error.backtrace
+  end
+
   def killed?
     status == :killed
   end

data/lib/evilution/runner/baseline_runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../baseline"
 require_relative "../spec_resolver"
 require_relative "../integration/rspec"
@@ -8,8 +9,6 @@ require_relative "../example_filter"
 require_relative "../spec_ast_cache"
 require_relative "../source_ast_cache"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 unless defined?(Evilution::Runner::INTEGRATIONS)
   Evilution::Runner::INTEGRATIONS = {
     rspec: Evilution::Integration::RSpec,
@@ -31,18 +30,25 @@ class Evilution::Runner::BaselineRunner
 
   def build_integration
     klass = integration_class
-    test_files = config.spec_files.empty? ? nil : config.spec_files
-    kwargs = {
-      test_files: test_files,
+    kwargs = base_integration_kwargs
+    kwargs.merge!(rspec_integration_kwargs) if klass == Evilution::Integration::RSpec
+    klass.new(**kwargs)
+  end
+
+  def base_integration_kwargs
+    {
+      test_files: config.spec_files.empty? ? nil : config.spec_files,
       hooks: hooks,
       fallback_to_full_suite: config.fallback_to_full_suite?,
       spec_selector: config.spec_selector
     }
-    if klass == Evilution::Integration::RSpec
-      kwargs[:related_specs_heuristic] = config.related_specs_heuristic?
-      kwargs[:example_filter] = build_example_filter
-    end
-    klass.new(**kwargs)
+  end
+
+  def rspec_integration_kwargs
+    {
+      related_specs_heuristic: config.related_specs_heuristic?,
+      example_filter: build_example_filter
+    }
   end
 
   def call(subjects)

data/lib/evilution/runner/diagnostics.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../memory"
 require_relative "../parallel/pool"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::Diagnostics
   def initialize(config, stderr: $stderr)
     @config = config
@@ -33,19 +32,23 @@ class Evilution::Runner::Diagnostics
   def log_mutation_diagnostics(result)
     return unless verbose?
 
-    parts = []
-    parts << format("child_rss: %<mb>.1f MB", mb: result.child_rss_kb / 1024.0) if result.child_rss_kb
+    parts = mutation_metric_parts(result)
+    stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n") unless parts.empty?
 
-    if result.memory_delta_kb
-      sign = result.memory_delta_kb.negative? ? "" : "+"
-      parts << format("delta: %<sign>s%<mb>.1f MB", sign: sign, mb: result.memory_delta_kb / 1024.0)
-    end
+    log_mutation_error(result) if result.error?
+  end
 
+  def mutation_metric_parts(result)
+    parts = []
+    parts << format("child_rss: %<mb>.1f MB", mb: result.child_rss_kb / 1024.0) if result.child_rss_kb
+    parts << format_memory_delta(result.memory_delta_kb) if result.memory_delta_kb
     parts << gc_stats_string
+    parts
+  end
 
-    stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n") unless parts.empty?
-
-    log_mutation_error(result) if result.error?
+  def format_memory_delta(delta_kb)
+    sign = delta_kb.negative? ? "" : "+"
+    format("delta: %<sign>s%<mb>.1f MB", sign: sign, mb: delta_kb / 1024.0)
   end
 
   def log_worker_stats(stats)

data/lib/evilution/runner/isolation_resolver.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../isolation/fork"
 require_relative "../isolation/in_process"
 require_relative "../rails_detector"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::IsolationResolver
   PRELOAD_CANDIDATES = [
     File.join("spec", "rails_helper.rb"),
@@ -109,16 +108,18 @@ class Evilution::Runner::IsolationResolver
   end
 
   def resolve_preload_path
-    if config.preload.is_a?(String)
-      unless File.file?(config.preload)
-        raise Evilution::ConfigError.new(
-          "preload file not found: #{config.preload.inspect}",
-          file: config.preload
-        )
-      end
-      return config.preload
-    end
+    return resolve_explicit_preload(config.preload) if config.preload.is_a?(String)
+
+    resolve_autodetected_preload
+  end
+
+  def resolve_explicit_preload(path)
+    return path if File.file?(path)
+
+    raise Evilution::ConfigError.new("preload file not found: #{path.inspect}", file: path)
+  end
 
+  def resolve_autodetected_preload
     root = detected_rails_root
     return nil unless root
 

data/lib/evilution/runner/mutation_executor/mutation_runner.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../mutation_executor"
 require_relative "../../result/mutation_result"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::MutationExecutor::MutationRunner
   def initialize(config:, cache:, isolator:)
     @config = config

data/lib/evilution/runner/mutation_executor/neutralization_pipeline.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+require_relative "../mutation_executor"
 
 class Evilution::Runner::MutationExecutor::NeutralizationPipeline
   def initialize(neutralizers)

data/lib/evilution/runner/mutation_executor/neutralizer/baseline_failed.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../neutralizer"
 require_relative "../../../result/mutation_result"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-module Evilution::Runner::MutationExecutor::Neutralizer; end unless defined?(Evilution::Runner::MutationExecutor::Neutralizer)
-
 class Evilution::Runner::MutationExecutor::Neutralizer::BaselineFailed
   def initialize(config:, spec_resolver:, fallback_dir:)
     @config = config
@@ -35,12 +32,8 @@ class Evilution::Runner::MutationExecutor::Neutralizer::BaselineFailed
       status: :neutral,
       duration: result.duration,
       test_command: result.test_command,
-      child_rss_kb: result.child_rss_kb,
-      memory_delta_kb: result.memory_delta_kb,
-      parent_rss_kb: result.parent_rss_kb,
-      error_message: result.error_message,
-      error_class: result.error_class,
-      error_backtrace: result.error_backtrace
+      memory: result.memory,
+      error: result.error
     )
   end
 end

data/lib/evilution/runner/mutation_executor/neutralizer/infra_error.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../neutralizer"
 require_relative "../../../result/mutation_result"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-module Evilution::Runner::MutationExecutor::Neutralizer; end unless defined?(Evilution::Runner::MutationExecutor::Neutralizer)
-
 # Reclassify results as :neutral when the failure was caused by test
 # infrastructure rather than by the mutation. Two independent paths:
 #
@@ -64,12 +61,8 @@ class Evilution::Runner::MutationExecutor::Neutralizer::InfraError
       status: :neutral,
       duration: result.duration,
       test_command: result.test_command,
-      child_rss_kb: result.child_rss_kb,
-      memory_delta_kb: result.memory_delta_kb,
-      parent_rss_kb: result.parent_rss_kb,
-      error_message: result.error_message,
-      error_class: result.error_class,
-      error_backtrace: result.error_backtrace
+      memory: result.memory,
+      error: result.error
     )
   end
 end

data/lib/evilution/runner/mutation_executor/neutralizer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+
+# Namespace for MutationExecutor's neutralization rules (InfraError,
+# BaselineFailed). Concrete neutralizer classes live in neutralizer/*.rb and
+# are autoloaded on first reference.
+module Evilution::Runner::MutationExecutor::Neutralizer
+  autoload :InfraError, File.expand_path("neutralizer/infra_error", __dir__)
+  autoload :BaselineFailed, File.expand_path("neutralizer/baseline_failed", __dir__)
+end

data/lib/evilution/runner/mutation_executor/result_cache.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "../mutation_executor"
 require_relative "../../result/mutation_result"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::MutationExecutor::ResultCache
   CACHEABLE_STATUSES = %i[killed timeout].freeze
   private_constant :CACHEABLE_STATUSES
 
+  Partition = Data.define(:uncached_indices, :cached_results)
+
   def initialize(backend)
     @backend = backend
   end
@@ -58,7 +58,7 @@ class Evilution::Runner::MutationExecutor::ResultCache
       end
     end
 
-    [uncached_indices, cached_results]
+    Partition.new(uncached_indices: uncached_indices, cached_results: cached_results)
   end
 
   private

data/lib/evilution/runner/mutation_executor/result_notifier.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../mutation_executor"
 require_relative "../../reporter/progress_bar"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::MutationExecutor::ResultNotifier
   def initialize(config, diagnostics:, on_result:)
     @config = config

data/lib/evilution/runner/mutation_executor/result_packer.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../mutation_executor"
 require_relative "../../result/mutation_result"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::MutationExecutor::ResultPacker
   def compact(result)
     {
@@ -28,12 +26,16 @@ class Evilution::Runner::MutationExecutor::ResultPacker
       duration: data[:duration],
       killing_test: data[:killing_test],
       test_command: data[:test_command],
-      child_rss_kb: data[:child_rss_kb],
-      memory_delta_kb: data[:memory_delta_kb],
-      parent_rss_kb: data[:parent_rss_kb],
-      error_message: data[:error_message],
-      error_class: data[:error_class],
-      error_backtrace: data[:error_backtrace]
+      memory: Evilution::Result::MemoryStats.from_fields(
+        child_rss_kb: data[:child_rss_kb],
+        memory_delta_kb: data[:memory_delta_kb],
+        parent_rss_kb: data[:parent_rss_kb]
+      ),
+      error: Evilution::Result::ErrorInfo.from_fields(
+        message: data[:error_message],
+        klass: data[:error_class],
+        backtrace: data[:error_backtrace]
+      )
     )
   end
 end

data/lib/evilution/runner/mutation_executor/strategy/parallel.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-module Evilution::Runner::MutationExecutor::Strategy; end unless defined?(Evilution::Runner::MutationExecutor::Strategy)
+require_relative "../strategy"
 
 class Evilution::Runner::MutationExecutor::Strategy::Parallel
   def initialize(cache:, isolator:, packer:, pipeline:, notifier:, pool_factory:, config:, diagnostics: nil)
@@ -20,8 +18,17 @@ class Evilution::Runner::MutationExecutor::Strategy::Parallel
     @notifier.start(mutations.length)
     pool = @pool_factory.call
     state = { results: [], truncated: false, completed: 0 }
-    all_worker_stats = []
+    all_worker_stats = run_batches(mutations, pool, baseline_result, integration, state)
 
+    log_worker_diagnostics(all_worker_stats)
+    @notifier.finish
+    build_result(state)
+  end
+
+  private
+
+  def run_batches(mutations, pool, baseline_result, integration, state)
+    all_worker_stats = []
     mutations.each_slice(@config.jobs) do |batch|
       break if state[:truncated]
 
@@ -29,24 +36,37 @@ class Evilution::Runner::MutationExecutor::Strategy::Parallel
       all_worker_stats.concat(pool.worker_stats)
       process_batch(batch_results, baseline_result, state)
     end
+    all_worker_stats
+  end
 
-    @diagnostics.log_worker_stats(@diagnostics.aggregate_worker_stats(all_worker_stats)) if @diagnostics
-    @notifier.finish
-    [state[:results], state[:truncated]]
+  def log_worker_diagnostics(all_worker_stats)
+    return unless @diagnostics
+
+    @diagnostics.log_worker_stats(@diagnostics.aggregate_worker_stats(all_worker_stats))
   end
 
-  private
+  def build_result(state)
+    Evilution::Runner::MutationExecutor::ExecutionResult.new(results: state[:results], truncated: state[:truncated])
+  end
 
   def run_batch(batch, pool, integration)
-    uncached_indices, cached_results = @cache.partition(batch, packer: @packer)
-    worker_results = run_uncached(batch, uncached_indices, pool, integration)
-    compact_results = merge(batch, uncached_indices, cached_results, worker_results)
-    batch_results = batch.zip(compact_results).map { |m, h| @packer.rebuild(m, h) }
-    uncached_indices.each { |i| @cache.store(batch_results[i].mutation, batch_results[i]) }
+    partition = @cache.partition(batch, packer: @packer)
+    worker_results = run_uncached(batch, partition.uncached_indices, pool, integration)
+    compact_results = merge(batch, partition.uncached_indices, partition.cached_results, worker_results)
+    batch_results = rebuild_results(batch, compact_results)
+    cache_results(batch_results, partition.uncached_indices)
     batch.each(&:strip_sources!)
     batch_results
   end
 
+  def rebuild_results(batch, compact_results)
+    batch.zip(compact_results).map { |m, h| @packer.rebuild(m, h) }
+  end
+
+  def cache_results(batch_results, uncached_indices)
+    uncached_indices.each { |i| @cache.store(batch_results[i].mutation, batch_results[i]) }
+  end
+
   def run_uncached(batch, uncached_indices, pool, integration)
     return [] if uncached_indices.empty?
 

data/lib/evilution/runner/mutation_executor/strategy/sequential.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
-module Evilution::Runner::MutationExecutor::Strategy; end unless defined?(Evilution::Runner::MutationExecutor::Strategy)
+require_relative "../strategy"
 
 class Evilution::Runner::MutationExecutor::Strategy::Sequential
   def initialize(runner:, pipeline:, notifier:)
@@ -29,6 +27,6 @@ class Evilution::Runner::MutationExecutor::Strategy::Sequential
     end
 
     @notifier.finish
-    [results, truncated]
+    Evilution::Runner::MutationExecutor::ExecutionResult.new(results: results, truncated: truncated)
   end
 end

data/lib/evilution/runner/mutation_executor/strategy.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+
+# Namespace for MutationExecutor's execution strategies (Sequential, Parallel).
+# Concrete strategy classes live in strategy/{sequential,parallel}.rb and are
+# autoloaded on first reference.
+module Evilution::Runner::MutationExecutor::Strategy
+  autoload :Sequential, File.expand_path("strategy/sequential", __dir__)
+  autoload :Parallel, File.expand_path("strategy/parallel", __dir__)
+end

data/lib/evilution/runner/mutation_executor.rb

@@ -1,23 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "../parallel/pool"
-require_relative "mutation_executor/result_cache"
-require_relative "mutation_executor/result_packer"
-require_relative "mutation_executor/result_notifier"
-require_relative "mutation_executor/mutation_runner"
-require_relative "mutation_executor/neutralization_pipeline"
-require_relative "mutation_executor/neutralizer/infra_error"
-require_relative "mutation_executor/neutralizer/baseline_failed"
-require_relative "mutation_executor/strategy/sequential"
-require_relative "mutation_executor/strategy/parallel"
-
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+require_relative "../runner"
 
 class Evilution::Runner::MutationExecutor
-  InfraError = Neutralizer::InfraError
-  BaselineFailed = Neutralizer::BaselineFailed
-  Sequential = Strategy::Sequential
-  Parallel = Strategy::Parallel
+  ExecutionResult = Data.define(:results, :truncated)
+
+  autoload :ResultCache, File.expand_path("mutation_executor/result_cache", __dir__)
+  autoload :ResultPacker, File.expand_path("mutation_executor/result_packer", __dir__)
+  autoload :ResultNotifier, File.expand_path("mutation_executor/result_notifier", __dir__)
+  autoload :MutationRunner, File.expand_path("mutation_executor/mutation_runner", __dir__)
+  autoload :NeutralizationPipeline, File.expand_path("mutation_executor/neutralization_pipeline", __dir__)
+  autoload :Strategy, File.expand_path("mutation_executor/strategy", __dir__)
+  autoload :Neutralizer, File.expand_path("mutation_executor/neutralizer", __dir__)
 
   def initialize(config, isolator:, baseline_runner:, cache:, hooks:, diagnostics:, on_result: nil)
     @config = config
@@ -53,8 +47,8 @@ class Evilution::Runner::MutationExecutor
   def build_pipeline(spec_resolver)
     NeutralizationPipeline.new(
       [
-        InfraError.new,
-        BaselineFailed.new(
+        Neutralizer::InfraError.new,
+        Neutralizer::BaselineFailed.new(
           config: @config,
           spec_resolver: spec_resolver || ->(_f) {},
           fallback_dir: @baseline_runner.neutralization_fallback_dir
@@ -64,7 +58,7 @@ class Evilution::Runner::MutationExecutor
   end
 
   def build_sequential(notifier, pipeline)
-    Sequential.new(
+    Strategy::Sequential.new(
       runner: MutationRunner.new(config: @config, cache: @cache, isolator: @isolator),
       pipeline: pipeline,
       notifier: notifier
@@ -72,7 +66,7 @@ class Evilution::Runner::MutationExecutor
   end
 
   def build_parallel(notifier, pipeline)
-    Parallel.new(
+    Strategy::Parallel.new(
       cache: @cache,
       isolator: @isolator,
       packer: @packer,