test-prof 1.0.10 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d847a0016b2749e8ba8a637d2db3d0044f7b77cfc5962596ff490aea0f5fc7d
-  data.tar.gz: 1f32af0e6e09b555bf258c5a52586a9d4a768578b0c816298343dfd5deb826da
+  metadata.gz: 9e19d20bbf0af4e016f9dabfe56e8074cce79d750a359555a2855b982298aa8b
+  data.tar.gz: 609607e479fabd363a6ee27e20b2f55845c9a5682fdec6352b5411b7c20e5ed5
 SHA512:
-  metadata.gz: 55db394aef01457404c8f5cd914cfa0eb359f3bea08874c6d4a6b75b1151af5b4153087815c90ed73ea5948c403941918b75af0b79558afe795db77c4d2b2568
-  data.tar.gz: d95cfbd7c513d086cd47b2ce0a804ec52fdf174854c0a07c239289c65d97d18833529321e0ffb4853aabc802f05a8a8eac4e3fcdc7011f0ffd1bf0c60d150b41
+  metadata.gz: a17fe83206dd28c8b632acc3cfeb79c1acdf8344fbb199f1a688f1e61ef9f11097f0de0cc04ba1d153d108c2e966622062ea4e9917c2e8083c921de7b5bba9b6
+  data.tar.gz: cdaf249b8072a916dad83d690d32d9264ff40c46c542f26374fd217324af99a04be61560753d37ee44a0298f05b71d1ef0616e62bf020035414c4ed28d51fab3

data/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 ## master (unreleased)
 
+## 1.1.0 (2022-12-06)
+
+- LetItBe: freeze records during initialization with `freeze: true`. ([@palkan][])
+
+- Add FactoryDefault profiler (factory associations profilers). ([@palkan][])
+
+- FactoryDefault: Allow creating a default per trait (or set of traits). ([@palkan][])
+
+Now `create_default(:user)` and `create_default(:user, :admin)` would result into two defaults corresponding to the specified traits.
+
+- FactoryDefault: Add stats support. ([@palkan][])
+
+Now you can see how often the default factory values have been used by specifying
+the `FACTORY_DEFAULT_SUMMARY=1` or `FACTORY_DEFAULT_STATS=1` env var.
+
+- Support using FactoryDefault with before_all/let_it_be. ([@palkan][])
+
+Currently, RSpec only. Default factories created within `before_all` or `let_it_be` are not reset 'till the end of the corresponding context. Thus, now it's possible to use `create_default` within `let_it_be` without any additional hacks.
+
+- FactoryDefault: Add `preserve_attributes = false | true` option. ([@palkan][])
+
+Allow skipping defaults if association is defined with overrides, e.g.:
+
+```ruby
+factory :post do
+  association :user, name: "Post Author"
+end
+```
+
+- FactoryDefault: Add `skip_factory_default(&block)` to temporary disable default factories. ([@palkan][])
+
+You can also use `TestProf::FactoryDefault.disable!(&block)`.
+
+- Add support for global `before_all` tags ([@maxshend][])
+
+```ruby
+TestProf::BeforeAll.configure do |config|
+  config.before(:begin, reset_sequences: true, foo: :bar) do
+    warn <<~MESSAGE
+      Do NOT create objects outside of transaction
+      because all db sequences will be reset to 1
+      in every single example, so that IDs of new objects
+      can get into conflict with the long-living ones.
+    MESSAGE
+  end
+end
+```
+
+## 1.0.11 (2022-10-27)
+
+- Fix monitoring methods with keyword args in Ruby 3+. ([@palkan][])
+
+- Disable garbage collection frames when `TEST_STACK_PROF_IGNORE_GC` env variable is set ([@cbliard][])
+
+- Fixed restoring lock_thread value in nested contexts ([@ygelfand][])
+
 ## 1.0.10 (2022-08-12)
 
 - Allow overriding global logger. ([@palkan][])
