rangeable 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b0a56ae009cc8892842f7b40ca828a0aa0f716c389b58b2e172afe08bca8e70
-  data.tar.gz: 67ecd4f99e0e9857a952301eacc7564507d1d0c422a9ee61b2e34eb141ad852d
+  metadata.gz: f362dd2814304e1073bec891bb7e2611d379ca0661f9681f78ca87a066253ec2
+  data.tar.gz: c6cfb8717fe206e7477710627faabe5f91c07177f4e740120f5a1b2eaf01625a
 SHA512:
-  metadata.gz: 119170a145bf1229fc3777caa8d6c7747349cd9f8a05cf5411b609b01ff22d2b28a1914d4eaa3494dfccbf6a9f40716e2456662b4cf507c8479f0c5071ddaba1
-  data.tar.gz: 2e76959c07b80799a06b5f01aedaa71d807f3a842be70e4565bf38aed64b3a860d1b7380aa1f9c125e18aa4d1bab5ca59f548e27cb48b0b97cfdad8034fd6c15
+  metadata.gz: c82564bc81baa64215ec301c681a350cba6600d45a39d04ff7bb1e65f900efb593d5dd5192c051de84254337394de99f312183c0fd682d731c5c88152b3ac330
+  data.tar.gz: b00a459e59a86b5d62a95d9bafeeae1edcf7f539a16e0b4b11fd75d9ef0631f2ded2c395cb52e9c44c48b68a6e780982446fbca73b42ef2b4638924305ae41dc

data/README.md

