evilution 0.30.4 → 0.32.0

data/lib/evilution/integration/test_unit/framework_loader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Loads the test-unit gem and disables its at_exit auto-run handler.
+# Mirrors Evilution::Integration::RSpec::FrameworkLoader's role: framework
+# setup is one responsibility separated from dispatch + result building so
+# integrations can compose it independently in tests.
+class Evilution::Integration::TestUnit::FrameworkLoader
+  def loaded?
+    @loaded == true
+  end
+
+  def call
+    return if @loaded
+
+    require "test-unit"
+    self.class.stub_autorun!
+    @loaded = true
+  rescue LoadError => e
+    raise Evilution::Error, "test-unit is required but not available: #{e.message}"
+  end
+
+  # User code that `require "test-unit"` installs an at_exit hook that calls
+  # Test::Unit::AutoRunner.run when need_auto_run? is true. At evilution exit
+  # ARGV still holds evilution flags and the runner prints a misleading banner.
+  # Flipping need_auto_run = false prevents the handler from firing.
+  def self.stub_autorun!
+    return unless defined?(::Test::Unit::AutoRunner)
+
+    ::Test::Unit::AutoRunner.need_auto_run = false
+  end
+end

data/lib/evilution/integration/test_unit/result_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Shapes the result Hash that flows back to Evilution::Result::MutationResult
+# / classify_status. Three orthogonal flavours — pass/fail/crash, no tests
+# executed, and unresolved spec — each have their own change axis (e.g. the
+# no-tests-ran error string evolved separately as the test-unit framework
+# diagnostic improved). Putting them behind a single object documents the
+# contract and lets the integration class drop them.
+module Evilution::Integration::TestUnit::ResultBuilder
+  module_function
+
+  def call(passed:, command:, detector:)
+    if passed
+      { passed: true, test_command: command }
+    elsif detector.only_crashes?
+      crash(command, detector)
+    else
+      { passed: false, test_command: command }
+    end
+  end
+
+  def no_tests_ran(command)
+    {
+      passed: false,
+      error: "no Test::Unit tests executed (0 test methods ran) — the resolved " \
+             "spec registered no Test::Unit suite. Check --integration/--spec.",
+      error_class: "Evilution::Error",
+      test_command: command
+    }
+  end
+
+  def unresolved(mutation_file_path)
+    {
+      passed: false,
+      unresolved: true,
+      error: "no matching test resolved for #{mutation_file_path}",
+      test_command: "ruby -Itest (skipped: no test resolved for #{mutation_file_path})"
+    }
+  end
+
+  def crash(command, detector)
+    classes = detector.unique_crash_classes
+    {
+      passed: false,
+      test_crashed: true,
+      error: "test crashes: #{detector.crash_summary}",
+      error_class: (classes.first if classes.length == 1),
+      test_command: command
+    }
+  end
+end

data/lib/evilution/integration/test_unit/subject_class_registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Tracks Test::Unit::TestCase descendants in the host process. Test::Unit has
+# no public registry-clear method analogous to Minitest::Runnable.runnables;
+# the integration scopes each dispatch to classes that appeared during *this*
+# round by diffing the descendant set before and after #load. Keeping that
+# responsibility in its own object makes it cheap to stub in tests and lets
+# the integration's main class read as orchestration.
+module Evilution::Integration::TestUnit::SubjectClassRegistry
+  module_function
+
+  def descendants
+    return [] unless defined?(::Test::Unit::TestCase)
+
+    ObjectSpace.each_object(Class).select { |c| c < ::Test::Unit::TestCase }
+  end
+
+  # Yields, captures the descendant set before/after, and returns the diff.
+  def newly_loaded
+    before = descendants
+    yield
+    descendants - before
+  end
+end

data/lib/evilution/integration/test_unit/test_file_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Resolves the list of test files to load for a given mutation. Encapsulates
+# the explicit-override path, spec-selector lookup, fallback glob, and the
+# warn-once behaviour for unresolved sources. The integration class would
+# otherwise carry both per-instance test resolution state (@test_files,
+# @spec_selector, @warned_files, @fallback_to_full_suite) and dispatch
+# orchestration in the same object; splitting them gives the resolver its
+# own change axis (e.g. adding new resolution heuristics) independent of
+# the runner.
+class Evilution::Integration::TestUnit::TestFileResolver
+  def initialize(test_files:, spec_selector:, fallback_to_full_suite:)
+    @test_files = test_files
+    @spec_selector = spec_selector
+    @fallback_to_full_suite = fallback_to_full_suite
+    @warned_files = Set.new
+  end
+
+  # Returns the resolved file list, or nil if the source could not be
+  # resolved and fallback is disabled.
+  def call(mutation_file_path)
+    return @test_files if @test_files
+
+    resolved = Array(@spec_selector.call(mutation_file_path))
+    return resolved unless resolved.empty?
+
+    warn_unresolved(mutation_file_path)
+    @fallback_to_full_suite ? glob_test_files : nil
+  end
+
+  private
+
+  def glob_test_files
+    files = Dir.glob("test/**/*_test.rb")
+    files.empty? ? ["test"] : files
+  end
+
+  def warn_unresolved(file_path)
+    return if @warned_files.include?(file_path)
+
+    @warned_files << file_path
+    action = @fallback_to_full_suite ? "running full suite" : "marking mutation unresolved"
+    warn "[evilution] No matching test found for #{file_path}, #{action}. " \
+         "Use --spec to specify the test file."
+  end
+end

data/lib/evilution/integration/test_unit.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "test_unit_crash_detector"
+require_relative "../spec_resolver"
+require_relative "../spec_selector"
+
+require_relative "../integration"
+
+# Test::Unit integration. Decomposed under lib/evilution/integration/test_unit/
+# mirroring the RSpec integration's layout. This class is the orchestrator:
+# it wires the framework loader, dispatcher, subject-class registry,
+# test-file resolver, and result builder. The class is registered under
+# Evilution::Runner::INTEGRATIONS[:test_unit] and reachable via the
+# `--integration test-unit` CLI flag.
+class Evilution::Integration::TestUnit < Evilution::Integration::Base
+  def self.baseline_runner
+    ->(test_file) { run_baseline_test_file(test_file) }
+  end
+
+  # SpecResolver tuned for the dominant Test::Unit layout: tests live under
+  # test/, named with the _test.rb suffix (the same convention Minitest uses).
+  # Rails plugins on the test-unit gem (e.g. kaminari-core) follow this layout.
+  # The test/test_<name>.rb prefix-style convention is rare enough in practice
+  # that we defer support to a follow-up if a project surfaces needing it.
+  def self.spec_resolver
+    Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
+  end
+
+  def self.baseline_options
+    {
+      runner: baseline_runner,
+      spec_resolver: spec_resolver,
+      fallback_dir: "test"
+    }
+  end
+
+  def self.run_baseline_test_file(test_file)
+    require_relative "test_unit/framework_loader"
+    require_relative "test_unit/subject_class_registry"
+    require_relative "test_unit/dispatcher"
+    FrameworkLoader.new.call
+    new_classes = SubjectClassRegistry.newly_loaded do
+      baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+    end
+    Dispatcher.call(new_classes, name: "evilution baseline").passed?
+  end
+
+  def self.baseline_test_files(test_file)
+    File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
+  end
+
+  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil)
+    require_relative "test_unit/framework_loader"
+    require_relative "test_unit/subject_class_registry"
+    require_relative "test_unit/dispatcher"
+    require_relative "test_unit/test_file_resolver"
+    require_relative "test_unit/result_builder"
+    @framework_loader = FrameworkLoader.new
+    @file_resolver = TestFileResolver.new(
+      test_files: test_files,
+      spec_selector: spec_selector || Evilution::SpecSelector.new(spec_resolver: self.class.spec_resolver),
+      fallback_to_full_suite: fallback_to_full_suite
+    )
+    @crash_detector = nil
+    super(hooks: hooks)
+  end
+
+  private
+
+  def ensure_framework_loaded
+    return if @framework_loader.loaded?
+
+    fire_hook(:setup_integration_pre, integration: :test_unit)
+    @framework_loader.call
+    fire_hook(:setup_integration_post, integration: :test_unit)
+  end
+
+  def run_tests(mutation)
+    ensure_framework_loaded
+    reset_state
+    files = @file_resolver.call(mutation.file_path)
+    return ResultBuilder.unresolved(mutation.file_path) if files.nil?
+
+    command = "ruby -Itest #{files.join(" ")}"
+    execute_test_unit(files, command)
+  rescue StandardError => e
+    { passed: false, error: e.message, test_command: command }
+  end
+
+  def execute_test_unit(files, command)
+    new_classes = SubjectClassRegistry.newly_loaded do
+      files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
+    end
+    return ResultBuilder.no_tests_ran(command) if Dispatcher.test_method_count(new_classes).zero?
+
+    detector = reset_crash_detector
+    result = Dispatcher.call(new_classes, name: "evilution-mutation")
+    result.faults.each { |fault| detector.record(fault) }
+    ResultBuilder.call(passed: result.passed?, command: command, detector: detector)
+  end
+
+  # Test::Unit has no public registry-clear analogous to
+  # Minitest::Runnable.runnables.clear. SubjectClassRegistry's newly_loaded
+  # block scopes each dispatch to classes loaded in *this* round, so stale
+  # classes from prior mutations sit dormant on ObjectSpace without polluting
+  # the run. #reset_state stays as a contract no-op for parity with Minitest.
+  def reset_state
+    # no-op — see comment above
+  end
+
+  def build_args(_mutation)
+    []
+  end
+
+  def reset_crash_detector
+    if @crash_detector
+      @crash_detector.reset
+    else
+      @crash_detector = Evilution::Integration::TestUnitCrashDetector.new
+    end
+    @crash_detector
+  end
+end

data/lib/evilution/integration/test_unit_crash_detector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+# Test::Unit analog of Evilution::Integration::MinitestCrashDetector. Tracks
+# whether a Test::Unit test run produced only crashes (exceptions captured as
+# Test::Unit::Error) vs assertion failures (Test::Unit::Failure). When only
+# crashes occur, the mutation result can carry crash details while remaining
+# classified as :killed — see classify_status / Result::MutationResult.
+#
+# Hook the detector into a Test::Unit::TestResult via .attach(result), or
+# call #record(fault) directly when iterating a finished result's #faults.
+class Evilution::Integration::TestUnitCrashDetector
+  def initialize
+    reset
+  end
+
+  def reset
+    @assertion_failures = 0
+    @crashes = []
+  end
+
+  def attach(test_result)
+    require "test/unit/testresult"
+    test_result.add_listener(Test::Unit::TestResult::FAULT) { |fault| record(fault) }
+  end
+
+  def record(fault)
+    if fault.is_a?(Test::Unit::Error)
+      @crashes << fault.exception
+    elsif fault.is_a?(Test::Unit::Failure)
+      @assertion_failures += 1
+    end
+  end
+
+  def passed?
+    @assertion_failures.zero? && @crashes.empty?
+  end
+
+  def assertion_failure?
+    @assertion_failures.positive?
+  end
+
+  def crashed?
+    @crashes.any?
+  end
+
+  def only_crashes?
+    @crashes.any? && @assertion_failures.zero?
+  end
+
+  def unique_crash_classes
+    @crashes.map { |e| e.class.name }.uniq
+  end
+
+  def crash_summary
+    return nil if @crashes.empty?
+
+    "#{unique_crash_classes.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+  end
+end

data/lib/evilution/isolation/fork.rb

@@ -11,6 +11,7 @@ require_relative "../isolation"
 
 class Evilution::Isolation::Fork
   GRACE_PERIOD = 2
+  REAP_DEADLINE = 1.0
 
   def initialize(hooks: nil)
     @hooks = hooks
@@ -48,6 +49,15 @@ class Evilution::Isolation::Fork
   def fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
     ::Process.fork do
       ENV["TMPDIR"] = sandbox_dir
+      # Path-relativizing mutations (e.g. File.join(dir, name) -> name) would
+      # otherwise write into the parent's CWD (typically the repo root) and
+      # leak past the run. chdir here keeps such writes inside sandbox_dir,
+      # which the ensure block of #call removes. The in_isolated_worker! flag
+      # signals the rest of evilution (SpecResolver/SpecSelector/SpecAstCache/
+      # MutationApplier/SourceEvaluator/Integration) to anchor project-relative
+      # paths to Evilution::PROJECT_ROOT instead of the sandbox CWD.
+      Dir.chdir(sandbox_dir)
+      Evilution.in_isolated_worker!
       read_io.close
       suppress_child_output
       @hooks.fire(:worker_process_start, mutation:) if @hooks
@@ -121,8 +131,23 @@ class Evilution::Isolation::Fork
     end
   end
 
+  # Process.wait without a deadline can hang the parent indefinitely. The
+  # per-mutation child may already have written a payload (or a grandchild may
+  # have written garbage that looks like one) while the child itself is stuck
+  # in execute_in_child waiting on a subject grandchild the mutation broke.
+  # wait_for_result has already returned by this point, so the per-mutation
+  # timeout cannot fire. Bound the wait and fall back to the TERM/KILL ladder.
   def reap_and_decode(pid, payload)
-    ::Process.wait(pid)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + REAP_DEADLINE
+    loop do
+      break if ::Process.waitpid(pid, ::Process::WNOHANG)
+
+      if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+        terminate_child(pid)
+        break
+      end
+      sleep 0.05
+    end
     decode_payload(payload)
   end
 

data/lib/evilution/isolation/in_process.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require "timeout"
+require "tmpdir"
 require_relative "../memory"
 require_relative "../result/mutation_result"
 
@@ -17,19 +19,34 @@ class Evilution::Isolation::InProcess
   def call(mutation:, test_command:, timeout:)
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     rss_before = Evilution::Memory.rss_kb
-    result = execute_with_timeout(mutation, test_command, timeout)
+    sandbox_dir = Dir.mktmpdir("evilution-run")
+    result = execute_with_timeout(mutation, test_command, timeout, sandbox_dir)
     rss_after = Evilution::Memory.rss_kb
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
     delta = compute_memory_delta(rss_before, rss_after, result)
 
     build_mutation_result(mutation, result, duration, rss_before, rss_after, delta)
+  ensure
+    FileUtils.rm_rf(sandbox_dir) if sandbox_dir
   end
 
   private
 
-  def execute_with_timeout(mutation, test_command, timeout)
+  # The Dir.chdir block is inside the Timeout.timeout block so that a
+  # Timeout::Error raised mid-call still unwinds through Dir.chdir's ensure
+  # and restores the parent CWD before the rescue clause runs. The sandbox
+  # contains any relative-path writes from path-relativizing mutations
+  # (EV-wqxu / GH #1278). Evilution.with_isolated_worker signals the rest of
+  # evilution (SpecResolver/SpecSelector/SpecAstCache/MutationApplier/
+  # SourceEvaluator/Integration) to anchor project-relative paths to
+  # PROJECT_ROOT for the duration of the call.
+  def execute_with_timeout(mutation, test_command, timeout, sandbox_dir)
     result = Timeout.timeout(timeout) do
-      suppress_output { test_command.call(mutation) }
+      Evilution.with_isolated_worker do
+        Dir.chdir(sandbox_dir) do
+          suppress_output { test_command.call(mutation) }
+        end
+      end
     end
     { timeout: false }.merge(result)
   rescue Timeout::Error

data/lib/evilution/mcp/info_tool.rb

@@ -58,8 +58,8 @@ class Evilution::MCP::InfoTool < MCP::Tool
       },
       integration: {
         type: "string",
-        description: "[subjects, tests] Test integration (rspec, minitest) — 'tests' selects " \
-                     "the matching spec resolver (spec/*_spec.rb for rspec, test/*_test.rb for minitest)"
+        description: "[subjects, tests] Test integration (rspec, minitest, test-unit) — 'tests' selects " \
+                     "the matching spec resolver (spec/*_spec.rb for rspec, test/*_test.rb for minitest/test-unit)"
       },
       skip_config: {
         type: "boolean",

data/lib/evilution/mcp/mutate_tool.rb

@@ -72,8 +72,9 @@ class Evilution::MCP::MutateTool < MCP::Tool
       },
       integration: {
         type: "string",
-        enum: %w[rspec minitest],
-        description: "Test integration to use (default: rspec)"
+        enum: %w[rspec minitest test-unit],
+        description: "Test integration to use (default: rspec). " \
+                     "Use test-unit for projects whose suites run on the test-unit gem."
       },
       isolation: {
         type: "string",

data/lib/evilution/runner/baseline_runner.rb

@@ -5,6 +5,7 @@ require_relative "../baseline"
 require_relative "../spec_resolver"
 require_relative "../integration/rspec"
 require_relative "../integration/minitest"
+require_relative "../integration/test_unit"
 require_relative "../example_filter"
 require_relative "../spec_ast_cache"
 require_relative "../source_ast_cache"
@@ -12,7 +13,8 @@ require_relative "../source_ast_cache"
 unless defined?(Evilution::Runner::INTEGRATIONS)
   Evilution::Runner::INTEGRATIONS = {
     rspec: Evilution::Integration::RSpec,
-    minitest: Evilution::Integration::Minitest
+    minitest: Evilution::Integration::Minitest,
+    test_unit: Evilution::Integration::TestUnit
   }.freeze
 end
 

data/lib/evilution/runner/canary.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "fileutils"
+require "securerandom"
+require_relative "../runner"
+require_relative "../mutation"
+require_relative "../subject"
+
+# Runs one guaranteed-unobservable synthetic mutation through the configured
+# integration + isolation at session start. The synthetic spec never references
+# the synthetic class, so mutating the class cannot change any test outcome — a
+# healthy pipeline must score the mutation :survived. Any other status means the
+# mutation infrastructure is misreporting, so the run aborts before producing
+# numbers that would all be unreliable. Mirrors the configured --isolation so
+# isolation-specific defects are caught too.
+class Evilution::Runner::Canary
+  class Failed < Evilution::Error; end
+
+  def initialize(config:, isolator:, integration_class:, hooks: nil)
+    @config = config
+    @isolator = isolator
+    @integration_class = integration_class
+    @hooks = hooks
+  end
+
+  def call
+    dir = Dir.mktmpdir("evilution-canary")
+    class_path = write_target_class(dir)
+    spec_path = write_spec(dir)
+
+    result = @isolator.call(
+      mutation: build_mutation(class_path),
+      test_command: ->(mutation) { build_integration(spec_path).call(mutation) },
+      timeout: @config.timeout
+    )
+    raise Failed, failure_message(result.status) unless result.status == :survived
+
+    nil
+  ensure
+    FileUtils.remove_entry(dir) if dir
+  end
+
+  private
+
+  # pid + random hex keeps the synthetic class/spec names unique across
+  # concurrent sessions and across repeated re-eval into the same VM.
+  def suffix
+    @suffix ||= "#{Process.pid}_#{SecureRandom.hex(4)}"
+  end
+
+  def class_name
+    @class_name ||= "EvilutionCanary_#{suffix}"
+  end
+
+  def original_source
+    <<~RUBY
+      class #{class_name}
+        private
+
+        def __evilution_canary_probe
+          :original
+        end
+      end
+    RUBY
+  end
+
+  def mutated_source
+    original_source.sub(":original", "nil")
+  end
+
+  def write_target_class(dir)
+    path = File.join(dir, "#{class_name.downcase}.rb")
+    File.write(path, original_source)
+    path
+  end
+
+  def write_spec(dir)
+    minitest = @config.integration == :minitest
+    name = minitest ? "canary_#{suffix}_test.rb" : "canary_#{suffix}_spec.rb"
+    path = File.join(dir, name)
+    File.write(path, minitest ? minitest_spec_source : rspec_spec_source)
+    path
+  end
+
+  def rspec_spec_source
+    <<~RUBY
+      RSpec.describe("evilution proof-of-life canary") do
+        it "pipeline is alive" do
+          expect(true).to be(true)
+        end
+      end
+    RUBY
+  end
+
+  def minitest_spec_source
+    <<~RUBY
+      class EvilutionCanaryTest_#{suffix} < Minitest::Test
+        def test_pipeline_is_alive
+          assert true
+        end
+      end
+    RUBY
+  end
+
+  def build_mutation(class_path)
+    Evilution::Mutation.new(
+      subject: Evilution::Subject.new(
+        name: "#{class_name}#__evilution_canary_probe",
+        file_path: class_path, line_number: 1, source: original_source, node: nil
+      ),
+      operator_name: :canary_probe,
+      sources: Evilution::Mutation::Sources.new(original: original_source, mutated: mutated_source),
+      location: Evilution::Mutation::Location.new(file_path: class_path, line: 5, column: 4)
+    )
+  end
+
+  def build_integration(spec_path)
+    @integration_class.new(test_files: [spec_path], hooks: @hooks)
+  end
+
+  def failure_message(status)
+    "evilution proof-of-life canary failed: a guaranteed-unobservable synthetic " \
+      "mutation was scored #{status.inspect} instead of :survived. The mutation " \
+      "pipeline is misreporting — every score this run would produce is unreliable. " \
+      "Likely causes: Rails/Zeitwerk autoloading breaking child eval; an env-specific " \
+      "RSpec config (e.g. fail_if_no_examples); a classify_status fallback defect; or " \
+      "an isolation-mode defect. Re-run with --no-canary to bypass this check."
+  end
+end

data/lib/evilution/runner.rb

@@ -4,6 +4,11 @@ require "fileutils"
 require_relative "../evilution"
 
 class Evilution::Runner
+  # Autoloaded: canary.rb subclasses Evilution::Error at class-body eval
+  # time, which is not yet defined while evilution.rb is mid-load. Deferring
+  # the load until first reference lets evilution.rb finish defining Error.
+  autoload :Canary, File.expand_path("runner/canary", __dir__)
+
   attr_reader :config
 
   def initialize(config: Evilution::Config.new, on_result: nil, hooks: nil)
@@ -27,6 +32,8 @@ class Evilution::Runner
     perform_preload
     log_memory("after preload") if rails_root_detected?
 
+    run_canary
+
     baseline_result = run_baseline(subjects)
 
     plan = mutation_planner.call(subjects)
@@ -122,6 +129,17 @@ class Evilution::Runner
     baseline_runner.call(subjects)
   end
 
+  def run_canary
+    return unless config.canary?
+
+    Evilution::Runner::Canary.new(
+      config: config,
+      isolator: isolator,
+      integration_class: baseline_runner.integration_class,
+      hooks: @hooks
+    ).call
+  end
+
   def run_mutations(mutations, baseline_result = nil)
     mutation_executor.call(mutations, baseline_result)
   end
@@ -136,7 +154,12 @@ class Evilution::Runner
       return
     end
 
-    dir = config.quiet_children_dir
+    # Resolve to absolute now — fork children chdir into a per-mutation
+    # sandbox (EV-wqxu / GH #1278) before suppress_child_output runs, so a
+    # relative log_dir would reopen $stdout/$stderr at <sandbox>/<log_dir>
+    # which does not exist and the child dies with Errno::ENOENT before
+    # marshaling any result back.
+    dir = File.expand_path(config.quiet_children_dir)
     begin
       FileUtils.rm_rf(dir)
       FileUtils.mkdir_p(dir)