@@ -294,3 +350,6 @@ See [changelog](https://github.com/test-prof/test-prof/blob/v0.8.0/CHANGELOG.md)
 [@grillermo]: https://github.com/grillermo
 [@cou929]: https://github.com/cou929
 [@ruslanshakirov]: https://github.com/ruslanshakirov
+[@ygelfand]: https://github.com/ygelfand
+[@cbliard]: https://github.com/cbliard
+[@maxshend]: https://github.com/maxshend

data/lib/test_prof/before_all/adapters/active_record.rb

@@ -47,7 +47,7 @@ module TestProf
       # might lead to leaking connections
       config.before(:begin) do
         next unless ::ActiveRecord::Base.connection.pool.respond_to?(:lock_thread=)
-        instance_variable_set("#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread", ::ActiveRecord::Base.connection.pool.instance_variable_get(:@lock_thread))
+        instance_variable_set("#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread", ::ActiveRecord::Base.connection.pool.instance_variable_get(:@lock_thread)) unless instance_variable_defined? "#{PREFIX_RESTORE_LOCK_THREAD}_orig_lock_thread"
         ::ActiveRecord::Base.connection.pool.lock_thread = true
       end
 

data/lib/test_prof/before_all.rb

@@ -17,19 +17,19 @@ module TestProf
     class << self
       attr_accessor :adapter
 
-      def begin_transaction
+      def begin_transaction(scope = nil, metadata = [])
         raise AdapterMissing if adapter.nil?
 
-        config.run_hooks(:begin) do
+        config.run_hooks(:begin, scope, metadata) do
           adapter.begin_transaction
         end
         yield
       end
 
-      def rollback_transaction
+      def rollback_transaction(scope = nil, metadata = [])
         raise AdapterMissing if adapter.nil?
 
-        config.run_hooks(:rollback) do
+        config.run_hooks(:rollback, scope, metadata) do
           adapter.rollback_transaction
         end
       end
@@ -49,6 +49,33 @@ module TestProf
       end
     end
 
+    class HookEntry # :nodoc:
+      attr_reader :filters, :block
+
+      def initialize(block:, filters: [])
+        @block = block
+        @filters = TestProf.rspec? ? ::RSpec::Core::Metadata.build_hash_from(filters) : filters
+      end
+
+      def run(scope, metadata)
+        return unless filters_apply?(metadata)
+
+        block.call(scope)
+      end
+
+      private
+
+      def filters_apply?(metadata)
+        return true unless filters.present? && TestProf.rspec?
+
+        ::RSpec::Core::MetadataFilter.apply?(
+          :all?,
+          filters,
+          metadata
+        )
+      end
+    end
+
     class HooksChain # :nodoc:
       attr_reader :type, :after, :before
 
@@ -58,10 +85,10 @@ module TestProf
         @after = []
       end
 
-      def run
-        before.each(&:call)
+      def run(scope = nil, metadata = [])
+        before.each { |hook| hook.run(scope, metadata) }
         yield
-        after.each(&:call)
+        after.each { |hook| hook.run(scope, metadata) }
       end
     end
 
@@ -76,26 +103,26 @@ module TestProf
       end
 
       # Add `before` hook for `begin` or
-      # `rollback` operation:
+      # `rollback` operation with optional filters:
       #
-      #   config.before(:rollback) { ... }
-      def before(type, &block)
+      #   config.before(:rollback, foo: :bar) { ... }
+      def before(type, *filters, &block)
         validate_hook_type!(type)
-        hooks[type].before << block if block
+        hooks[type].before << HookEntry.new(block: block, filters: filters) if block
       end
 
       # Add `after` hook for `begin` or
-      # `rollback` operation:
+      # `rollback` operation with optional filters:
       #
-      #   config.after(:begin) { ... }
-      def after(type, &block)
+      #   config.after(:begin, foo: :bar) { ... }
+      def after(type, *filters, &block)
         validate_hook_type!(type)
-        hooks[type].after << block if block
+        hooks[type].after << HookEntry.new(block: block, filters: filters) if block
       end
 
-      def run_hooks(type) # :nodoc:
+      def run_hooks(type, scope = nil, metadata = []) # :nodoc:
         validate_hook_type!(type)
-        hooks[type].run { yield }
+        hooks[type].run(scope, metadata) { yield }
       end
 
       private

data/lib/test_prof/event_prof/monitor.rb

@@ -48,9 +48,16 @@ module TestProf
 
           patch = Module.new do
             mids.each do |mid|
-              define_method(mid) do |*args, &block|
-                next super(*args, &block) unless guard.nil? || instance_exec(*args, &guard)
-                tracker.track { super(*args, &block) }
+              if RUBY_VERSION >= "2.7.0"
+                define_method(mid) do |*args, **kwargs, &block|
+                  next super(*args, **kwargs, &block) unless guard.nil? || instance_exec(*args, **kwargs, &guard)
+                  tracker.track { super(*args, **kwargs, &block) }
+                end
+              else
+                define_method(mid) do |*args, &block|
+                  next super(*args, &block) unless guard.nil? || instance_exec(*args, &guard)
+                  tracker.track { super(*args, &block) }
+                end
               end
             end
           end

data/lib/test_prof/event_prof.rb

@@ -8,7 +8,7 @@ require "test_prof/utils/sized_ordered_set"
 
 module TestProf
   # EventProf profiles your tests and suites against custom events,
-  # such as ActiveSupport::Notifacations.
+  # such as ActiveSupport::Notifications.
   #
   # It works very similar to `rspec --profile` but can track arbitrary events.
   #

data/lib/test_prof/factory_default/factory_bot_patch.rb

@@ -4,13 +4,7 @@ module TestProf
   module FactoryDefault # :nodoc: all
     module RunnerExt
       refine TestProf::FactoryBot::FactoryRunner do
-        def name
-          @name
-        end
-
-        def traits
-          @traits
-        end
+        attr_reader :name, :traits, :overrides
       end
     end
 
@@ -18,7 +12,8 @@ module TestProf
 
     module StrategyExt
       def association(runner)
-        FactoryDefault.get(runner.name, runner.traits) || super
+        FactoryDefault.get(runner.name, runner.traits, runner.overrides) ||
+          FactoryDefault.profiler.instrument(runner.name, runner.traits, runner.overrides) { super }
       end
     end
   end

data/lib/test_prof/factory_default.rb

@@ -3,27 +3,198 @@
 require "test_prof"
 require "test_prof/factory_bot"
 require "test_prof/factory_default/factory_bot_patch"
+require "test_prof/ext/float_duration"
+require "test_prof/ext/active_record_refind" if defined?(::ActiveRecord::Base)
 
 module TestProf
   # FactoryDefault allows use to re-use associated objects
   # in factories implicilty
   module FactoryDefault
+    using FloatDuration
+    using Ext::ActiveRecordRefind if defined?(::ActiveRecord::Base)
+
+    using(Module.new do
+      refine Object do
+        def to_override_key
+          "<#{self.class.name}::$id$#{object_id}$di$>"
+        end
+
+        def refind
+          self
+        end
+      end
+
+      if defined?(::ActiveRecord::Base)
+        refine ::ActiveRecord::Base do
+          def to_override_key
+            "<#{self.class.name}\#$id$#{public_send(self.class.primary_key)}$di$>"
+          end
+        end
+      end
+
+      [
+        String,
+        Integer,
+        Float,
+        FalseClass,
+        TrueClass,
+        NilClass,
+        Regexp
+      ].each do |mod|
+        refine(mod) do
+          def to_override_key
+            inspect
+          end
+        end
+      end
+    end)
+
+    class Profiler
+      include Logging
+
+      attr_reader :data
+
+      def initialize
+        @data = Hash.new { |h, k| h[k] = {count: 0, time: 0.0} }
+      end
+
+      def instrument(name, traits, overrides)
+        start = TestProf.now
+        yield.tap do
+          time = TestProf.now - start
+          key = build_association_name(name, traits, overrides)
+          data[key][:count] += 1
+          data[key][:time] += time
+        end
+      end
+
+      def print_report
+        if data.empty?
+          log :info, "FactoryDefault profiler collected no data"
+          return
+        end
+
+        # Merge object overrides into one stats record
+        data = self.data.each_with_object({}) do |(name, stats), acc|
+          name = name.gsub(/\$id\$.+\$di\$/, "<id>")
+          if acc.key?(name)
+            acc[name][:count] += stats[:count]
+            acc[name][:time] += stats[:time]
+          else
+            acc[name] = stats
+          end
+        end
+
+        msgs = []
+
+        msgs <<
+          <<~MSG
+            Factory associations usage:
+          MSG
+
+        first_column = data.keys.map(&:size).max + 2
+
+        msgs << format(
+          "%#{first_column}s  %9s  %12s",
+          "factory", "count", "total time"
+        )
+
+        msgs << ""
+
+        total_count = 0
+        total_time = 0.0
+
+        data.to_a.sort_by { |(_, v)| -v[:time] }.each do |(key, factory_stats)|
+          total_count += factory_stats[:count]
+          total_time += factory_stats[:time]
+
+          msgs << format(
+            "%#{first_column}s  %9d  %12s",
+            key, factory_stats[:count], factory_stats[:time].duration
+          )
+        end
+
+        msgs <<
+          <<~MSG
+
+            Total associations created: #{total_count}
+            Total uniq associations created: #{data.size}
+            Total time spent: #{total_time.duration}
+
+          MSG
+
+        log :info, msgs.join("\n")
+      end
+
+      private
+
+      def build_association_name(name, traits, overrides)
+        traits_str = "[#{traits.join(",")}]" if traits&.any?
+        overrides_str = "{#{overrides.map { |k, v| "#{k}:#{v.to_override_key}" }.join(",")}}" if overrides&.any?
+        "#{name}#{traits_str}#{overrides_str}"
+      end
+    end
+
+    class NoopProfiler
+      def instrument(*)
+        yield
+      end
+
+      def print_report
+      end
+    end
+
     module DefaultSyntax # :nodoc:
       def create_default(name, *args, &block)
         options = args.extract_options!
-        preserve = options.delete(:preserve_traits)
+        default_options = {}
+        default_options[:preserve_traits] = options.delete(:preserve_traits) if options.key?(:preserve_traits)
+        default_options[:preserve_attributes] = options.delete(:preserve_attributes) if options.key?(:preserve_attributes)
 
         obj = TestProf::FactoryBot.create(name, *args, options, &block)
-        set_factory_default(name, obj, preserve_traits: preserve)
+
+        # Factory with traits
+        name = [name, *args] if args.any?
+
+        set_factory_default(name, obj, **default_options)
       end
 
-      def set_factory_default(name, obj, preserve_traits: nil)
-        FactoryDefault.register(name, obj, preserve_traits: preserve_traits)
+      def set_factory_default(name, obj, preserve_traits: FactoryDefault.config.preserve_traits, preserve_attributes: FactoryDefault.config.preserve_attributes, **other)
+        FactoryDefault.register(
+          name, obj,
+          preserve_traits: preserve_traits,
+          preserve_attributes: preserve_attributes,
+          **other
+        )
+      end
+
+      def skip_factory_default(&block)
+        FactoryDefault.disable!(&block)
+      end
+    end
+
+    class Configuration
+      attr_accessor :preserve_traits, :preserve_attributes,
+        :report_summary, :report_stats,
+        :profiling_enabled
+
+      alias_method :profiling_enabled?, :profiling_enabled
+
+      def initialize
+        # TODO(v2): Switch to true
+        @preserve_traits = false
+        @preserve_attributes = false
+        @profiling_enabled = ENV["FACTORY_DEFAULT_PROF"] == "1"
+        @report_summary = ENV["FACTORY_DEFAULT_SUMMARY"] == "1"
+        @report_stats = ENV["FACTORY_DEFAULT_STATS"] == "1"
       end
     end
 
     class << self
-      attr_accessor :preserve_traits
+      include Logging
+
+      attr_accessor :current_context
+      attr_reader :stats, :profiler
 
       def init
         TestProf::FactoryBot::Syntax::Methods.include DefaultSyntax
@@ -32,38 +203,181 @@ module TestProf
         TestProf::FactoryBot::Strategy::Build.prepend StrategyExt
         TestProf::FactoryBot::Strategy::Stub.prepend StrategyExt
 
-        # default is false to retain backward compatibility
-        @preserve_traits = false
+        @profiler = config.profiling_enabled? ? Profiler.new : NoopProfiler.new
+        @enabled = ENV["FACTORY_DEFAULT_DISABLED"] != "1"
+        @stats = {}
+      end
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # TODO(v2): drop
+      def preserve_traits=(val)
+        config.preserve_traits = val
+      end
+
+      def preserve_attributes=(val)
+        config.preserve_attributes = val
       end
 
       def register(name, obj, **options)
-        options[:preserve_traits] = true if FactoryDefault.preserve_traits
-        store[name] = {object: obj, **options}
+        # Name with traits
+        if name.is_a?(Array)
+          register_traited_record(*name, obj, **options)
+        else
+          register_default_record(name, obj, **options)
+        end
+
         obj
       end
 
-      def get(name, traits = nil)
+      def get(name, traits = nil, overrides = nil)
+        return unless enabled?
+
         record = store[name]
         return unless record
 
-        if traits && !traits.empty?
-          return if FactoryDefault.preserve_traits || record[:preserve_traits]
+        if traits && (trait_key = record[:traits][traits])
+          name = trait_key
+          record = store[name]
+          traits = nil
+        end
+
+        stats[name][:miss] += 1
+
+        if traits && !traits.empty? && record[:preserve_traits]
+          return
+        end
+
+        object = record[:object]
+
+        if overrides && !overrides.empty? && record[:preserve_attributes]
+          overrides.each do |name, value|
+            return unless object.respond_to?(name) # rubocop:disable Lint/NonLocalExitFromIterator
+            return if object.public_send(name) != value # rubocop:disable Lint/NonLocalExitFromIterator
+          end
+        end
+
+        stats[name][:miss] -= 1
+        stats[name][:hit] += 1
+
+        if record[:context] && (record[:context] != :example)
+          object.refind
+        else
+          object
         end
-        record[:object]
       end
 
       def remove(name)
         store.delete(name)
       end
 
-      def reset
-        store.clear
+      def reset(context: nil)
+        return store.clear unless context
+
+        store.delete_if do |_name, metadata|
+          metadata[:context] == context
+        end
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def enable!
+        was_enabled = @enabled
+        @enabled = true
+        return unless block_given?
+        yield
+      ensure
+        @enabled = was_enabled
+      end
+
+      def disable!
+        was_enabled = @enabled
+        @enabled = false
+        return unless block_given?
+        yield
+      ensure
+        @enabled = was_enabled
+      end
+
+      def print_report
+        profiler.print_report
+        return unless config.report_stats || config.report_summary
+
+        if stats.empty?
+          log :info, "FactoryDefault has not been used"
+          return
+        end
+
+        msgs = []
+
+        if config.report_stats
+          msgs <<
+            <<~MSG
+              FactoryDefault usage stats:
+            MSG
+
+          first_column = stats.keys.map(&:size).max + 2
+
+          msgs << format(
+            "%#{first_column}s  %9s  %9s",
+            "factory", "hit", "miss"
+          )
+
+          msgs << ""
+        end
+
+        total_hit = 0
+        total_miss = 0
+
+        stats.to_a.sort_by { |(_, v)| -v[:hit] }.each do |(key, record_stats)|
+          total_hit += record_stats[:hit]
+          total_miss += record_stats[:miss]
+
+          if config.report_stats
+            msgs << format(
+              "%#{first_column}s  %9d  %9d",
+              key, record_stats[:hit], record_stats[:miss]
+            )
+          end
+        end
+
+        msgs << "" if config.report_stats
+
+        msgs <<
+          <<~MSG
+            FactoryDefault summary: hit=#{total_hit} miss=#{total_miss}
+          MSG
+
+        log :info, msgs.join("\n")
       end
 
       private
 
+      def register_default_record(name, obj, **options)
+        store[name] = {object: obj, traits: {}, context: current_context, **options}
+        stats[name] ||= {hit: 0, miss: 0}
+      end
+
+      def register_traited_record(name, *traits, obj, **options)
+        name_with_traits = "#{name}[#{traits.join(",")}]"
+
+        register_default_record(name_with_traits, obj, **options)
+        register_default_record(name, obj, **options) unless store[name]
+
+        # Add reference to the traited default to the original default record
+        store[name][:traits][traits] = name_with_traits
+      end
+
       def store
-        Thread.current[:testprof_factory_store] ||= {}
+        Thread.current[:testprof_factory_default_store] ||= {}
       end
     end
   end

data/lib/test_prof/factory_doctor/minitest.rb

@@ -87,7 +87,7 @@ module Minitest
       private
 
       def pluralize_records(count)
-        count == 1 ? "1 record" : "#{count} records"
+        (count == 1) ? "1 record" : "#{count} records"
       end
     end
   end

data/lib/test_prof/factory_prof.rb

@@ -18,7 +18,7 @@ module TestProf
       attr_accessor :mode, :printer
 
       def initialize
-        @mode = ENV["FPROF"] == "flamegraph" ? :flamegraph : :simple
+        @mode = (ENV["FPROF"] == "flamegraph") ? :flamegraph : :simple
         @printer =
           case ENV["FPROF"]
           when "flamegraph"

data/lib/test_prof/recipes/rspec/before_all.rb

@@ -17,23 +17,24 @@ module TestProf
           return
         end
 
-        @__before_all_activated__ = true
+        @__before_all_activation__ = context = self
+        current_metadata = metadata
 
         before(:all) do
           @__inspect_output = "before_all hook"
           BeforeAll.setup_fixtures(self) if setup_fixtures
-          BeforeAll.begin_transaction do
+          BeforeAll.begin_transaction(context, current_metadata) do
             instance_eval(&block)
           end
         end
 
         after(:all) do
-          BeforeAll.rollback_transaction
+          BeforeAll.rollback_transaction(context, current_metadata)
         end
       end
 
       def within_before_all?
-        instance_variable_defined?(:@__before_all_activated__)
+        instance_variable_defined?(:@__before_all_activation__)
       end
     end
   end

data/lib/test_prof/recipes/rspec/factory_default.rb

@@ -4,6 +4,25 @@ require "test_prof/factory_default"
 
 TestProf::FactoryDefault.init
 
+if defined?(TestProf::BeforeAll)
+  TestProf::BeforeAll.configure do |config|
+    config.before(:begin) do |context|
+      TestProf::FactoryDefault.current_context = context
+    end
+
+    config.after(:rollback) do |context|
+      TestProf::FactoryDefault.reset(context: context)
+    end
+  end
+end
+
 RSpec.configure do |config|
-  config.after(:each) { TestProf::FactoryDefault.reset }
+  if defined?(TestProf::BeforeAll)
+    config.before(:each) { TestProf::FactoryDefault.current_context = :example }
+    config.after(:each) { TestProf::FactoryDefault.reset(context: :example) }
+  else
+    config.after(:each) { TestProf::FactoryDefault.reset }
+  end
+
+  config.after(:suite) { TestProf::FactoryDefault.print_report }
 end

data/lib/test_prof/recipes/rspec/let_it_be.rb

@@ -7,6 +7,12 @@ module TestProf
   # Just like `let`, but persist the result for the whole group.
   # NOTE: Experimental and magical, for more control use `before_all`.
   module LetItBe
+    Modifier = Struct.new(:scope, :block) do
+      def call(record, config)
+        block.call(record, config)
+      end
+    end
+
     class Configuration
       # Define an alias for `let_it_be` with the predefined options:
       #
@@ -17,10 +23,13 @@ module TestProf
         LetItBe.define_let_it_be_alias(name, **default_args)
       end
 
-      def register_modifier(key, &block)
+      # Register modifier by providing the name of key,
+      # optional scope (when to apply the modifier, on initialization (:initialize)
+      # or when accessed # via let (:let))
+      def register_modifier(key, on: :let, &block)
         raise ArgumentError, "Modifier #{key} is already defined for let_it_be" if LetItBe.modifiers.key?(key)
 
-        LetItBe.modifiers[key] = block
+        LetItBe.modifiers[key] = Modifier.new(on, block)
       end
 
       def default_modifiers
@@ -41,17 +50,18 @@ module TestProf
         @modifiers ||= {}
       end
 
-      def wrap_with_modifiers(mods, &block)
+      def wrap_with_modifiers(mods, on: :let, &block)
+        mods = mods.select { |k, val| LetItBe.modifiers.fetch(k).scope == on }
         return block if mods.empty?
 
         validate_modifiers! mods
 
-        -> {
+        proc do
           record = instance_eval(&block)
           mods.inject(record) do |rec, (k, v)|
             LetItBe.modifiers.fetch(k).call(rec, v)
           end
-        }
+        end
       end
 
       def module_for(group)
@@ -97,9 +107,11 @@ module TestProf
 
       options = default_options.merge(options)
 
+      initializer = LetItBe.wrap_with_modifiers(options, on: :initialize, &initializer)
+
       before_all(&initializer)
 
-      let_accessor = LetItBe.wrap_with_modifiers(options) do
+      let_accessor = LetItBe.wrap_with_modifiers(options, on: :let) do
         instance_variable_get(:"#{PREFIX}#{identifier}")
       end
 
@@ -192,7 +204,7 @@ if defined?(::ActiveRecord::Base)
 
       next record.reload if record.is_a?(::ActiveRecord::Base)
 
-      if record.respond_to?(:map)
+      if record.respond_to?(:to_ary)
         next record.map do |rec|
           rec.is_a?(::ActiveRecord::Base) ? rec.reload : rec
         end
@@ -205,7 +217,7 @@ if defined?(::ActiveRecord::Base)
 
       next record.refind if record.is_a?(::ActiveRecord::Base)
 
-      if record.respond_to?(:map)
+      if record.respond_to?(:to_ary)
         next record.map do |rec|
           rec.is_a?(::ActiveRecord::Base) ? rec.refind : rec
         end
@@ -213,7 +225,7 @@ if defined?(::ActiveRecord::Base)
       record
     end
 
-    config.register_modifier :freeze do |record, val|
+    config.register_modifier :freeze, on: :initialize do |record, val|
       if val == false
         TestProf::LetItBe::Freezer::Stoplist.stop!(record)
         next record

data/lib/test_prof/rspec_dissect.rb

@@ -47,7 +47,7 @@ module TestProf
         @let_top_count = (ENV["RD_PROF_LET_TOP"] || 3).to_i
         @top_count = (ENV["RD_PROF_TOP"] || 5).to_i
         @stamp = ENV["RD_PROF_STAMP"]
-        @mode = ENV["RD_PROF"] == "1" ? "all" : ENV["RD_PROF"]
+        @mode = (ENV["RD_PROF"] == "1") ? "all" : ENV["RD_PROF"]
 
         unless MODES.include?(mode)
           raise "Unknown RSpecDissect mode: #{mode};" \

data/lib/test_prof/stack_prof.rb

@@ -24,11 +24,10 @@ module TestProf
     class Configuration
       FORMATS = %w[html json].freeze
 
-      attr_accessor :mode, :interval, :raw, :target, :format
-
+      attr_accessor :mode, :raw, :target, :format, :interval, :ignore_gc
       def initialize
         @mode = ENV.fetch("TEST_STACK_PROF_MODE", :wall).to_sym
-        @target = ENV["TEST_STACK_PROF"] == "boot" ? :boot : :suite
+        @target = (ENV["TEST_STACK_PROF"] == "boot") ? :boot : :suite
         @raw = ENV["TEST_STACK_PROF_RAW"] != "0"
         @format =
           if FORMATS.include?(ENV["TEST_STACK_PROF_FORMAT"])
@@ -38,7 +37,8 @@ module TestProf
           end
 
         sample_interval = ENV["TEST_STACK_PROF_INTERVAL"].to_i
-        @interval = sample_interval > 0 ? sample_interval : nil
+        @interval = (sample_interval > 0) ? sample_interval : nil
+        @ignore_gc = !ENV["TEST_STACK_PROF_IGNORE_GC"].nil?
       end
 
       def raw?
@@ -96,6 +96,7 @@ module TestProf
         }
 
         options[:interval] = config.interval if config.interval
+        options[:ignore_gc] = true if config.ignore_gc
 
         if block_given?
           options[:out] = build_path(name)

data/lib/test_prof/tag_prof/rspec.rb

@@ -13,7 +13,7 @@ module TestProf
       attr_reader :result, :printer
 
       def initialize
-        @printer = ENV["TAG_PROF_FORMAT"] == "html" ? Printers::HTML : Printers::Simple
+        @printer = (ENV["TAG_PROF_FORMAT"] == "html") ? Printers::HTML : Printers::Simple
 
         @result =
           if ENV["TAG_PROF_EVENT"].nil?

data/lib/test_prof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestProf
-  VERSION = "1.0.10"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.1.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler