varar-core 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d857a484c127ac8dc313cff7dc855f7924e9b90dd9935b3575e880a4abc5e9c
-  data.tar.gz: becbdbfe8eda5afc06b7506b719fafd3868e1506cec1e484e461766b7b39225a
+  metadata.gz: 4e14558a60af014ad7a1e7edfea61644a415408c5da1e384d6c34d4f191a2743
+  data.tar.gz: f91c617e21f8affcd745676fffba8be6b1ab484ec9c2c4e17b7173d6d07e1733
 SHA512:
-  metadata.gz: f1f17d5bf2fef77cc8c8dbb4d0991c72232b08d0fe139f0c60768016c86b2eeeca33e54b66a4098ba1ab5bf15cbb00aa91f0a3e48e9ceadc7c457c630085d62c
-  data.tar.gz: 05404cecafaeca822ede078824c9bfad5d959236ea7c23f00a8b44a9d0ffe4a002ff9363d7c52bc86649d2d3bfd6b353f68c67c1131ac0c867172beac0e0913f
+  metadata.gz: 4a89ff743d9d00027565cad5933ad28f2bc05af437a773feeac38f9c7c640ee25d548af761852343259afed64654205360e5e2983df9fbd82bc14a1167746013
+  data.tar.gz: 66c9b893012bd279f337db321fbae0262802bf579f627a7d7e0db37ff4183b3ec3112c413af5614481521d61543ca2e634b966d54260032615cf0c97057fd89f

data/lib/varar/core/ast.rb

@@ -46,6 +46,6 @@ module Varar
     # one example. See ADR 0012.
     Example = Data.define(:scope_stack, :span, :body, :preceded_by_delimiter)
 
-    VarDoc = Data.define(:path, :source, :examples, :orphan_attachments)
+    Doc = Data.define(:path, :source, :examples, :orphan_attachments)
   end
 end

data/lib/varar/core/canonical_json.rb

@@ -4,39 +4,39 @@ require 'json'
 
 module Varar
   module Core
-    # JSON serializers byte-for-byte compatible with JS `JSON.stringify(v, null, 2)`:
+    # Writes varar.lock.json the way JS `JSON.stringify(v, null, 2)` does:
     # 2-space indent, LF, trailing newline, non-ASCII raw, empty containers as
-    # {}/[]. `canonical_stringify` recursively sorts object keys (the goldens);
-    # `ordered_stringify` preserves insertion order (varar.lock.json).
+    # {}/[], keys in insertion order.
     #
-    # The container layout is hand-rolled because Ruby's JSON.pretty_generate
-    # renders empty arrays/objects as "[\n\n]". Scalar encoding is delegated to
-    # the stdlib, which matches JS (escapes " \ control chars, keeps non-ASCII raw).
+    # A committed, language-shared file, so the layout is hand-rolled rather
+    # than left to JSON.pretty_generate, which renders empty arrays/objects as
+    # "[\n\n]" — a Ruby run would otherwise churn the file against every other
+    # port's. Scalar encoding is delegated to the stdlib, which matches JS
+    # (escapes " \ control chars, keeps non-ASCII raw).
+    #
+    # Conformance goldens are NOT compared through here: a port has to agree
+    # with the goldens' CONTENT, and every spec parses them and compares deep
+    # equality.
     module CanonicalJson
       module_function
 
-      def canonical_stringify(value)
-        "#{encode(value, '', sort_keys: true)}\n"
-      end
-
       def ordered_stringify(value)
-        "#{encode(value, '', sort_keys: false)}\n"
+        "#{encode(value, '')}\n"
       end
 
-      def encode(value, indent, sort_keys:)
+      def encode(value, indent)
         case value
         when Hash
           return '{}' if value.empty?
 
-          keys = sort_keys ? value.keys.sort : value.keys
           inner = "#{indent}  "
-          items = keys.map { |key| "#{inner}#{key.to_s.to_json}: #{encode(value[key], inner, sort_keys: sort_keys)}" }
+          items = value.keys.map { |key| "#{inner}#{key.to_s.to_json}: #{encode(value[key], inner)}" }
           "{\n#{items.join(",\n")}\n#{indent}}"
         when Array
           return '[]' if value.empty?
 
           inner = "#{indent}  "
-          items = value.map { |element| "#{inner}#{encode(element, inner, sort_keys: sort_keys)}" }
+          items = value.map { |element| "#{inner}#{encode(element, inner)}" }
           "[\n#{items.join(",\n")}\n#{indent}]"
         else
           value.to_json

data/lib/varar/core/conformance.rb

@@ -98,8 +98,8 @@ module Varar
         }
       end
 
-      # Project a VarDoc to the wire dict for the var-doc artifact.
-      def to_var_doc_artifact(doc)
+      # Project a Doc to the wire dict for the var-doc artifact.
+      def to_doc_artifact(doc)
         {
           'path' => doc.path,
           'examples' => doc.examples.map { |ex| example_hash(ex) },
@@ -137,7 +137,7 @@ module Varar
 
       # Project an ExecutionPlan to the wire dict for the plan artifact.
       def to_plan_artifact(plan)
-        source = plan.var_doc.source
+        source = plan.doc.source
         {
           'examples' => plan.examples.map { |ex| planned_example_hash(ex, source) },
           'diagnostics' => plan.diagnostics.map do |d|
@@ -206,8 +206,8 @@ module Varar
       end
 
       # Run all examples and return the four-artifact bundle. Port of runConformance.
-      def run_conformance(var_doc, registry, create_context, parameter_types = [])
-        execution = Plan.plan(var_doc, registry)
+      def run_conformance(doc, registry, create_context, parameter_types = [])
+        execution = Plan.plan(doc, registry)
         observed = Hash.new { |h, k| h[k] = [] }
         observer = ->(o) { observed[o.example_index] << o }
         queue = Execute.collect_examples(execution, create_context: create_context, observer: observer)
@@ -244,7 +244,7 @@ module Varar
         end
 
         {
-          var_doc: to_var_doc_artifact(var_doc),
+          doc: to_doc_artifact(doc),
           registry: to_registry_artifact(registry, parameter_types),
           plan: to_plan_artifact(execution),
           trace: { 'examples' => trace_examples }

data/lib/varar/core/drift.rb

@@ -10,14 +10,14 @@ module Varar
   module Core
     # One example-producing paragraph, as recorded in the baseline.
     BaselineExample = Data.define(:name, :line)
-    # The committed baseline for one spec file.
-    SpecBaseline = Data.define(:source_hash, :examples)
-    # The whole varar.lock.json: every spec keyed by its POSIX path.
-    VarLock = Data.define(:version, :specs)
+    # The committed baseline for one oath file.
+    OathBaseline = Data.define(:source_hash, :examples)
+    # The whole varar.lock.json: every oath keyed by its POSIX path.
+    LockFile = Data.define(:version, :oaths)
     # A paragraph the baseline says was an example and now matches no step.
     Drift = Data.define(:name, :line, :span)
 
-    # Spec drift detection: a paragraph the committed varar.lock.json baseline
+    # Oath drift detection: a paragraph the committed varar.lock.json baseline
     # recorded as an example that now matches no step. Pure, byte-identical to
     # the TS port so varar.lock.json is shared across languages. Port of drift.ts.
     #
@@ -62,25 +62,25 @@ module Varar
       end
 
       # The current example-producing paragraphs, in document order.
-      def live_examples(var_doc, plan)
-        var_doc.examples.filter_map do |candidate|
+      def live_examples(doc, plan)
+        doc.examples.filter_map do |candidate|
           next unless live?(candidate.span, plan)
 
           BaselineExample.new(name: Plan.derive_example_name(candidate.body), line: candidate.span.start_line)
         end
       end
 
-      def derive_spec_baseline(source, var_doc, plan)
-        SpecBaseline.new(source_hash: Hash32.hash_source(source), examples: live_examples(var_doc, plan))
+      def derive_oath_baseline(source, doc, plan)
+        OathBaseline.new(source_hash: Hash32.hash_source(source), examples: live_examples(doc, plan))
       end
 
       # Paragraphs the baseline recorded as examples that now match zero steps.
       # Each re-identified by the most word-similar current paragraph at/above
       # the threshold (exact name scores 1; ties break toward the nearest line).
-      def detect_drift(baseline, var_doc, plan)
+      def detect_drift(baseline, doc, plan)
         return [] if baseline.nil?
 
-        candidates = var_doc.examples
+        candidates = doc.examples
         tokens = candidates.map { |c| tokenize(Plan.derive_example_name(c.body)) }
         live = candidates.map { |c| live?(c.span, plan) }
 
@@ -111,43 +111,76 @@ module Varar
         drifts.map { |d| Diagnostics.drift_detected(d.name, d.span) }
       end
 
-      # One spec's baseline reconciliation against a BaselineStore. In update
+      # One oath's baseline reconciliation against a BaselineStore. In update
       # mode, accept all drift (re-record, report nothing); otherwise detect
       # drift and rewrite the baseline only on a clean run, so an unacknowledged
       # drift keeps its old entry (and stays red).
-      def reconcile_drift(store, spec_path, source, var_doc, plan, update: false)
+      def reconcile_drift(store, oath_path, source, doc, plan, update: false)
         text = store.read
-        lock = text ? parse_var_lock(text) : nil
-        baseline = lock ? lock.specs[spec_path] : nil
-        drifts = update ? [] : detect_drift(baseline, var_doc, plan)
+        lock = text ? parse_lock_file(text) : nil
+        baseline = lock ? lock.oaths[oath_path] : nil
+        drifts = update ? [] : detect_drift(baseline, doc, plan)
         if update || drifts.empty?
-          specs = lock ? lock.specs.dup : {}
-          specs[spec_path] = derive_spec_baseline(source, var_doc, plan)
-          store.write(stringify_var_lock(VarLock.new(version: 1, specs: specs)))
+          oaths = lock ? lock.oaths.dup : {}
+          oaths[oath_path] = derive_oath_baseline(source, doc, plan)
+          store.write(stringify_lock_file(LockFile.new(version: 2, oaths: oaths)))
         end
         drifts
       end
 
-      def parse_var_lock(text)
+      # Drop every baseline whose oath path is not in +keep_paths+ — the entries
+      # left behind when an oath is deleted or moved. Pure counterpart of
+      # parse_lock_file / stringify_lock_file; the caller decides what "still
+      # exists" means.
+      def prune_lock_file(lock, keep_paths)
+        keep = keep_paths.to_a
+        LockFile.new(version: 2, oaths: lock.oaths.slice(*keep))
+      end
+
+      # The whole-lock counterpart of reconcile_drift, run ONCE per run rather
+      # than per oath: reconciliation cannot see paths that no longer exist, so
+      # without this the lock silently accumulates dead entries and stops being
+      # a faithful inventory of the oath set (#70).
+      #
+      # +keep_paths+ MUST be everything the +docs+ globs currently match — never
+      # the set the run happened to execute. Runs are routinely filtered, and
+      # pruning against a filtered set would delete live baselines.
+      #
+      # Removal is still not *gated*: a deleted oath is a different signal from
+      # drift and stays ungated (ADR 0002). This only stops preserving dead
+      # state, and only under +update+. Returns the paths removed (or, without
+      # +update+, the ones that would be).
+      def prune_baselines(store, keep_paths, update: false)
+        text = store.read
+        lock = text ? parse_lock_file(text) : nil
+        return [] unless lock
+
+        keep = keep_paths.to_a
+        stale = lock.oaths.keys.reject { |path| keep.include?(path) }
+        store.write(stringify_lock_file(prune_lock_file(lock, keep))) if update && !stale.empty?
+        stale
+      end
+
+      def parse_lock_file(text)
         parsed = JSON.parse(text)
-        return nil unless parsed.is_a?(::Hash) && parsed['version'] == 1
+        return nil unless parsed.is_a?(::Hash) && parsed['version'] == 2
 
-        specs_raw = parsed['specs']
-        return nil unless specs_raw.is_a?(::Hash)
+        oaths_raw = parsed['oaths']
+        return nil unless oaths_raw.is_a?(::Hash)
 
-        specs = {}
-        specs_raw.each do |path, value|
-          baseline = parse_spec_baseline(value)
+        oaths = {}
+        oaths_raw.each do |path, value|
+          baseline = parse_oath_baseline(value)
           return nil if baseline.nil?
 
-          specs[path] = baseline
+          oaths[path] = baseline
         end
-        VarLock.new(version: 1, specs: specs)
+        LockFile.new(version: 2, oaths: oaths)
       rescue JSON::ParserError, TypeError
         nil
       end
 
-      def parse_spec_baseline(value)
+      def parse_oath_baseline(value)
         return nil unless value.is_a?(::Hash)
 
         source_hash = value['sourceHash']
@@ -161,7 +194,7 @@ module Varar
 
           examples << parsed
         end
-        SpecBaseline.new(source_hash: source_hash, examples: examples)
+        OathBaseline.new(source_hash: source_hash, examples: examples)
       end
 
       def parse_baseline_example(value)
@@ -174,19 +207,19 @@ module Varar
         BaselineExample.new(name: name, line: line)
       end
 
-      # Serialize varar.lock.json deterministically: spec paths sorted, examples
-      # in document order, insertion-order keys otherwise (version, specs;
+      # Serialize varar.lock.json deterministically: oath paths sorted, examples
+      # in document order, insertion-order keys otherwise (version, oaths;
       # sourceHash, examples; name, line) — NOT canonical JSON's key sort.
-      def stringify_var_lock(lock)
-        specs = {}
-        lock.specs.keys.sort.each do |path|
-          baseline = lock.specs[path]
-          specs[path] = {
+      def stringify_lock_file(lock)
+        oaths = {}
+        lock.oaths.keys.sort.each do |path|
+          baseline = lock.oaths[path]
+          oaths[path] = {
             'sourceHash' => baseline.source_hash,
             'examples' => baseline.examples.map { |e| { 'name' => e.name, 'line' => e.line } }
           }
         end
-        CanonicalJson.ordered_stringify({ 'version' => 1, 'specs' => specs })
+        CanonicalJson.ordered_stringify({ 'version' => 2, 'oaths' => oaths })
       end
     end
   end

data/lib/varar/core/execute.rb

@@ -42,17 +42,17 @@ module Varar
       def execute_plan(plan, sink:, create_context:, observer: nil, reporter: nil)
         plan.diagnostics.each { |d| reporter.call(d) } if reporter
         create_ctx = create_context || ->(_file) { {} }
-        var_path = plan.var_doc.path
+        oath_path = plan.doc.path
 
         plan.examples.each_with_index do |ex, example_index|
           seen_lines = {}
           ex.steps.each { |s| seen_lines[s.match_span.start_line] = true }
           info = { lines: seen_lines.keys }
-          sink.call(ex.name, build_run(plan, ex, example_index, create_ctx, observer, var_path), info)
+          sink.call(ex.name, build_run(plan, ex, example_index, create_ctx, observer, oath_path), info)
         end
       end
 
-      def build_run(plan, ex, example_index, create_ctx, observer, var_path)
+      def build_run(plan, ex, example_index, create_ctx, observer, oath_path)
         lambda do
           state_by_file = {}
           last_return = nil
@@ -97,7 +97,7 @@ module Varar
                 raise ReturnShapeError, "unknown step kind: #{step.step_def.kind}"
               end
             rescue StandardError => e
-              augmented = augment_stack(e, step, var_path)
+              augmented = augment_stack(e, step, oath_path)
               observer&.call(observation(ex, example_index, i + 1, file, 'fail', augmented))
               thrown = augmented
               break
@@ -117,7 +117,7 @@ module Varar
             bad = CellDiffs.compare_row(last_return, ex.row_checks).reject(&:ok)
             if row_error || !bad.empty?
               last_step = ex.steps.last
-              augmented = augment_stack(row_error || CellMismatchError.new(bad), last_step, var_path)
+              augmented = augment_stack(row_error || CellMismatchError.new(bad), last_step, oath_path)
               observer&.call(observation(ex, example_index, ex.steps.length,
                                          last_step.step_def.expression_source_file, 'fail', augmented))
               thrown = augmented
@@ -129,7 +129,7 @@ module Varar
             if thrown.nil?
               error = UnexpectedPassError.new
               last = ex.steps.last
-              raise(last ? augment_stack(error, last, var_path) : error)
+              raise(last ? augment_stack(error, last, oath_path) : error)
             end
             raise thrown if ex.expected_error_message && !thrown.message.include?(ex.expected_error_message)
 
@@ -177,7 +177,7 @@ module Varar
 
         inline_returned = slots[0...step.args.length]
         source_texts = step.param_spans.map do |s|
-          Offsets.utf16_slice(plan.var_doc.source, s.start_offset, s.end_offset)
+          Offsets.utf16_slice(plan.doc.source, s.start_offset, s.end_offset)
         end
         param_diffs = ParamDiff.compare_params(inline_returned, step.args, step.param_spans, source_texts,
                                                step.formats).reject(&:ok)
@@ -199,9 +199,12 @@ module Varar
       end
 
       # In TS this injects a synthetic `at <text> (path:line:col)` frame for
-      # editor navigation; the conformance trace derives the anchor separately
-      # via failure_anchor, so here it is a no-op that returns the error.
-      def augment_stack(error, _step, _var_path)
+      # editor navigation. Ruby has no writable stack text to splice into, so
+      # it records the anchor structurally instead — the failing step's span
+      # (or the first mismatched cell's), which Failures.to_failure reads back
+      # so a renderer underlines the step and not its whole line.
+      def augment_stack(error, step, _var_path)
+        FailureAnchor.attach_anchor(error, FailureAnchor.failure_anchor(error, step.match_span))
         error
       end
     end

data/lib/varar/core/failure.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'varar/core/cell_diff'
+require 'varar/core/failure_anchor'
+require 'varar/core/result'
+
+module Varar
+  module Core
+    # Converts a caught step error into the structured ExampleFailure payload —
+    # port of failure.ts / failure.py / Failure.java / failure.rs. Shared by
+    # every producer so failures are byte-identical across ports.
+    #
+    # Where TS scrapes an injected `<path>:line:col` stack frame for the failing
+    # line, Ruby reads it off the anchor the executor attached (the Rust port
+    # does the same): a Ruby backtrace has no synthetic frame to scrape, and the
+    # anchor already carries the line the frame would have named.
+    module Failures
+      module_function
+
+      # A caught step error → the ExampleResult.failure payload.
+      #
+      # `fallback_line` is used when the error carries no anchor, i.e. it never
+      # passed through a step.
+      def to_failure(error, _oath_path, fallback_line)
+        anchor = FailureAnchor.attached_anchor(error)
+
+        ExampleFailure.new(
+          line: anchor ? anchor.start_line : fallback_line,
+          message: error.message,
+          stack: render_stack(error),
+          cells: failing_cells(error),
+          anchor: anchor && AnchorRange.new(from: anchor.start_offset, to: anchor.end_offset)
+        )
+      end
+
+      # Every mismatched cell — table, header-bound row, inline capture or doc
+      # string. nil (not an empty array) when the error is not a mismatch, so
+      # the key stays absent in the serialized payload.
+      def failing_cells(error)
+        return nil unless error.is_a?(CellMismatchError)
+
+        failing = error.cells.reject(&:ok).map do |c|
+          CellFailure.new(from: c.span.start_offset, to: c.span.end_offset, actual: c.actual)
+        end
+        failing.empty? ? nil : failing
+      end
+
+      # Display-only: the message plus Ruby's own backtrace. Runtime-shaped by
+      # design (ADR 0014) — no consumer parses it.
+      def render_stack(error)
+        ([error.message] + Array(error.backtrace)).join("\n")
+      end
+    end
+  end
+end

data/lib/varar/core/failure_anchor.rb

@@ -12,6 +12,13 @@ module Varar
     module FailureAnchor
       module_function
 
+      # The anchor travels with the raised error, from the executor (which knows
+      # the step) to Failures.to_failure (which only sees the error) — the same
+      # job TS does with a global symbol on the Error. An instance variable on
+      # the exception, so it never shows up in `inspect` output the way an
+      # extra attribute would.
+      ANCHOR_IVAR = :@varar_failure_anchor
+
       def failure_anchor(error, fallback)
         case error
         when CellMismatchError
@@ -21,6 +28,19 @@ module Varar
           fallback
         end
       end
+
+      # Record on the error itself where the failure points.
+      def attach_anchor(error, anchor)
+        error.instance_variable_set(ANCHOR_IVAR, anchor) if error.respond_to?(:instance_variable_set)
+      end
+
+      # The anchor the executor attached, or nil if there is none — then a
+      # renderer only has the failing line to go on.
+      def attached_anchor(error)
+        return nil unless error.respond_to?(:instance_variable_get)
+
+        error.instance_variable_get(ANCHOR_IVAR)
+      end
     end
   end
 end

data/lib/varar/core/parse.rb

@@ -5,7 +5,7 @@ require 'varar/core/structurer'
 
 module Varar
   module Core
-    # Parse +source+ into a VarDoc: scan blocks, then group into Examples.
+    # Parse +source+ into a Doc: scan blocks, then group into Examples.
     # Port of parse.ts.
     module Parse
       module_function

data/lib/varar/core/plan.rb

@@ -29,9 +29,9 @@ module Varar
       end
     end
 
-    ExecutionPlan = Data.define(:var_doc, :examples, :diagnostics)
+    ExecutionPlan = Data.define(:doc, :examples, :diagnostics)
 
-    # Produce an ExecutionPlan from a VarDoc + Registry: match step expressions
+    # Produce an ExecutionPlan from a Doc + Registry: match step expressions
     # against every text block, attach trailing tables/fences, detect
     # header-bound tables, and collect diagnostics. Port of plan.ts.
     module Plan
@@ -52,11 +52,11 @@ module Varar
 
       module_function
 
-      def plan(var_doc, registry)
+      def plan(doc, registry)
         diagnostics = []
 
         # Phase 1: plan each candidate paragraph independently into a "unit".
-        units = var_doc.examples.map { |ex| plan_candidate(ex, var_doc, registry, diagnostics) }
+        units = doc.examples.map { |ex| plan_candidate(ex, doc, registry, diagnostics) }
 
         # Phase 2: group adjacent candidates into examples. A matching candidate
         # continues the open example when no delimiter (heading / `---`) precedes
@@ -66,7 +66,7 @@ module Varar
         examples = []
         open = nil
         flush = lambda do
-          examples << finish_merged(open, var_doc.source) if open
+          examples << finish_merged(open, doc.source) if open
           open = nil
         end
         units.each do |unit|
@@ -89,7 +89,7 @@ module Varar
         end
         flush.call
 
-        ExecutionPlan.new(var_doc: var_doc, examples: examples, diagnostics: diagnostics)
+        ExecutionPlan.new(doc: doc, examples: examples, diagnostics: diagnostics)
       end
 
       def start_merged(unit)
@@ -124,7 +124,7 @@ module Varar
 
       # Plan a single candidate paragraph (plus attached tables/fences) in
       # isolation. Emits ambiguity / error-fence diagnostics into +diagnostics+.
-      def plan_candidate(ex, var_doc, registry, diagnostics)
+      def plan_candidate(ex, doc, registry, diagnostics)
         had_ambiguous = false
         steps_by_block = {}
 
@@ -135,7 +135,7 @@ module Varar
           result = plan_block(block.text, registry)
 
           result.ambiguities.each do |collision|
-            span = lift_span(var_doc.source, block, collision.match_start, collision.match_end)
+            span = lift_span(doc.source, block, collision.match_start, collision.match_end)
             cp_start = Offsets.cp_index_for_utf16(block.text, collision.match_start)
             cp_end = Offsets.cp_index_for_utf16(block.text, collision.match_end)
             diagnostics << Diagnostics.ambiguous_match(
@@ -159,8 +159,8 @@ module Varar
           steps_by_block[idx] = result.steps.map do |hit|
             PlannedStep.new(
               text: Offsets.utf16_slice(block.text, hit.match_start, hit.match_end),
-              match_span: lift_span(var_doc.source, block, hit.match_start, hit.match_end),
-              param_spans: hit.param_spans.map { |p| lift_span(var_doc.source, block, p.start, p.end) },
+              match_span: lift_span(doc.source, block, hit.match_start, hit.match_end),
+              param_spans: hit.param_spans.map { |p| lift_span(doc.source, block, p.start, p.end) },
               step_def: hit.step_def,
               args: hit.args,
               formats: hit.formats
@@ -169,7 +169,7 @@ module Varar
         end
 
         # Header-bound table detection.
-        bound = had_ambiguous ? nil : detect_header_bound(ex, steps_by_block, var_doc.source)
+        bound = had_ambiguous ? nil : detect_header_bound(ex, steps_by_block, doc.source)
         if bound
           table, binding_step, header_spans = bound
           header_binding = HeaderBinding.new(

data/lib/varar/core/registry.rb

@@ -39,7 +39,7 @@ module Varar
       end
 
       # Seed Varar's own built-in parameter types (beyond cucumber-expressions'
-      # int/float/string/word). Shared by every port so specs match
+      # int/float/string/word). Shared by every port so oaths match
       # identically. Built-ins are NOT tracked as custom parameter types, so
       # they never appear in the conformance registry.json projection.
       def seed_builtins(registry)

data/lib/varar/core/result.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Varar
+  module Core
+    # Run-result records — port of result.ts / result.rb's siblings in every
+    # other port. The persisted .varar/<oath_path>.json file is a serialized
+    # OathResults, read by the language server to place run diagnostics in the
+    # editor (ADR 0014).
+
+    # One mismatched CELL as a source-offset range plus the runtime value.
+    # `from`/`to` are absolute UTF-16 source offsets; `to` is exclusive.
+    CellFailure = Data.define(:from, :to, :actual)
+
+    # Where a failure points in the source: an offset range, `to` exclusive.
+    # The failing step's match span, or the first mismatched cell's span (the
+    # failure_anchor rule) — what lets a renderer underline the step that
+    # failed rather than the whole line it sits on.
+    AnchorRange = Data.define(:from, :to)
+
+    # The failure payload of a failed ExampleResult. `cells` and `anchor` are
+    # nil when they do not apply, and serialize as absent (not null), so a
+    # reader that predates them still parses the file. `stack` is deliberately
+    # runtime-shaped — no consumer parses it.
+    ExampleFailure = Data.define(:line, :message, :stack, :cells, :anchor) do
+      def initialize(line:, message:, stack:, cells: nil, anchor: nil)
+        super
+      end
+    end
+
+    # The run result for one BDD example. `lines` are the 1-based source lines
+    # of its steps (the editor's line-wash anchors).
+    ExampleResult = Data.define(:name, :status, :lines, :failure) do
+      def initialize(name:, status:, lines:, failure: nil)
+        super
+      end
+    end
+
+    # The persisted run result for one oath file. `oath_path` uses POSIX
+    # separators and is relative to the workspace root; `source_hash` is
+    # Hashing.hash_source over the oath as it was run, so a reader can tell
+    # whether the offsets still apply to the buffer in front of it.
+    OathResults = Data.define(:version, :oath_path, :source_hash, :examples)
+
+    # Projection of OathResults onto the JSON shape of .varar/<oath_path>.json.
+    #
+    # The wire format is the TypeScript one (ADR 0014): camelCase names,
+    # declaration order, and the optional members absent rather than null so a
+    # reader that predates them still parses the file. Pure — writing the file
+    # is the shell's job.
+    module Results
+      module_function
+
+      def to_wire(results)
+        {
+          'version' => results.version,
+          'oathPath' => results.oath_path,
+          'sourceHash' => results.source_hash,
+          'examples' => results.examples.map { |e| example_to_wire(e) }
+        }
+      end
+
+      def example_to_wire(example)
+        out = { 'name' => example.name, 'status' => example.status, 'lines' => example.lines.to_a }
+        out['failure'] = failure_to_wire(example.failure) if example.failure
+        out
+      end
+
+      def failure_to_wire(failure)
+        out = { 'line' => failure.line, 'message' => failure.message, 'stack' => failure.stack }
+        if failure.cells && !failure.cells.empty?
+          out['cells'] = failure.cells.map { |c| { 'from' => c.from, 'to' => c.to, 'actual' => c.actual } }
+        end
+        out['anchor'] = { 'from' => failure.anchor.from, 'to' => failure.anchor.to } if failure.anchor
+        out
+      end
+    end
+  end
+end

data/lib/varar/core/structurer.rb

@@ -66,7 +66,7 @@ module Varar
           end
         end
 
-        VarDoc.new(
+        Doc.new(
           path: path,
           source: source,
           examples: examples,

data/lib/varar/core.rb

@@ -4,7 +4,7 @@ module Varar
   # The pure functional core: parse, match, plan, execute, diffs, drift, and
   # the conformance projections. No filesystem, network, globals, or time.
   module Core
-    VERSION = '0.7.0'
+    VERSION = '0.8.0'
   end
 end
 
@@ -24,6 +24,8 @@ require 'varar/core/plan'
 require 'varar/core/doc_string_diff'
 require 'varar/core/param_diff'
 require 'varar/core/failure_anchor'
+require 'varar/core/result'
+require 'varar/core/failure'
 require 'varar/core/execute'
 require 'varar/core/hash'
 require 'varar/core/drift'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: varar-core
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Aslak Hellesøy
@@ -40,6 +40,7 @@ files:
 - lib/varar/core/doc_string_diff.rb
 - lib/varar/core/drift.rb
 - lib/varar/core/execute.rb
+- lib/varar/core/failure.rb
 - lib/varar/core/failure_anchor.rb
 - lib/varar/core/hash.rb
 - lib/varar/core/matcher.rb
@@ -47,6 +48,7 @@ files:
 - lib/varar/core/parse.rb
 - lib/varar/core/plan.rb
 - lib/varar/core/registry.rb
+- lib/varar/core/result.rb
 - lib/varar/core/scanner.rb
 - lib/varar/core/sentences.rb
 - lib/varar/core/span.rb