brute 4.1.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 428a37a7f0f2e0930d1b0c901fc75606686c25e07046b54c6dc4964fbbb88433
-  data.tar.gz: 33f0b4a2956004b7e4d26790f981718fea46d2ae7cf1f54deaea250a7951edaf
+  metadata.gz: 6016495cc66cb0d8c5b7b33aaef14eee694960355bb2d772c2d75b1aaacca844
+  data.tar.gz: 137446fd33a37736993e2d067d75169d8ca1ce83c109511054b73e768550fda5
 SHA512:
-  metadata.gz: 7c382ae2d9229bdd7524cbdb87614f94b8c54e25ae2f76ee68892198bcf8d901d35398b3555f712b07253f17c3dddd1d8d66907c44ff9eaa28dd5adca3441582
-  data.tar.gz: 1c3816fff0d6664a25a9bfcb0c44df62c6833c2ba5066b3cbec0772fd24ea1ab4e078b7e1faca3f577297842fdd92c3aca59368f376993ba88956aaf3c02d500
+  metadata.gz: 4098f01a58d7d6946fb4f362aab7d37db86cb1f6e77def51f96e08b86eddbaa8c5462e8a613d9e74ff84731baf5ed65076abd010c2ab854b5e838279b3801ee3
+  data.tar.gz: 25c4986d4beed8103eb6c0f527ad737b98de3f7c3d1e562c83f956afcc3b3267eb5c6cb669ac488cf9ffdf97c6a446888f9363a2d01bd6f3913701d7cc46c313

data/lib/brute/changelog.rb

@@ -2,7 +2,7 @@
 
 require "date"
 
-require_relative "deprecate"
+require "gem_kit"
 
 module Brute
   # A parser and linter for CHANGELOG.md, which follows
@@ -34,8 +34,8 @@ module Brute
     # Deprecated. This moved out to the gem_kit-release gem, where the rest of
     # the release toolchain now lives — `gem kit changelog` is the CLI over it.
     # The implementation stays here, working, until the deadline.
-    extend Brute::Deprecate
-    brute_deprecate_constant "GemKit::Release::Changelog", "5.0"
+    extend GemKit::Deprecate
+    superseded_by "GemKit::Release::Changelog", "5.0"
 
     # The six change types Keep a Changelog defines. Anything else under a
     # version is a typo or an invention, and both are worth catching.

data/lib/brute/deprecate.rb

@@ -1,190 +1,91 @@
 # frozen_string_literal: true
 
-require "rubygems/deprecate"
-
-# gem_kit-release is a *development* dependency: the release tooling reads the
-# registry below, but the library itself must not depend on release tooling to
-# load. So mirror into its registry when it happens to be there, and carry on
-# when it is not.
-begin
-  require "gem_kit/release/deprecate"
-rescue LoadError
-  # Not installed — this is a normal production install of Brute.
-end
+require "gem_kit"
 
 module Brute
-  # Brute's deprecation policy, built on Gem::Deprecate.
-  #
-  # Rubygems' own convention is the one worth copying: a deprecation names its
-  # replacement and the *version it will be removed in*, so "deprecated" is a
-  # dated promise rather than an open-ended apology. Brute adds one thing on
-  # top — a registry. Every declaration records itself, which turns the set of
-  # outstanding deprecations into data the tooling can act on:
-  #
-  #   bin/deprecations             # list everything still outstanding
-  #   bin/increment-version major  # refuses to bump past a removal deadline
-  #
-  # Deprecate a method:
+  # Deprecated. This is [`GemKit::Deprecate`](https://rubygems.org/gems/gem_kit)
+  # now — the same code, extracted so that other gems could use it, and so that
+  # `gem kit deprecations` could read one registry rather than two.
   #
-  #   class Session
-  #     extend Brute::Deprecate
+  #   extend Brute::Deprecate     ->  extend GemKit::Deprecate
+  #   brute_deprecate             ->  deprecate
+  #   brute_deprecate_constant    ->  superseded_by
   #
-  #     def old_reset; new_reset; end
-  #     brute_deprecate :old_reset, "Session#new_reset", "5.0"
-  #   end
-  #
-  # Deprecate a whole class — a renamed or moved constant. Leave the old name
-  # in place as a subclass of the new one, then declare it:
-  #
-  #   class Completion < Brute::Completion::OpenRouter
-  #     extend Brute::Deprecate
-  #     brute_deprecate_constant "Brute::Completion::OpenRouter", "5.0"
-  #   end
-  #
-  # Both warn on use, naming the caller. Gem::Deprecate.skip_during { ... }
-  # silences them, so a test suite can exercise the old path in quiet.
+  # Extending this module still works and still registers: it warns, then
+  # extends GemKit::Deprecate for you and aliases the old method names onto the
+  # new ones. It will stop working in 5.0.
   module Deprecate
-    extend Gem::Deprecate
-
-    # One outstanding deprecation. `removed_in` is the version the old name
-    # stops existing in — the deadline both CLI commands read.
-    Entry = Struct.new(:name, :replacement, :removed_in, :declared_at, keyword_init: true) do
-      def to_s
-        "#{name} -> #{replacement == :none ? "(no replacement)" : replacement}"
-      end
-    end
-
-    class << self
-      # Every deprecation declared in the loaded library, in declaration order.
-      def registry
-        @registry ||= []
-      end
-
-      # Record a deprecation. Returns the Entry.
-      def register(name:, replacement:, removed_in:, declared_at: nil)
-        entry = Entry.new(
-          name:        name.to_s,
-          replacement: replacement,
-          removed_in:  Gem::Version.new(removed_in.to_s),
-          declared_at: declared_at || caller_locations(1, 1)&.first&.then { |l| "#{l.path}:#{l.lineno}" },
-        )
-        registry << entry
-
-        # Same shape (name, replacement, removed_in, declared_at), so
-        # `gem kit deprecations` can read Brute's entries directly.
-        if defined?(::GemKit::Release::Deprecate)
-          ::GemKit::Release::Deprecate.registry << entry
-        end
-
-        entry
-      end
-
-      # The deprecations that come due at `version` — everything whose removal
-      # deadline has arrived or passed. This is the gate: releasing `version`
-      # with any of these still present breaks the promise the warning made.
-      def pending(version)
-        target = Gem::Version.new(version.to_s)
-        registry.select { |entry| entry.removed_in <= target }
-      end
-
-      # Deprecations still in their grace period at `version`.
-      def upcoming(version)
-        target = Gem::Version.new(version.to_s)
-        registry.reject { |entry| entry.removed_in <= target }
-      end
-
-      # The default deadline: the next major version after the current one.
-      def next_major_version
-        Gem::Version.new(Brute::VERSION.split(".").first).bump.to_s
-      end
-
-      # Single funnel for every warning, so Gem::Deprecate.skip_during works
-      # across all of them and specs have one place to listen.
-      def warn(message)
-        Kernel.warn(message) unless Gem::Deprecate.skip
-      end
-
-      # Build the Gem::Deprecate-shaped message body. `origin` must be
-      # computed at the call site — one frame deeper and it names this file
-      # rather than the code that needs changing.
-      def message(target, replacement, removed_in, origin)
-        [
-          "NOTE: #{target} is deprecated",
-          replacement == :none ? " with no replacement" : "; use #{replacement} instead",
-          ". It will be removed in Brute #{removed_in}",
-          "\n#{target} called from #{origin}.",
-        ].join
-      end
-    end
-
-    # Deprecate one method. Mirrors Gem::Deprecate#rubygems_deprecate, but the
-    # deadline is explicit rather than "the next major" — a deprecation added
-    # late in a cycle usually wants the major after next.
-    def brute_deprecate(name, replacement = :none, removed_in = Brute::Deprecate.next_major_version)
-      label = singleton_class? ? "#{attached_object}.#{name}" : "#{self}##{name}"
-      Brute::Deprecate.register(
-        name:        label,
-        replacement: replacement,
-        removed_in:  removed_in,
-        declared_at: caller_locations(1, 1)&.first&.then { |l| "#{l.path}:#{l.lineno}" },
+    REPLACEMENT = "GemKit::Deprecate"
+    REMOVED_IN  = "5.0"
+
+    # The names Brute used before the extraction. `deprecate` collides with
+    # Gem::Deprecate's own, which is why Brute's carried a prefix; GemKit's
+    # namespace does that job instead.
+    ALIASES = { brute_deprecate: :deprecate, brute_deprecate_constant: :superseded_by }.freeze
+
+    def self.extended(base)
+      origin = Gem.location_of_caller.join(":")
+      GemKit::Deprecate.warn(
+        GemKit::Deprecate.message("Brute::Deprecate", REPLACEMENT, REMOVED_IN, origin),
       )
 
-      class_eval do
-        old = "_deprecated_#{name}"
-        alias_method old, name
-        define_method name do |*args, &block|
-          target = is_a?(Module) ? "#{self}.#{name}" : "#{self.class}##{name}"
-          origin = Gem.location_of_caller.join(":")
-          Brute::Deprecate.warn(Brute::Deprecate.message(target, replacement, removed_in, origin))
-          send(old, *args, &block)
-        end
-        ruby2_keywords name if respond_to?(:ruby2_keywords, true)
-      end
+      base.extend(GemKit::Deprecate)
+      ALIASES.each { |old, new| base.singleton_class.alias_method(old, new) }
     end
 
-    # Deprecate a whole constant — the renamed-or-moved case. Call it in the
-    # body of the old name (kept as a subclass of the new one); it registers
-    # the rename and warns whenever the old name is instantiated.
-    def brute_deprecate_constant(replacement, removed_in = Brute::Deprecate.next_major_version)
-      Brute::Deprecate.register(
-        name:        name || to_s,
-        replacement: replacement,
-        removed_in:  removed_in,
-        declared_at: caller_locations(1, 1)&.first&.then { |l| "#{l.path}:#{l.lineno}" },
-      )
-
-      return unless respond_to?(:new)
-
-      define_singleton_method(:new) do |*args, **options, &block|
-        origin = Gem.location_of_caller.join(":")
-        Brute::Deprecate.warn(Brute::Deprecate.message(name || to_s, replacement, removed_in, origin))
-        super(*args, **options, &block)
-      end
+    # The registry moved with the DSL. Delegated rather than mirrored: two
+    # registries meant two answers to "what is still outstanding".
+    class << self
+      def registry            = GemKit::Deprecate.registry
+      def pending(version)    = GemKit::Deprecate.pending(version)
+      def upcoming(version)   = GemKit::Deprecate.upcoming(version)
+      def register(...)       = GemKit::Deprecate.register(...)
+      def warn(message)       = GemKit::Deprecate.warn(message)
     end
   end
 end
 
+# The module itself is deprecated, and a module cannot announce that the way a
+# class can — there is no `new` to wrap. Registering it by hand is what puts it
+# in `gem kit deprecations` alongside everything else.
+GemKit::Deprecate.register(
+  name:        "Brute::Deprecate",
+  replacement: Brute::Deprecate::REPLACEMENT,
+  removed_in:  Brute::Deprecate::REMOVED_IN,
+  declared_at: "#{__FILE__}:#{__LINE__ - 5}",
+)
+
 __END__
 
 describe "brute/deprecate" do
-  # Capture what Brute::Deprecate.warn emits, and keep the shared registry
-  # clean — these specs declare throwaway deprecations.
   captured = []
-  around_each = lambda do |&block|
-    saved = Brute::Deprecate.registry.dup
-    original = Brute::Deprecate.method(:warn)
+  # Capture what the shim emits, and keep the shared registry clean.
+  isolated = lambda do |&block|
+    saved    = GemKit::Deprecate.registry.dup
+    original = GemKit::Deprecate.method(:warn)
     captured.clear
-    Brute::Deprecate.define_singleton_method(:warn) { |message| captured << message }
+    GemKit::Deprecate.define_singleton_method(:warn) { |message| captured << message }
     begin
       block.call
     ensure
-      Brute::Deprecate.define_singleton_method(:warn, original)
-      Brute::Deprecate.registry.replace(saved)
+      GemKit::Deprecate.define_singleton_method(:warn, original)
+      GemKit::Deprecate.registry.replace(saved)
+    end
+  end
+
+  it "warns when extended, naming GemKit::Deprecate" do
+    isolated.call do
+      Class.new { extend Brute::Deprecate }
+
+      captured.size.should == 1
+      captured.first.should.match(/Brute::Deprecate is deprecated/)
+      captured.first.should.match(/use GemKit::Deprecate instead/)
+      captured.first.should.match(/removed in 5\.0/)
     end
   end
 
-  it "warns on a deprecated method, naming the replacement, version and caller" do
-    around_each.call do
+  it "still declares a method deprecation under the old name" do
+    isolated.call do
       klass = Class.new do
         extend Brute::Deprecate
         def new_name = :result
@@ -192,17 +93,13 @@ describe "brute/deprecate" do
         brute_deprecate :old_name, "Thing#new_name", "9.0"
       end
 
-      klass.new.old_name.should == :result   # still works
-      captured.size.should == 1
-      captured.first.should.match(/is deprecated/)
-      captured.first.should.match(/use Thing#new_name instead/)
-      captured.first.should.match(/removed in Brute 9\.0/)
-      captured.first.should.match(/called from /)
+      klass.new.old_name.should == :result
+      GemKit::Deprecate.registry.last.replacement.should == "Thing#new_name"
     end
   end
 
-  it "warns on a deprecated constant but keeps it working" do
-    around_each.call do
+  it "still declares a constant deprecation under the old name" do
+    isolated.call do
       modern = Class.new { def initialize(x); @x = x; end; attr_reader :x }
       legacy = Class.new(modern) do
         extend Brute::Deprecate
@@ -210,116 +107,26 @@ describe "brute/deprecate" do
         brute_deprecate_constant "New::Name", "9.0"
       end
 
-      legacy.new(42).x.should == 42          # still works
-      captured.size.should == 1
-      captured.first.should.match(/Old::Name is deprecated; use New::Name instead/)
-    end
-  end
-
-  it "names the caller, not the deprecation machinery" do
-    around_each.call do
-      klass = Class.new do
-        extend Brute::Deprecate
-        def old_name = :result
-        brute_deprecate :old_name, "Thing#new_name", "9.0"
-      end
-
-      # These specs live in this file's __END__, so "the caller" is a line in
-      # deprecate.rb either way — pin the exact line to tell them apart.
-      klass.new.old_name; call_line = __LINE__
-      captured.first.should.match(/called from .*deprecate\.rb:#{call_line}\./)
-    end
-  end
-
-  it "labels a class-method deprecation by the class, not its singleton" do
-    around_each.call do
-      Class.new do
-        def self.to_s = "Demo"
-        def self.old_thing = :ok
-        class << self
-          extend Brute::Deprecate
-          brute_deprecate :old_thing, "Other.new_thing", "9.0"
-        end
-      end
-
-      Brute::Deprecate.registry.last.name.should == "Demo.old_thing"
-    end
-  end
-
-  it "registers each declaration with its deadline and source" do
-    around_each.call do
-      Class.new do
-        extend Brute::Deprecate
-        def gone = nil
-        brute_deprecate :gone, "Other#kept", "9.0"
-      end
-
-      entry = Brute::Deprecate.registry.last
-      entry.replacement.should == "Other#kept"
-      entry.removed_in.should == Gem::Version.new("9.0")
-      entry.declared_at.should.match(/deprecate\.rb:\d+/)
-    end
-  end
-
-  it "mirrors registrations into gem_kit-release's registry when it is present" do
-    # Conditional by design: gem_kit-release is a development dependency, so
-    # in a production install of Brute there is nothing to mirror into. (Also
-    # true inside a pre-commit hook, whose flake snapshot is HEAD's.)
-    next unless defined?(::GemKit::Release::Deprecate)
-
-    around_each.call do
-      saved = GemKit::Release::Deprecate.registry.dup
-      begin
-        Brute::Deprecate.register(name: "Mirrored", replacement: "New", removed_in: "9.0")
-
-        GemKit::Release::Deprecate.registry.last.name.should == "Mirrored"
-        GemKit::Release::Deprecate.registry.last.removed_in.should == Gem::Version.new("9.0")
-      ensure
-        GemKit::Release::Deprecate.registry.replace(saved)
-      end
+      legacy.new(42).x.should == 42
+      GemKit::Deprecate.registry.last.name.should == "Old::Name"
     end
   end
 
-  it "splits the registry into pending (due) and upcoming at a version" do
-    around_each.call do
-      Brute::Deprecate.registry.clear
-      Brute::Deprecate.register(name: "A", replacement: "A2", removed_in: "5.0")
-      Brute::Deprecate.register(name: "B", replacement: "B2", removed_in: "6.0")
-
-      Brute::Deprecate.pending("5.0.0").map(&:name).should == ["A"]
-      Brute::Deprecate.upcoming("5.0.0").map(&:name).should == ["B"]
-      Brute::Deprecate.pending("4.9.0").should.be.empty
-      Brute::Deprecate.pending("6.1.0").map(&:name).should == ["A", "B"]
-    end
-  end
+  it "delegates the registry rather than keeping one of its own" do
+    isolated.call do
+      Brute::Deprecate.registry.should.equal?(GemKit::Deprecate.registry)
 
-  it "defaults the deadline to the next major version" do
-    around_each.call do
-      Brute::Deprecate.next_major_version.should == Gem::Version.new(Brute::VERSION.split(".").first).bump.to_s
+      GemKit::Deprecate.register(name: "A", replacement: "A2", removed_in: "5.0")
+      Brute::Deprecate.pending("5.0.0").map(&:name).should.include?("A")
+      Brute::Deprecate.upcoming("4.0.0").map(&:name).should.include?("A")
     end
   end
 
-  it "stays quiet inside Gem::Deprecate.skip_during" do
-    saved = Brute::Deprecate.registry.dup
-    begin
-      klass = Class.new do
-        extend Brute::Deprecate
-        def quiet = :ok
-        brute_deprecate :quiet, "Other#loud", "9.0"
-      end
-
-      warned = []
-      original = Kernel.method(:warn)
-      Kernel.define_singleton_method(:warn) { |*args| warned << args.join }
-      begin
-        Gem::Deprecate.skip_during { klass.new.quiet.should == :ok }
-      ensure
-        Kernel.define_singleton_method(:warn, original)
-      end
+  it "registers itself, so `gem kit deprecations` lists it" do
+    entry = GemKit::Deprecate.registry.find { |e| e.name == "Brute::Deprecate" }
 
-      warned.should.be.empty
-    ensure
-      Brute::Deprecate.registry.replace(saved)
-    end
+    entry.should.not.be.nil
+    entry.replacement.should == "GemKit::Deprecate"
+    entry.removed_in.should == Gem::Version.new("5.0")
   end
 end

data/lib/brute/middleware/open_router.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "../deprecate"
+require "gem_kit"
+
 require_relative "../completion/open_router"
 
 module Brute
@@ -13,10 +14,10 @@ module Brute
       #   Brute::Middleware::OpenRouter::Completion  ->  Brute::Completion::OpenRouter
       #
       # The old name stays a working subclass of the new one until the deadline
-      # below; see Brute::Deprecate and `bin/deprecations`.
+      # below; see DEPRECATIONS.md and `gem kit deprecations`.
       class Completion < Brute::Completion::OpenRouter
-        extend Brute::Deprecate
-        brute_deprecate_constant "Brute::Completion::OpenRouter", "5.0"
+        extend GemKit::Deprecate
+        superseded_by "Brute::Completion::OpenRouter", "5.0"
       end
     end
   end
@@ -33,22 +34,22 @@ describe "brute/middleware/open_router" do
 
   it "warns on use, naming the replacement and the removal version" do
     captured = []
-    original = Brute::Deprecate.method(:warn)
-    Brute::Deprecate.define_singleton_method(:warn) { |message| captured << message }
+    original = GemKit::Deprecate.method(:warn)
+    GemKit::Deprecate.define_singleton_method(:warn) { |message| captured << message }
     begin
       Brute::Middleware::OpenRouter::Completion.new(->(env) { env })
     ensure
-      Brute::Deprecate.define_singleton_method(:warn, original)
+      GemKit::Deprecate.define_singleton_method(:warn, original)
     end
 
     captured.size.should == 1
     captured.first.should.match(/Brute::Middleware::OpenRouter::Completion is deprecated/)
     captured.first.should.match(/use Brute::Completion::OpenRouter instead/)
-    captured.first.should.match(/removed in Brute 5\.0/)
+    captured.first.should.match(/removed in 5\.0/)
   end
 
   it "is registered with its removal deadline" do
-    entry = Brute::Deprecate.registry.find { |e| e.name == "Brute::Middleware::OpenRouter::Completion" }
+    entry = GemKit::Deprecate.registry.find { |e| e.name == "Brute::Middleware::OpenRouter::Completion" }
     entry.should.not.be.nil
     entry.removed_in.should == Gem::Version.new("5.0")
   end

data/lib/brute/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Brute
-  VERSION = "4.1.0"
+  VERSION = "4.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.2.0
 platform: ruby
 authors:
 - Brute Contributors
@@ -135,6 +135,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.34'
+- !ruby/object:Gem::Dependency
+  name: gem_kit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -183,14 +197,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 description: Production-grade coding agent with tool execution, middleware pipeline,
   context compaction, session persistence, and multi-provider LLM support.
 executables: []