hegeltest 0.3.4-aarch64-linux → 0.4.1-aarch64-linux

data/lib/hegel/test_location.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "runner"
+
+module Hegel
+  # Where a Hegel.test call lives, in the four pieces
+  # hegel_settings_set_test_location takes. Under Antithesis the engine
+  # reports each run's verdict as the assertion
+  # "<class_name>::<function> passes properties" at file:begin_line, so two
+  # calls that share a class_name and a function share one assertion.
+  TestLocation = Data.define(:file, :begin_line, :class_name, :function)
+
+  class TestLocation
+    # Matches the label prefix Ruby 3.4 puts on a frame inside a block, so
+    # that the method underneath names the test.
+    BLOCK_PREFIX = /\A(?:block(?: \(\d+ levels\))? in )+/
+
+    # Matches "Class#method" and "Class.method". Greedy, so a namespaced
+    # class keeps its "::" and a "#<Class:0x...>" label splits at its last
+    # separator.
+    METHOD_LABEL = /\A(.+)[#.]([^#.]+)\z/
+
+    # The first of +locations+ that is the caller's own, by the same rule
+    # Runner.origin_for uses to name a failure (see ADR 0012), so a wrapper in
+    # this gem, a gem, or the standard library is not named as the test.
+    # +locations+ is never empty, because the frame of Hegel.test's own caller
+    # exists even at the top of a script.
+    def self.from_locations(locations)
+      location = locations.find { |candidate| !Runner.infrastructure?(candidate.path) } || locations.first
+      path = location.absolute_path || location.path
+      root = File.join(Dir.pwd, "")
+      file = path.start_with?(root) ? path.delete_prefix(root) : path
+      class_name, function = names(location.label, file, location.lineno)
+      new(file: file, begin_line: location.lineno, class_name: class_name, function: function)
+    end
+
+    # [class_name, function] for a frame +label+. A frame with no enclosing
+    # method (a script body, or an RSpec example, whose block sits at the top
+    # of its file) has no name of its own, so it takes its file and line:
+    # that keeps two examples in one file from sharing one assertion.
+    def self.names(label, file, lineno)
+      match = METHOD_LABEL.match(label.sub(BLOCK_PREFIX, ""))
+      return match.captures if match
+
+      [file.delete_suffix(".rb"), "line #{lineno}"]
+    end
+    private_class_method :names
+  end
+end

data/lib/hegel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hegel
-  VERSION = "0.3.4"
+  VERSION = "0.4.1"
 end

data/lib/hegel.rb

@@ -3,6 +3,7 @@
 require_relative "hegel/version"
 require_relative "hegel/errors"
 require_relative "hegel/runner"
+require_relative "hegel/test_location"
 require_relative "hegel/generator"
 require_relative "hegel/generators"
 require_relative "hegel/syntax/methods"
@@ -28,6 +29,13 @@ module Hegel
   # assertion failure rather than as a Hegel-specific one. Raises
   # Hegel::Error for a run-level failure instead of a property failure.
   #
+  # +profile+ names the settings profile the run starts from: one of the
+  # engine's shipped profiles, one in hegel.toml, or one registered with
+  # Hegel::Settings.register_profile. Left nil, the run starts from the
+  # default profile. A keyword passed alongside still beats the profile, and
+  # report_multiple_failures is always passed, so a profile's value for it
+  # never applies (see docs/adr/0028). An unknown name raises Hegel::Error.
+  #
   # +test_cases+, +seed+, +derandomize+, +verbosity+, +phases+, and
   # +suppress_health_check+ all default to nil, which means the same thing
   # for each of them: do not call the matching libhegel setter, and let the
@@ -54,6 +62,11 @@ module Hegel
   # keyword above: see Hegel::Runner.run's own comment for why it is always
   # passed.
   #
+  # +stop_on_first_failure+, +print_blob+, +show_statistics+,
+  # +nondeterminism_strictness+, and +backend+ default to nil, so the engine's
+  # profile decides as it does for +test_cases+; they follow hegel-rust's
+  # Settings.
+  #
   # +output+ (default $stderr) is where a failure report is written; a
   # caller passes its own IO to capture that report instead (tests do).
   #
@@ -66,13 +79,16 @@ module Hegel
   # real engine. Ordinary callers never pass it. Its default expression
   # (#default_impl) only runs when +impl+ is not given, so a test that does
   # pass one never opens the native library at all.
-  def test(test_cases: nil, seed: nil, derandomize: nil, verbosity: nil, database: nil, database_key: nil,
-    phases: nil, suppress_health_check: nil, report_multiple_failures: false, output: $stderr,
+  def test(profile: nil, test_cases: nil, seed: nil, derandomize: nil, verbosity: nil, database: nil, database_key: nil,
+    phases: nil, suppress_health_check: nil, report_multiple_failures: false, stop_on_first_failure: nil,
+    print_blob: nil, show_statistics: nil, nondeterminism_strictness: nil, backend: nil, output: $stderr,
     reproduce_failure: nil, impl: default_impl, &block)
-    Runner.run(impl: impl, test_cases: test_cases, seed: seed, derandomize: derandomize, verbosity: verbosity,
+    Runner.run(impl: impl, profile: profile, test_cases: test_cases, seed: seed, derandomize: derandomize, verbosity: verbosity,
       database: database, database_key: database_key, phases: phases, suppress_health_check: suppress_health_check,
-      report_multiple_failures: report_multiple_failures, output: output, reproduce_failure: reproduce_failure,
-      &block)
+      report_multiple_failures: report_multiple_failures, stop_on_first_failure: stop_on_first_failure,
+      print_blob: print_blob, show_statistics: show_statistics, nondeterminism_strictness: nondeterminism_strictness,
+      backend: backend, output: output, reproduce_failure: reproduce_failure,
+      test_location: TestLocation.from_locations(caller_locations(1)), &block)
   end
 
   # The Hegel::LibHegel::Real instance #test uses by default, built once and