power_assert 2.0.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f842260e6bea4e899b1e6af63144e7eda3ce9703788902893576890d61c1f6be
-  data.tar.gz: e1c53238ed0eb63702879ecedf209cbe5cea34ee8829d9ffb18af1694b2f8e26
+  metadata.gz: 705f51cc47d3a6d949df579d782c02ed246b1dc782794a1855a7bdd412ccbb63
+  data.tar.gz: 38ca48e3a3efccafce2c68715c592a62dd98d388925e5bb60088258deaa52273
 SHA512:
-  metadata.gz: d43ea1d5aa5c3e78defd497e9fda7077aae1f989d0e8b4428eb2fad5852559e597e27313b8867d665cc3c0c141a8ab56a3720c42075922d33b465d465a147481
-  data.tar.gz: 35a8335719afd408c219bb2838496fc0e438f404fdd1abf15147a28fd77d46ed32c6ef59a46caf55cf96ffbd0b03f20f277af37959d97b6510f77c9c73c952f0
+  metadata.gz: a8e8d18cca0c77c0bd0d9092ba167a3c3e99628516b053e37f4f218c9e512eef4c9d348f2ac00276841d0c9ee7470556f99382fd551e2231084f4cebdf052926
+  data.tar.gz: f665351eb5861e18676a17e7247c939cf59815df6692b64af1c5aabe4f1d303403ffe60341c940c7f304ffcec9c9596377b91f1c46007c9a51a04a0b24a78e84

data/.github/workflows/ci.yml

@@ -5,7 +5,7 @@ jobs:
     uses: ruby/actions/.github/workflows/ruby_versions.yml@master
     with:
       engine: cruby
-      min_version: 2.5
+      min_version: 3.1
   test:
     needs: ruby-versions
     name: >-
@@ -21,15 +21,12 @@ jobs:
             os: "ubuntu-latest"
             TEST_SYMLINK: yes
             rubyopt: "--enable-frozen-string-literal"
-        exclude:
-          - ruby-version: "2.5"
-            os: "macos-latest"
     runs-on: ${{ matrix.os }}
     env:
       TEST_SYMLINK: ${{ matrix.TEST_SYMLINK }}
     continue-on-error: ${{ matrix.ruby-version == 'head' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/Gemfile

@@ -12,8 +12,7 @@ group :development do
   gem 'test-unit'
   gem 'rake'
   gem 'simplecov'
-  gem 'bundler'
   gem 'irb', '>= 1.3.1'
-  gem 'byebug'
+  gem 'fiddle'
   gem 'benchmark-ips'
 end

data/README.md

@@ -20,79 +20,89 @@ Use following test frameworks or extensions instead.
 * [rspec-power_assert](https://github.com/joker1007/rspec-power_assert)
 * [rspec-matchers-power_assert_matchers](https://github.com/kachick/rspec-matchers-power_assert_matchers)
 * [pry-power_assert](https://github.com/yui-knk/pry-power_assert)
-* [pry-byebug-power_assert](https://github.com/k-tsj/pry-byebug-power_assert)
 * [irb-power_assert](https://github.com/kachick/irb-power_assert)
 * [power_p](https://github.com/k-tsj/power_p)
 
 ## Requirement
-* CRuby 2.5+
+* CRuby 3.1+
 
 ## Configuration
 To colorize output messages, add <code>require "power_assert/colorize"</code> to your code.
-(It requires CRuby 3.0.1+ or irb 1.3.1+)
+(It requires irb 1.3.1+)
 
 ## Known Limitations
-* Expressions must be put in one line. Expressions with folded long lines produce nothing report, e.g.:
+* Expressions must be on a single line. Splitting an assertion across multiple lines prevents any report from being generated, e.g.:
 
 ```ruby
 assert do
-  # reported
+  # Reported
   func(foo: 0123456789, bar: "abcdefg")
 end
 
 assert do
-  # won't be reported
+  # Not reported
   func(foo: 0123456789,
        bar: "abcdefg")
 end
 ```
 
-* Expressions must have one or more method call. Expressions with no method call produce nothing report, e.g.:
+* Expressions must include at least one method call. Assertions without method calls generate no report, e.g.:
 
 ```ruby
 val = false
 assert do
-  # reported
+  # Reported
   val == true
 end
 
 assert do
-  # won't be reported
+  # Not reported
   val
 end
 ```
 
-* Returned values from accessor methods, method missing, or "super" produce nothing report, e.g:
+* Return values from `method_missing` or `super` generate no report, e.g.:
 
 ```ruby
 class Foo
-  attr_accessor :val
+  def method_missing(*)
+    :foo
+  end
 end
 foo = Foo.new
-foo.val = false
 
 assert do
-  # reported (only the value of "foo" and the literal "true")
-  foo.val == true
-end
-
-assert do
-  # won't be reported
-  foo.val
+  # Not reported
+  foo.foo
 end
 ```
 
-* Expressions should not have conditional branches. Expressions with such conditional codes may produce nothing report, e.g.:
+* Avoid conditional branches inside assertions. Conditional logic may prevent a report from being generated, e.g.:
 
 ```ruby
 condition = true
 expected = false
 actual = true
 assert do
-  # this will fail but nothing reported
+  # This fails, but nothing is reported
   condition ? expected == actual : expected == actual
 end
 ```
 
+* (CRuby 4.0+) `<Struct subclass>.new` generates no report. Use `<Struct subclass>.[]` instead, e.g.:
+
+```ruby
+s = Struct.new(:a)
+assert do
+  # Not reported
+  s.new(0)
+end
+
+assert do
+  # Reported
+  s[0]
+end
+```
+
 ## Reference
 * [Power Assert in Ruby (at RubyKaigi 2014) // Speaker Deck](https://speakerdeck.com/k_tsj/power-assert-in-ruby)

data/Rakefile

@@ -8,7 +8,6 @@ Rake::TestTask.new(:test) do |t|
   t.ruby_opts = ["-w", "-r#{helper_path}"]
   t.test_files = FileList["test/**/*_test.rb"].exclude do |i|
     begin
-      next false unless defined?(RubyVM)
       RubyVM::InstructionSequence.compile(File.read(i))
       false
     rescue SyntaxError

data/lib/power_assert/context.rb

@@ -7,9 +7,34 @@ module PowerAssert
   class Context
     Value = Struct.new(:name, :value, :lineno, :column, :display_offset)
 
-    def initialize(base_caller_length)
+    def initialize(assertion_proc_or_source, assertion_method, source_binding)
       @fired = false
       @target_thread = Thread.current
+
+      if assertion_proc_or_source.respond_to?(:to_proc)
+        @assertion_proc = assertion_proc_or_source.to_proc
+        line = nil
+      else
+        @assertion_proc = source_binding.eval "Proc.new {#{assertion_proc_or_source}}"
+        line = assertion_proc_or_source
+      end
+
+      @parser = Parser::DUMMY
+      @trace_call = TracePoint.new(:call, :c_call) do
+        if PowerAssert.app_context? and Thread.current == @target_thread
+          @trace_call.disable
+          locs = PowerAssert.app_caller_locations
+          path = locs.last.path
+          lineno = locs.last.lineno
+          if File.exist?(path)
+            line ||= File.open(path) {|fp| fp.each_line.drop(lineno - 1).first }
+          end
+          if line
+            @parser = Parser.new(line, path, lineno, @assertion_proc.binding, assertion_method.to_s, @assertion_proc)
+          end
+        end
+      end
+
       method_id_set = nil
       @return_values = []
       @trace_return = TracePoint.new(:return, :c_return) do |tp|
@@ -22,14 +47,12 @@ module PowerAssert
         next if tp.event == :c_return and
                 not (@parser.lineno == tp.lineno and @parser.path == tp.path)
         locs = PowerAssert.app_caller_locations
-        diff = locs.length - base_caller_length
-        if (tp.event == :c_return && diff == 1 || tp.event == :return && diff <= 2) and Thread.current == @target_thread
-          idx = -(base_caller_length + 1)
-          if @parser.path == locs[idx].path and @parser.lineno == locs[idx].lineno
+        if (tp.event == :c_return && locs.length == 1 || tp.event == :return && locs.length <= 2) and Thread.current == @target_thread
+          if @parser.path == locs.last.path and @parser.lineno == locs.last.lineno
             val = PowerAssert.configuration.lazy_inspection ?
               tp.return_value :
               InspectedValue.new(SafeInspectable.new(tp.return_value).inspect)
-            @return_values << Value[method_id.to_s, val, locs[idx].lineno, nil]
+            @return_values << Value[method_id.to_s, val, locs.last.lineno, nil]
           end
         end
       rescue Exception => e
@@ -41,7 +64,7 @@ module PowerAssert
     end
 
     def message
-      raise 'call #yield or #enable at first' unless fired?
+      raise 'call #yield at first' unless fired?
       @message ||= build_assertion_message(@parser, @return_values).freeze
     end
 
@@ -49,8 +72,21 @@ module PowerAssert
       -> { message }
     end
 
+    def yield
+      @fired = true
+      invoke_yield(&@assertion_proc)
+    end
+
     private
 
+    def invoke_yield
+      @trace_return.enable do
+        @trace_call.enable do
+          yield
+        end
+      end
+    end
+
     def fired?
       @fired
     end
@@ -157,77 +193,4 @@ module PowerAssert
     end
   end
   private_constant :Context
-
-  class BlockContext < Context
-    def initialize(assertion_proc_or_source, assertion_method, source_binding)
-      super(0)
-      if assertion_proc_or_source.respond_to?(:to_proc)
-        @assertion_proc = assertion_proc_or_source.to_proc
-        line = nil
-      else
-        @assertion_proc = source_binding.eval "Proc.new {#{assertion_proc_or_source}}"
-        line = assertion_proc_or_source
-      end
-      @parser = Parser::DUMMY
-      @trace_call = TracePoint.new(:call, :c_call) do
-        if PowerAssert.app_context? and Thread.current == @target_thread
-          @trace_call.disable
-          locs = PowerAssert.app_caller_locations
-          path = locs.last.path
-          lineno = locs.last.lineno
-          if File.exist?(path)
-            line ||= File.open(path) {|fp| fp.each_line.drop(lineno - 1).first }
-          end
-          if line
-            @parser = Parser.new(line, path, lineno, @assertion_proc.binding, assertion_method.to_s, @assertion_proc)
-          end
-        end
-      end
-    end
-
-    def yield
-      @fired = true
-      invoke_yield(&@assertion_proc)
-    end
-
-    private
-
-    def invoke_yield
-      @trace_return.enable do
-        @trace_call.enable do
-          yield
-        end
-      end
-    end
-  end
-  private_constant :BlockContext
-
-  class TraceContext < Context
-    def initialize(binding)
-      target_frame, *base = PowerAssert.app_caller_locations
-      super(base.length)
-      path = target_frame.path
-      lineno = target_frame.lineno
-      if File.exist?(path)
-        line = File.open(path) {|fp| fp.each_line.drop(lineno - 1).first }
-        @parser = Parser.new(line, path, lineno, binding)
-      else
-        @parser = Parser::DUMMY
-      end
-    end
-
-    def enable
-      @fired = true
-      @trace_return.enable
-    end
-
-    def disable
-      @trace_return.disable
-    end
-
-    def enabled?
-      @trace_return.enabled?
-    end
-  end
-  private_constant :TraceContext
 end

data/lib/power_assert/enable_tracepoint_events.rb

@@ -1,62 +1,53 @@
 require 'power_assert/configuration'
 
-if defined?(RubyVM)
-  if PowerAssert.configuration._redefinition
-    module PowerAssert
-      # set redefined flag
-      basic_classes = [
-        Integer, Float, String, Array, Hash, Symbol, Time, Regexp, NilClass, TrueClass, FalseClass
-      ]
-
-      verbose = $VERBOSE
-      begin
-        $VERBOSE = nil
-        [:Fixnum, :Bignum].each do |c|
-          if Object.const_defined?(c) and (c = Object.const_get(c)) != Integer
-            basic_classes << c
+if PowerAssert.configuration._redefinition
+  module PowerAssert
+    # set redefined flag
+    basic_classes = [
+      Integer, Float, String, Array, Hash, Symbol, Time, Regexp, NilClass, TrueClass, FalseClass
+    ]
+
+    basic_operators = [
+      :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=, :length, :size,
+      :empty?, :nil?, :succ, :>, :>=, :!, :!=, :=~, :freeze, :-@, :max, :min,
+      # :call (it is just used for block call optimization)
+      :&, :|,
+      # :default (no specialized instruction for this)
+      :pack, :include?,
+    ]
+
+    basic_classes.each do |klass|
+      basic_operators.each do |bop|
+        if klass.public_method_defined?(bop)
+          refine(klass) do
+            define_method(bop) {}
           end
         end
-      ensure
-        $VERBOSE = verbose
       end
+    end
 
-      basic_operators = [
-        :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=, :length, :size,
-        :empty?, :nil?, :succ, :>, :>=, :!, :!=, :=~, :freeze, :-@, :max, :min,
-        # :call (it is just used for block call optimization)
-        :&, :|,
-        # :default (no specialized instruction for this)
-        :pack, :include?,
-      ]
-
-      basic_classes.each do |klass|
-        basic_operators.each do |bop|
-          if klass.public_method_defined?(bop)
-            refine(klass) do
-              define_method(bop) {}
-            end
-          end
-        end
+    # bypass check_cfunc
+    refine BasicObject do
+      def !
       end
 
-      # bypass check_cfunc
-      refine BasicObject do
-        def !
-        end
+      def ==
+      end
+    end
 
-        def ==
-        end
+    refine Module do
+      def ==
       end
+    end
 
-      refine Module do
-        def ==
-        end
+    refine Class do
+      def new
       end
     end
   end
-
-  # disable optimization
-  RubyVM::InstructionSequence.compile_option = {
-    specialized_instruction: false
-  }
 end
+
+# disable optimization
+RubyVM::InstructionSequence.compile_option = {
+  specialized_instruction: false
+}

data/lib/power_assert/parser.rb

@@ -33,16 +33,13 @@ module PowerAssert
     private
 
     def valid_syntax?(str)
-      return true unless defined?(RubyVM)
-      begin
-        verbose, $VERBOSE = $VERBOSE, nil
-        RubyVM::InstructionSequence.compile(str)
-        true
-      rescue SyntaxError
-        false
-      ensure
-        $VERBOSE = verbose
-      end
+      verbose, $VERBOSE = $VERBOSE, nil
+      RubyVM::InstructionSequence.compile(str)
+      true
+    rescue SyntaxError
+      false
+    ensure
+      $VERBOSE = verbose
     end
 
     def slice_expression(str)
@@ -68,113 +65,81 @@ module PowerAssert
     #                                                  +--------+
     #
     def extract_idents(sexp)
-      tag, * = sexp
-      case tag
-      when :arg_paren, :assoc_splat, :fcall, :hash, :method_add_block, :string_literal, :return
-        extract_idents(sexp[1])
-      when :assign, :massign
-        extract_idents(sexp[2])
-      when :opassign
-        _, _, (_, op_name, (_, op_column)), s0 = sexp
-        extract_idents(s0) + [Ident[:method, op_name.sub(/=\z/, ''), op_column]]
-      when :dyna_symbol
-        if sexp[1][0].kind_of?(Symbol)
-          # sexp[1] can be [:string_content, [..]] while parsing { "a": 1 }
-          extract_idents(sexp[1])
-        else
-          sexp[1].flat_map {|s| extract_idents(s) }
-        end
-      when :assoclist_from_args, :bare_assoc_hash, :paren, :string_embexpr,
-        :regexp_literal, :xstring_literal
-        sexp[1].flat_map {|s| extract_idents(s) }
-      when :command
-        [sexp[2], sexp[1]].flat_map {|s| extract_idents(s) }
-      when :assoc_new, :dot2, :dot3, :string_content
-        sexp[1..-1].flat_map {|s| extract_idents(s) }
-      when :unary
-        handle_columnless_ident([], sexp[1], extract_idents(sexp[2]))
-      when :binary
-        op = sexp[2]
-        if AND_OR_OPS.include?(op)
-          extract_idents(sexp[1]) + [Branch[extract_idents(sexp[3]), []]]
-        else
-          handle_columnless_ident(extract_idents(sexp[1]), op, extract_idents(sexp[3]))
-        end
-      when :call
-        _, recv, (op_sym, op_name, _), method = sexp
+      case sexp
+      in [:arg_paren | :assoc_splat | :fcall | :hash | :method_add_block | :string_literal | :return, s, *]
+        extract_idents(s)
+      in [:assign | :massign, _, s]
+        extract_idents(s)
+      in [:opassign, _, [_, op_name, [_, op_column]], s]
+        extract_idents(s) + [Ident[:method, op_name.sub(/=\z/, ''), op_column]]
+      in [:dyna_symbol, [Symbol, *] => s]
+        # s can be [:string_content, [..]] while parsing an expression like { "a": 1 }
+        extract_idents(s)
+      in [:dyna_symbol, ss]
+        ss.flat_map {|s| extract_idents(s) }
+      in [:assoclist_from_args | :bare_assoc_hash | :paren | :string_embexpr | :regexp_literal | :xstring_literal, ss, *]
+        ss.flat_map {|s| extract_idents(s) }
+      in [:command, s0, s1]
+        [s1, s0].flat_map {|s| extract_idents(s) }
+      in [:assoc_new | :dot2 | :dot3 | :string_content, *ss]
+        ss.flat_map {|s| extract_idents(s) }
+      in [:unary, mid, s]
+        handle_columnless_ident([], mid, extract_idents(s))
+      in [:binary, s0, op, s1] if AND_OR_OPS.include?(op)
+        extract_idents(s0) + [Branch[extract_idents(s1), []]]
+      in [:binary, s0, op, s1]
+        handle_columnless_ident(extract_idents(s0), op, extract_idents(s1))
+      in [:call, recv, [op_sym, op_name, _], method]
         with_safe_op = ((op_sym == :@op and op_name == '&.') or op_sym == :"&.")
         if method == :call
           handle_columnless_ident(extract_idents(recv), :call, [], with_safe_op)
         else
           extract_idents(recv) + (with_safe_op ? [Branch[extract_idents(method), []]] : extract_idents(method))
         end
-      when :array
-        sexp[1] ? sexp[1].flat_map {|s| extract_idents(s) } : []
-      when :command_call
-        [sexp[1], sexp[4], sexp[3]].flat_map {|s| extract_idents(s) }
-      when :aref
-        handle_columnless_ident(extract_idents(sexp[1]), :[], extract_idents(sexp[2]))
-      when :method_add_arg
-        idents = extract_idents(sexp[1])
-        if idents.empty?
-          # idents may be empty(e.g. ->{}.())
-          extract_idents(sexp[2])
-        else
-          if idents[-1].kind_of?(Branch) and idents[-1][1].empty?
-            # Safe navigation operator is used. See :call clause also.
-            idents[0..-2] + [Branch[extract_idents(sexp[2]) + idents[-1][0], []]]
-          else
-            idents[0..-2] + extract_idents(sexp[2]) + [idents[-1]]
-          end
-        end
-      when :args_add_block
-        _, (tag, ss0, *ss1), _ = sexp
-        if tag == :args_add_star
-          (ss0 + ss1).flat_map {|s| extract_idents(s) }
-        else
-          sexp[1].flat_map {|s| extract_idents(s) }
-        end
-      when :vcall
-        _, (tag, name, (_, column)) = sexp
-        if tag == :@ident
-          [Ident[@proc_local_variables.include?(name) ? :ref : :method, name, column]]
-        else
-          []
-        end
-      when :program
-        _, ((tag0, (tag1, (tag2, (tag3, mname, _)), _), (tag4, _, ss))) = sexp
-        if tag0 == :method_add_block and tag1 == :method_add_arg and tag2 == :fcall and
-            (tag3 == :@ident or tag3 == :@const) and mname == @assertion_method_name and (tag4 == :brace_block or tag4 == :do_block)
-          ss.flat_map {|s| extract_idents(s) }
-        else
-          _, (s0, *) = sexp
-          extract_idents(s0)
+      in [:array, ss]
+        ss ? ss.flat_map {|s| extract_idents(s) } : []
+      in [:command_call, s0, _, s1, s2]
+        [s0, s2, s1].flat_map {|s| extract_idents(s) }
+      in [:aref, s0, s1]
+        handle_columnless_ident(extract_idents(s0), :[], extract_idents(s1))
+      in [:method_add_arg, s0, s1]
+        case extract_idents(s0)
+        in []
+          # idents(s0) may be empty(e.g. ->{}.())
+          extract_idents(s1)
+        in [*is0, Branch[is1, []]]
+          # Safe navigation operator is used. See :call clause also.
+          is0 + [Branch[extract_idents(s1) + is1, []]]
+        in [*is, i]
+          is + extract_idents(s1) + [i]
         end
-      when :ifop
-        _, s0, s1, s2 = sexp
+      in [:args_add_block, [:args_add_star, ss0, *ss1], _]
+        (ss0 + ss1).flat_map {|s| extract_idents(s) }
+      in [:args_add_block, ss, _]
+        ss.flat_map {|s| extract_idents(s) }
+      in [:vcall, [:@ident, name, [_, column]]]
+        [Ident[@proc_local_variables.include?(name) ? :ref : :method, name, column]]
+      in [:vcall, _]
+        []
+      in [:program, [[:method_add_block, [:method_add_arg, [:fcall, [:@ident | :@const, ^@assertion_method_name, _]], _], [:brace_block | :do_block, _, ss]]]]
+        ss.flat_map {|s| extract_idents(s) }
+      in [:program, [s, *]]
+        extract_idents(s)
+      in [:ifop, s0, s1, s2]
         [*extract_idents(s0), Branch[extract_idents(s1), extract_idents(s2)]]
-      when :if, :unless
-        _, s0, ss0, (_, ss1) = sexp
-        [*extract_idents(s0), Branch[ss0.flat_map {|s| extract_idents(s) }, ss1 ? ss1.flat_map {|s| extract_idents(s) } : []]]
-      when :if_mod, :unless_mod
-        _, s0, s1 = sexp
+      in [:if | :unless, s0, ss0, [_, ss1]]
+        [*extract_idents(s0), Branch[ss0.flat_map {|s| extract_idents(s) }, ss1.flat_map {|s| extract_idents(s) }]]
+      in [:if | :unless, s0, ss0, _]
+        [*extract_idents(s0), Branch[ss0.flat_map {|s| extract_idents(s) }, []]]
+      in [:if_mod | :unless_mod, s0, s1]
         [*extract_idents(s0), Branch[extract_idents(s1), []]]
-      when :var_ref, :var_field
-        _, (tag, ref_name, (_, column)) = sexp
-        case tag
-        when :@kw
-          if ref_name == 'self'
-            [Ident[:ref, 'self', column]]
-          else
-            []
-          end
-        when :@ident, :@const, :@cvar, :@ivar, :@gvar
-          [Ident[:ref, ref_name, column]]
-        else
-          []
-        end
-      when :@ident, :@const, :@op
-        _, method_name, (_, column) = sexp
+      in [:var_ref | :var_field, [:@kw, 'self', [_, column]]]
+        [Ident[:ref, 'self', column]]
+      in [:var_ref | :var_field, [:@ident | :@const | :@cvar | :@ivar | :@gvar, ref_name, [_, column]]]
+        [Ident[:ref, ref_name, column]]
+      in [:var_ref | :var_field, _]
+        []
+      in [:@ident | :@const | :@op, method_name, [_, column]]
         [Ident[:method, method_name, column]]
       else
         []

data/lib/power_assert/version.rb

@@ -1,3 +1,3 @@
 module PowerAssert
-  VERSION = "2.0.5"
+  VERSION = "3.0.0"
 end

data/lib/power_assert.rb

@@ -3,18 +3,16 @@
 # Copyright (C) 2014 Kazuki Tsujimoto
 
 begin
-  unless defined?(Byebug)
-    captured = false
-    target_thread = Thread.current
-    TracePoint.new(:return, :c_return) do |tp|
-      next unless Thread.current == target_thread
-      captured = true
-      unless tp.return_value and tp.callee_id
-        raise ''
-      end
-    end.enable { __id__ }
-    raise '' unless captured
-  end
+  captured = false
+  target_thread = Thread.current
+  TracePoint.new(:return, :c_return) do |tp|
+    next unless Thread.current == target_thread
+    captured = true
+    unless tp.return_value and tp.callee_id
+      raise ''
+    end
+  end.enable { __id__ }
+  raise '' unless captured
 rescue
   raise LoadError, 'Fully compatible TracePoint API required'
 end
@@ -30,21 +28,8 @@ module PowerAssert
 
   class << self
     def start(assertion_proc_or_source, assertion_method: nil, source_binding: TOPLEVEL_BINDING)
-      if respond_to?(:clear_global_method_cache, true)
-        clear_global_method_cache
-      end
-      yield BlockContext.new(assertion_proc_or_source, assertion_method, source_binding)
-    end
-
-    def trace(frame)
-      begin
-        raise 'Byebug is not started yet' unless Byebug.started?
-      rescue NameError
-        raise "PowerAssert.#{__method__} requires Byebug"
-      end
-      ctx = TraceContext.new(frame._binding)
-      ctx.enable
-      ctx
+      clear_global_method_cache
+      yield Context.new(assertion_proc_or_source, assertion_method, source_binding)
     end
 
     def app_caller_locations
@@ -59,31 +44,16 @@ module PowerAssert
     private
 
     def internal_file?(file)
-      setup_internal_lib_dir(Byebug, :attach, 2) if defined?(Byebug)
-      setup_internal_lib_dir(PryByebug, :start_with_pry_byebug, 2, Pry) if defined?(PryByebug)
       INTERNAL_LIB_DIRS.find do |_, dir|
         file.start_with?(dir)
       end
     end
 
-    def setup_internal_lib_dir(lib, mid, depth, lib_obj = lib)
-      unless INTERNAL_LIB_DIRS.key?(lib)
-        INTERNAL_LIB_DIRS[lib] = lib_dir(lib_obj, mid, depth)
-      end
-    rescue NameError
-    end
-
-    def lib_dir(obj, mid, depth)
-      File.expand_path('../' * depth, obj.method(mid).source_location[0])
-    end
-
-    if defined?(RubyVM)
-      CLEAR_CACHE_ISEQ = RubyVM::InstructionSequence.compile('using PowerAssert.const_get(:Empty)')
-      private_constant :CLEAR_CACHE_ISEQ
+    CLEAR_CACHE_ISEQ = RubyVM::InstructionSequence.compile('using PowerAssert.const_get(:Empty)')
+    private_constant :CLEAR_CACHE_ISEQ
 
-      def clear_global_method_cache
-        CLEAR_CACHE_ISEQ.eval
-      end
+    def clear_global_method_cache
+      CLEAR_CACHE_ISEQ.eval
     end
   end
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: power_assert
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 3.0.0
 platform: ruby
 authors:
 - Kazuki Tsujimoto
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-12-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Power Assert shows each value of variables and method calls in the expression.
   It is useful for testing, providing which value wasn't correct when the condition
@@ -43,7 +42,6 @@ licenses:
 - BSD-2-Clause
 - Ruby
 metadata: {}
-post_install_message: 
 rdoc_options:
 - "--main"
 - README.md
@@ -60,8 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Power Assert for Ruby
 test_files: []