@@ -95,10 +95,18 @@ See [RangeableRFC](https://github.com/ZhgChgLi/RangeableRFC) § 4 for normative
 | Brute-force baseline (m=50, L=2000) vs `Rangeable` | **~5.5× speedup** in micro-benchmark |
 | Real consumer ([ZMediumToMarkdown](https://github.com/ZhgChgLi/ZMediumToMarkdown)) | **2.23× end-to-end speedup**, 55% render-time reduction; all 306 existing tests byte-identical |
 
+## Cross-language consistency
+
+This Ruby implementation joins the [Swift](https://github.com/ZhgChgLi/SwiftRangeable), [Python](https://github.com/ZhgChgLi/PythonRangeable), [JS](https://github.com/ZhgChgLi/JSRangeable), [Kotlin](https://github.com/ZhgChgLi/KotlinRangeable) and [Go](https://github.com/ZhgChgLi/GoRangeable) implementations. All six share a 160-op / 86-probe JSON fixture and produce byte-identical outputs.
+
 ## See also
 
 - **[RangeableRFC](https://github.com/ZhgChgLi/RangeableRFC)** — the normative specification this gem implements.
-- **[SwiftRangeable](https://github.com/ZhgChgLi/SwiftRangeable)** — sibling reference implementation in Swift; produces byte-identical outputs against a shared cross-language fixture.
+- **[SwiftRangeable](https://github.com/ZhgChgLi/SwiftRangeable)** — Swift reference (SPM).
+- **[PythonRangeable](https://github.com/ZhgChgLi/PythonRangeable)** — Python reference (`pip install rangeable`).
+- **[JSRangeable](https://github.com/ZhgChgLi/JSRangeable)** — TypeScript reference (`npm i rangeable-js`).
+- **[KotlinRangeable](https://github.com/ZhgChgLi/KotlinRangeable)** — Kotlin/JVM reference (JitPack).
+- **[GoRangeable](https://github.com/ZhgChgLi/GoRangeable)** — Go reference (`go get github.com/ZhgChgLi/GoRangeable`).
 - **[ZMediumToMarkdown](https://github.com/ZhgChgLi/ZMediumToMarkdown)** — real-world consumer that exercises this gem on Medium GraphQL renderers.
 
 ## Development

data/lib/rangeable/disjoint_set.rb

@@ -13,10 +13,13 @@ class Rangeable
   #
   # `insert` follows RFC §6.1 cleaner variant (containment idempotent
   # fast-path) and signals to the caller whether the mutation actually
-  # changed the canonical state.
+  # changed the canonical state. `remove` follows RFC §6.6 with the same
+  # mutated-vs-idempotent distinction (both use the same return symbols so
+  # the upstream `Rangeable` only writes one version-bump branch).
   class DisjointSet
-    # Result codes returned from `insert`. The caller (Rangeable) uses these
-    # to decide whether to bump the container-level version counter.
+    # Result codes returned from `insert` / `remove_subrange`. The caller
+    # (Rangeable) uses these to decide whether to bump the container-level
+    # version counter.
     MUTATED    = :mutated
     IDEMPOTENT = :idempotent
 
@@ -42,6 +45,14 @@ class Rangeable
       @entries.size
     end
 
+    # Read-only access to the underlying Array<Interval>. Returned reference
+    # is the live storage — callers that mutate it violate (I1). Used by the
+    # set-op two-pointer sweeps in `Rangeable` to avoid an Array allocation
+    # on every union/intersect/difference call.
+    def entries
+      @entries
+    end
+
     # Insert `[lo, hi]` into the set, performing union-with-merge per RFC §6.1.
     # Returns `MUTATED` if the canonical state changed (caller should bump
     # version), `IDEMPOTENT` if the insert was absorbed by an existing entry
@@ -88,5 +99,177 @@ class Rangeable
       @entries.insert(i0, merged)
       MUTATED
     end
+
+    # Subtract `[start_, end_]` from the set (§6.6 sweep+splice). Returns
+    # `MUTATED` if any entry was changed; `IDEMPOTENT` if no overlap.
+    # Caller is responsible for the eager-prune (§4.10 N1) check via `empty?`.
+    def remove_subrange(start_, end_)
+      raise ArgumentError, "lo (#{start_}) > hi (#{end_})" if start_ > end_
+
+      # Step 3 of §6.6: leftmost entry where `iv.hi >= start_`. Strict
+      # overlap; adjacency does NOT subtract anything.
+      i = @entries.bsearch_index { |iv| iv.hi >= start_ } || @entries.size
+
+      # Step 4: quick-exit. Either no entry crosses or past the cut window.
+      return IDEMPOTENT if i == @entries.size || @entries[i].lo > end_
+
+      # Step 5: sweep all overlapping entries; produce 0..2 residuals each.
+      to_replace_start = i
+      replacements = []
+      while i < @entries.size && @entries[i].lo <= end_
+        iv = @entries[i]
+        # Left residual exists iff iv.lo < start_; underflow-safe since
+        # start_ > iv.lo >= Int.min ⇒ start_ - 1 well-defined (§6.6).
+        replacements << Interval.new(iv.lo, start_ - 1) if iv.lo < start_
+        # Right residual exists iff end_ < iv.hi; overflow-safe since
+        # end_ < iv.hi <= Int.max ⇒ end_ + 1 well-defined.
+        replacements << Interval.new(end_ + 1, iv.hi) if end_ < iv.hi
+        i += 1
+      end
+      to_replace_end = i
+
+      # Step 6/7: splice. `slice!` then `insert` mirrors the reference
+      # `replace_subrange` and avoids quadratic shifts.
+      @entries.slice!(to_replace_start, to_replace_end - to_replace_start)
+      @entries.insert(to_replace_start, *replacements) unless replacements.empty?
+      MUTATED
+    end
+
+    # Replace the live entries with the given (I1)-canonical list. Used by
+    # set-op pipelines that compute the canonical result list externally
+    # (e.g. `merge_disjoint_lists`) and want to drop it in without re-running
+    # `insert`. Caller MUST guarantee the list satisfies (I1.1)–(I1.3); we
+    # do not re-verify (this is the internal hot path).
+    def replace_entries(new_entries)
+      @entries = new_entries
+    end
+
+    # Build a new DisjointSet directly from a known-canonical Array<Interval>.
+    # Used by set-op result construction; bypasses the `insert` cost path.
+    def self.from_entries(entries)
+      ds = new
+      ds.replace_entries(entries.dup)
+      ds
+    end
+
+    # === Set-op primitives (RFC §6.10–§6.13) ===
+    #
+    # All three primitives take Array<Interval> inputs and return
+    # Array<Interval> outputs. They live here (rather than on Rangeable)
+    # because they operate on per-element interval lists, which is exactly
+    # the DisjointSet's domain.
+
+    # §6.10 union helper: merge two (I1)-canonical lists into one
+    # (I1)-canonical list via two-pointer sweep + adjacency-collapse.
+    # `O(|l1| + |l2|)`. Either input may be empty.
+    def self.merge_disjoint_lists(l1, l2)
+      out = []
+      i = 0
+      j = 0
+      n1 = l1.size
+      n2 = l2.size
+      while i < n1 && j < n2
+        if l1[i].lo <= l2[j].lo
+          append_or_merge(out, l1[i])
+          i += 1
+        else
+          append_or_merge(out, l2[j])
+          j += 1
+        end
+      end
+      while i < n1
+        append_or_merge(out, l1[i])
+        i += 1
+      end
+      while j < n2
+        append_or_merge(out, l2[j])
+        j += 1
+      end
+      out
+    end
+
+    # §6.11 intersect helper: pairwise intersection via two-pointer sweep.
+    # No adjacency-collapse needed (Lemma 6.11.A). `O(|l1| + |l2|)`.
+    def self.intersect_disjoint_lists(l1, l2)
+      out = []
+      i = 0
+      j = 0
+      n1 = l1.size
+      n2 = l2.size
+      while i < n1 && j < n2
+        a = l1[i]
+        b = l2[j]
+        lo = a.lo > b.lo ? a.lo : b.lo
+        hi = a.hi < b.hi ? a.hi : b.hi
+        out << Interval.new(lo, hi) if lo <= hi
+        if a.hi <= b.hi
+          i += 1
+        else
+          j += 1
+        end
+      end
+      out
+    end
+
+    # §6.12 difference helper: subtract every interval in `l_b` from every
+    # interval in `l_a`. Two-pointer "in-flight current" sweep. `O(|l_a| + |l_b|)`.
+    def self.subtract_disjoint_lists(l_a, l_b)
+      out = []
+      i = 0
+      j = 0
+      n_a = l_a.size
+      n_b = l_b.size
+      current_lo = nil
+      current_hi = nil
+      while i < n_a
+        if current_lo.nil?
+          current_lo = l_a[i].lo
+          current_hi = l_a[i].hi
+        end
+        # Skip l_b entries strictly before the current entry.
+        j += 1 while j < n_b && l_b[j].hi < current_lo
+
+        if j == n_b || l_b[j].lo > current_hi
+          # No more l_b cuts on this entry; commit and advance i.
+          out << Interval.new(current_lo, current_hi)
+          i += 1
+          current_lo = nil
+          current_hi = nil
+          next
+        end
+
+        # l_b[j] overlaps [current_lo, current_hi]; cut.
+        # Left residual: (current_lo, l_b[j].lo - 1). Underflow-safe: only
+        # taken when l_b[j].lo > current_lo, so l_b[j].lo > Int.min.
+        out << Interval.new(current_lo, l_b[j].lo - 1) if l_b[j].lo > current_lo
+        if l_b[j].hi < current_hi
+          # Right residual remains as the new current; advance j.
+          # Overflow-safe: l_b[j].hi < current_hi ≤ Int.max.
+          current_lo = l_b[j].hi + 1
+          j += 1
+        else
+          # l_b[j] swallows the rest of the current entry; advance i.
+          i += 1
+          current_lo = nil
+          current_hi = nil
+        end
+      end
+      out
+    end
+
+    # @api private
+    # Helper for `merge_disjoint_lists`: append `iv` to `out`, collapsing
+    # if it overlaps or is integer-adjacent to `out.last`.
+    def self.append_or_merge(out, iv)
+      if out.empty? || out.last.hi + 1 < iv.lo
+        out << iv
+      else
+        # Overlap or adjacency: extend the last entry's hi if needed.
+        last = out.last
+        if iv.hi > last.hi
+          out[-1] = Interval.new(last.lo, iv.hi)
+        end
+      end
+    end
   end
 end

data/lib/rangeable/version.rb

@@ -5,5 +5,5 @@
 # alone (e.g. from the gemspec) does not lock the symbol into being a
 # module.
 class Rangeable
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/lib/rangeable.rb

@@ -189,8 +189,321 @@ class Rangeable
     end
   end
 
+  # ===========================================================================
+  # v2 Removal API (RFC §6.6–§6.9, §4.10 eager-pruning)
+  # ===========================================================================
+
+  # Remove the closed interval `[start_, end_]` from `R(element)`. RFC §6.6.
+  # Splits an entry if the cut lies strictly inside it. Idempotent (no-op,
+  # no version bump) when `element` is absent or no entry overlaps the cut
+  # window. Eagerly prunes `element` if its `R(e)` becomes empty (§4.10 N1).
+  def remove(element, start:, end:)
+    end_ = binding.local_variable_get(:end)
+    raise InvalidIntervalError, "start (#{start}) > end (#{end_})" if start > end_
+
+    set = @intervals[element]
+    return self if set.nil?  # §4.10 (N3): no R(e) ⇒ no-op, no bump.
+
+    result = set.remove_subrange(start, end_)
+    return self if result == DisjointSet::IDEMPOTENT
+
+    # Eager pruning (§4.10 N1) when R(e) is now ∅.
+    excise_element(element) if set.empty?
+
+    @version += 1
+    @event_index = nil
+    self
+  end
+
+  # Fully remove `element` from the container. RFC §6.7. Idempotent on a
+  # never-inserted element. Eagerly excises and densely renumbers `ord`.
+  def remove_element(element)
+    # Hash#delete returns the deleted value or nil. nil ⇒ key absent ⇒
+    # no-op per §4.10 (N3); MUST NOT bump version.
+    return self unless @intervals.delete(element)
+
+    idx = @insertion_order.index(element)
+    @insertion_order.delete_at(idx)
+    @ord.delete(element)
+    # Renumber ord densely for elements that moved up by one position.
+    (idx...@insertion_order.length).each do |k|
+      @ord[@insertion_order[k]] = k + 1
+    end
+
+    @version += 1
+    @event_index = nil
+    self
+  end
+  alias delete remove_element
+
+  # Reset the container to its empty state. RFC §6.8. Idempotent on an
+  # already-empty container (no version bump).
+  def clear
+    return self if @insertion_order.empty?  # §4.10 (N3) idempotence.
+
+    @intervals       = {}
+    @insertion_order = []
+    @ord             = {}
+    @version += 1
+    @event_index = nil
+    self
+  end
+  alias remove_all clear
+
+  # Subtract `[start_, end_]` from every element's `R(e)`. RFC §6.9.
+  # Atomic: at most one version bump for the entire op. Eagerly prunes
+  # any element whose `R(e)` becomes empty. No-op (no bump) if no element
+  # overlaps the cut window.
+  def remove_ranges(start:, end:)
+    end_ = binding.local_variable_get(:end)
+    raise InvalidIntervalError, "start (#{start}) > end (#{end_})" if start > end_
+
+    any_change = false
+    # Iterate a snapshot of @insertion_order: we may delete from @intervals
+    # mid-loop. We do NOT mutate @insertion_order in this loop — the §6.9
+    # pseudocode defers the rebuild to step 4 to avoid O(E²) delete_at cost.
+    @insertion_order.each do |element|
+      set = @intervals[element]
+      result = set.remove_subrange(start, end_)
+      next if result == DisjointSet::IDEMPOTENT
+
+      any_change = true
+      @intervals.delete(element) if set.empty?
+    end
+
+    return self unless any_change  # §4.10 (N3) no-op.
+
+    # Step 4: single-pass rebuild of insertion_order and dense ord.
+    @insertion_order = @insertion_order.select { |e| @intervals.key?(e) }
+    @ord = {}
+    @insertion_order.each_with_index { |e, k| @ord[e] = k + 1 }
+
+    @version += 1
+    @event_index = nil
+    self
+  end
+
+  # ===========================================================================
+  # v2 Set Operations API (RFC §6.10–§6.13)
+  # ===========================================================================
+
+  # Per-element `R_self(e) ∪ R_other(e)`. Returns a fresh `Rangeable` with
+  # `version == 0`. Insertion-order rule: preserve `self`'s, tail-append
+  # keys ∈ `other` ∖ `self` in `other`'s insertion-order order. RFC §6.10.
+  def union(other)
+    raise ArgumentError, "expected Rangeable, got #{other.class}" unless other.is_a?(Rangeable)
+
+    out = self.class.new
+
+    # Step 1: walk self's insertion_order; merge with other if shared key.
+    @insertion_order.each do |element|
+      list_self  = @intervals[element].entries
+      other_set  = other.send(:intervals_internal)[element]
+      list_other = other_set ? other_set.entries : EMPTY_ACTIVE
+      merged = DisjointSet.merge_disjoint_lists(list_self, list_other)
+      # length(merged) > 0 is guaranteed because list_self is non-empty (I1.4).
+      out.send(:install_element, element, DisjointSet.from_entries(merged))
+    end
+
+    # Step 2: tail-append keys ∈ other ∖ self in other's insertion order.
+    other.send(:insertion_order_internal).each do |element|
+      next if @intervals.key?(element)
+
+      other_entries = other.send(:intervals_internal)[element].entries
+      out.send(:install_element, element, DisjointSet.from_entries(other_entries.dup))
+    end
+
+    out
+  end
+  alias_method :|, :union
+
+  # Per-element `R_self(e) ∩ R_other(e)` for keys in both. Empty results
+  # are eagerly pruned (§4.10). Insertion-order: preserve self's order over
+  # surviving keys. RFC §6.11.
+  def intersect(other)
+    raise ArgumentError, "expected Rangeable, got #{other.class}" unless other.is_a?(Rangeable)
+
+    out = self.class.new
+
+    @insertion_order.each do |element|
+      other_set = other.send(:intervals_internal)[element]
+      next unless other_set  # not in other ⇒ drop.
+
+      list_self  = @intervals[element].entries
+      list_other = other_set.entries
+      intersected = DisjointSet.intersect_disjoint_lists(list_self, list_other)
+      next if intersected.empty?  # eager prune.
+
+      out.send(:install_element, element, DisjointSet.from_entries(intersected))
+    end
+
+    out
+  end
+  alias_method :&, :intersect
+  alias intersection intersect
+
+  # Per-element `R_self(e) ∖ R_other(e)`. Empty results eagerly pruned.
+  # Insertion-order: preserve self's order over surviving keys. RFC §6.12.
+  def difference(other)
+    raise ArgumentError, "expected Rangeable, got #{other.class}" unless other.is_a?(Rangeable)
+
+    out = self.class.new
+
+    @insertion_order.each do |element|
+      list_self = @intervals[element].entries
+      other_set = other.send(:intervals_internal)[element]
+      remaining =
+        if other_set.nil? || other_set.empty?
+          list_self.dup
+        else
+          DisjointSet.subtract_disjoint_lists(list_self, other_set.entries)
+        end
+      next if remaining.empty?  # eager prune.
+
+      out.send(:install_element, element, DisjointSet.from_entries(remaining))
+    end
+
+    out
+  end
+  alias_method :-, :difference
+  alias subtract difference
+
+  # Per-element `R_self(e) △ R_other(e) = (self∖other) ∪ (other∖self)`.
+  # Empty results eagerly pruned. Insertion-order: preserve self's order
+  # for `e ∈ keys(self)`; tail-append `e ∈ keys(other) ∖ keys(self)` in
+  # other's order. RFC §6.13.
+  #
+  # `merge_disjoint_lists` (NOT sorted concat) is required because the two
+  # one-sided residuals can be integer-adjacent (RFC §10.B Test #34 worked
+  # example: `R_self=[(0,5)], R_other=[(6,10)]` ⇒ a=[(0,5)], b=[(6,10)],
+  # adjacent at 5+1==6, must collapse to [(0,10)]).
+  def symmetric_difference(other)
+    raise ArgumentError, "expected Rangeable, got #{other.class}" unless other.is_a?(Rangeable)
+
+    out = self.class.new
+
+    # Step 1: self-primary keys.
+    @insertion_order.each do |element|
+      list_self  = @intervals[element].entries
+      other_set  = other.send(:intervals_internal)[element]
+      list_other = other_set ? other_set.entries : EMPTY_ACTIVE
+      a = DisjointSet.subtract_disjoint_lists(list_self,  list_other)
+      b = DisjointSet.subtract_disjoint_lists(list_other, list_self)
+      sym = DisjointSet.merge_disjoint_lists(a, b)
+      next if sym.empty?  # eager prune.
+
+      out.send(:install_element, element, DisjointSet.from_entries(sym))
+    end
+
+    # Step 2: other-only keys.
+    other.send(:insertion_order_internal).each do |element|
+      next if @intervals.key?(element)
+
+      other_entries = other.send(:intervals_internal)[element].entries
+      next if other_entries.empty?  # defensive; (I1.4) makes this unreachable.
+
+      out.send(:install_element, element, DisjointSet.from_entries(other_entries.dup))
+    end
+
+    out
+  end
+  alias_method :^, :symmetric_difference
+
+  # ---------------------------------------------------------------------------
+  # Mutating set ops (Ruby `!` convention). All four ALWAYS return self for
+  # chain-friendliness. Each bumps `version` exactly once iff the result
+  # differs structurally from `self` (per §6.10–§6.13 idempotence dual).
+  # Implementation strategy: build the new container via the non-mutating
+  # form (copy-then-swap), then compare to self. If structurally identical,
+  # discard and skip the bump.
+  # ---------------------------------------------------------------------------
+
+  def union!(other)
+    swap_with(union(other))
+  end
+
+  def intersect!(other)
+    swap_with(intersect(other))
+  end
+  alias intersection! intersect!
+
+  def difference!(other)
+    swap_with(difference(other))
+  end
+  alias subtract! difference!
+
+  def symmetric_difference!(other)
+    swap_with(symmetric_difference(other))
+  end
+
   private
 
+  # Internal accessor for set-op fast paths — exposed via `send` so the
+  # public surface stays clean. Returns the live @intervals Hash.
+  def intervals_internal
+    @intervals
+  end
+
+  def insertion_order_internal
+    @insertion_order
+  end
+
+  # Splice an already-canonical DisjointSet into this container under
+  # `element`. Used by set-op result construction. Caller MUST guarantee
+  # the element is not already a key (we tail-append to insertion_order).
+  def install_element(element, set)
+    @intervals[element]   = set
+    @insertion_order      << element
+    @ord[element]         = @insertion_order.length
+  end
+
+  # Excise an element from all three element-keyed structures and densely
+  # renumber `ord` for the survivors at positions ≥ idx. Used by §6.6
+  # eager-prune path.
+  def excise_element(element)
+    @intervals.delete(element)
+    idx = @insertion_order.index(element)
+    @insertion_order.delete_at(idx)
+    @ord.delete(element)
+    (idx...@insertion_order.length).each do |k|
+      @ord[@insertion_order[k]] = k + 1
+    end
+  end
+
+  # In-place swap helper for the mutating set-op variants. Compares the
+  # candidate result `other` to `self` structurally; if equal, no-op (no
+  # version bump). Otherwise replaces all element-keyed state with `other`'s
+  # contents and bumps version exactly once. Always returns self.
+  def swap_with(other)
+    return self if structurally_equal?(other)
+
+    @intervals       = other.send(:intervals_internal)
+    @insertion_order = other.send(:insertion_order_internal)
+    @ord             = other.send(:ord_internal)
+    @version += 1
+    @event_index = nil
+    self
+  end
+
+  # Internal accessor so `swap_with` can read the candidate's ord map.
+  def ord_internal
+    @ord
+  end
+
+  # Structural-equality test for the swap fast-path: same insertion order
+  # AND per-element same canonical entries. Used by mutating set ops to
+  # honor the §3.2 idempotence dual ("no bump if result == self").
+  def structurally_equal?(other)
+    return false unless @insertion_order == other.send(:insertion_order_internal)
+
+    other_intervals = other.send(:intervals_internal)
+    @insertion_order.all? do |e|
+      a = @intervals[e].entries
+      b = other_intervals[e].entries
+      a.size == b.size && a.zip(b).all? { |x, y| x.lo == y.lo && x.hi == y.hi }
+    end
+  end
+
   # RFC §4.6 (M2): freeze on insert as cheap defence against caller-side
   # mutation of hash-affecting state. We try to dup-then-freeze; if `dup`
   # is not supported (some Symbol-like cases) we fall back to the original.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rangeable
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - ZhgChgLi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-09 00:00:00.000000000 Z
+date: 2026-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest