test-prof 0.4.9 → 0.5.0.pre1

data/lib/test_prof.rb

@@ -90,7 +90,7 @@ module TestProf
     private
 
     def activate!(env_var, val)
-      yield if ENV[env_var] && (val.nil? || ENV[env_var] == val)
+      yield if ENV[env_var] && (val.nil? || val === ENV[env_var])
     end
 
     def with_timestamps(path)
@@ -132,3 +132,4 @@ require "test_prof/factory_prof"
 require "test_prof/rspec_stamp"
 require "test_prof/tag_prof"
 require "test_prof/rspec_dissect"
+require "test_prof/factory_all_stub"

data/lib/test_prof/any_fixture.rb

@@ -1,27 +1,53 @@
 # frozen_string_literal: true
 
+require "test_prof/ext/float_duration"
+require "test_prof/ext/string_strip_heredoc"
+
 module TestProf
   # Make DB fixtures from blocks.
   module AnyFixture
     INSERT_RXP = /^INSERT INTO ([\S]+)/
 
-    class Cache # :nodoc:
-      attr_reader :store
+    using FloatDuration
+    using StringStripHeredoc
 
-      delegate :clear, to: :store
+    class Cache # :nodoc:
+      attr_reader :store, :stats
 
       def initialize
         @store = {}
+        @stats = {}
       end
 
       def fetch(key)
-        return store[key] if store.key?(key)
+        if store.key?(key)
+          stats[key][:hit] += 1
+          return store[key]
+        end
+
         return unless block_given?
+
+        ts = TestProf.now
         store[key] = yield
+        stats[key] = { time: TestProf.now - ts, hit: 0 }
+        store[key]
+      end
+
+      def clear
+        store.clear
+        stats.clear
       end
     end
 
     class << self
+      include Logging
+
+      attr_accessor :reporting_enabled
+
+      def reporting_enabled?
+        reporting_enabled == true
+      end
+
       # Register a block of code as a fixture,
       # returns the result of the block execution
       def register(id)
@@ -53,6 +79,54 @@ module TestProf
         tables_cache[matches[1]] = true if matches
       end
 
+      def report_stats
+        msgs = []
+
+        msgs <<
+          <<-MSG.strip_heredoc
+            AnyFixture usage stats:
+          MSG
+
+        first_column = cache.stats.keys.map(&:size).max + 2
+
+        msgs << format(
+          "%#{first_column}s  %12s  %9s  %12s",
+          'key', 'build time', 'hit count', 'saved time'
+        )
+
+        msgs << ""
+
+        total_spent = 0.0
+        total_saved = 0.0
+        total_miss = 0.0
+
+        cache.stats.to_a.sort_by { |(_, v)| -v[:hit] }.each do |(key, stats)|
+          total_spent += stats[:time]
+
+          saved = stats[:time] * stats[:hit]
+
+          total_saved += saved
+
+          total_miss += stats[:time] if stats[:hit].zero?
+
+          msgs << format(
+            "%#{first_column}s  %12s  %9d  %12s",
+            key, stats[:time].duration, stats[:hit],
+            saved.duration
+          )
+        end
+
+        msgs <<
+          <<-MSG.strip_heredoc
+
+            Total time spent: #{total_spent.duration}
+            Total time saved: #{total_saved.duration}
+            Total time wasted: #{total_miss.duration}
+          MSG
+
+        log :info, msgs.join("\n")
+      end
+
       private
 
       def cache
@@ -63,5 +137,7 @@ module TestProf
         @tables_cache ||= {}
       end
     end
+
+    self.reporting_enabled = ENV['ANYFIXTURE_REPORT'] == '1'
   end
 end

data/lib/test_prof/any_fixture/dsl.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TestProf
+  module AnyFixture
+    # Adds "global" `fixture` method (through refinement)
+    module DSL
+      module Ext # :nodoc:
+        def fixture(id, &block)
+          ::TestProf::AnyFixture.register(:"#{id}", &block)
+        end
+      end
+
+      refine Kernel do
+        include Ext
+      end
+    end
+  end
+end

data/lib/test_prof/event_prof.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "test_prof/rspec_stamp"
+require "test_prof/event_prof/profiler"
 require "test_prof/event_prof/instrumentations/active_support"
 require "test_prof/utils/sized_ordered_set"
 
@@ -72,119 +73,20 @@ module TestProf
         yield config
       end
 
-      # Returns new configured instance of profiler
-      def build
-        Profiler.new(
-          event: config.event,
-          instrumenter: config.resolve_instrumenter
+      # Returns new configured instance of profilers group
+      def build(event = config.event)
+        ProfilersGroup.new(
+          event: event,
+          instrumenter: config.resolve_instrumenter,
+          rank_by: config.rank_by,
+          top_count: config.top_count,
+          per_example: config.per_example?
         )
       end
     end
-
-    class Profiler # :nodoc:
-      include TestProf::Logging
-
-      attr_reader :event, :total_count, :total_time
-
-      def initialize(event:, instrumenter:)
-        @event = event
-
-        log :info, "EventProf enabled (#{@event})"
-
-        instrumenter.subscribe(event) { |time| track(time) }
-
-        @groups = Utils::SizedOrderedSet.new(
-          top_count, sort_by: rank_by
-        )
-
-        @examples = Utils::SizedOrderedSet.new(
-          top_count, sort_by: rank_by
-        )
-
-        @total_count = 0
-        @total_time = 0.0
-      end
-
-      def track(time)
-        return if @current_group.nil?
-        @total_time += time
-        @total_count += 1
-
-        @time += time
-        @count += 1
-
-        return if @current_example.nil?
-
-        @example_time += time
-        @example_count += 1
-      end
-
-      def group_started(id)
-        reset_group!
-        @current_group = id
-      end
-
-      def group_finished(id)
-        data = { id: id, time: @time, count: @count, examples: @total_examples }
-
-        @groups << data unless data[rank_by].zero?
-
-        @current_group = nil
-      end
-
-      def example_started(id)
-        return unless config.per_example?
-        reset_example!
-        @current_example = id
-      end
-
-      def example_finished(id)
-        @total_examples += 1
-        return unless config.per_example?
-
-        data = { id: id, time: @example_time, count: @example_count }
-        @examples << data unless data[rank_by].zero?
-        @current_example = nil
-      end
-
-      def results
-        {
-          groups: @groups.to_a
-        }.tap do |data|
-          next unless config.per_example?
-
-          data[:examples] = @examples.to_a
-        end
-      end
-
-      def rank_by
-        EventProf.config.rank_by
-      end
-
-      def top_count
-        EventProf.config.top_count
-      end
-
-      private
-
-      def config
-        EventProf.config
-      end
-
-      def reset_group!
-        @time = 0.0
-        @count = 0
-        @total_examples = 0
-      end
-
-      def reset_example!
-        @example_count = 0
-        @example_time = 0.0
-      end
-    end
   end
 end
 
+require "test_prof/event_prof/custom_events"
 require "test_prof/event_prof/rspec" if defined?(RSpec::Core)
 require "test_prof/event_prof/minitest" if defined?(Minitest)
-require "test_prof/event_prof/custom_events"

data/lib/test_prof/event_prof/custom_events.rb

@@ -1,5 +1,35 @@
 # frozen_string_literal: true
 
+module TestProf
+  module EventProf
+    # Registers and activates custom events (which require patches).
+    module CustomEvents
+      class << self
+        def register(event)
+          raise ArgumentError, "Block is required!" unless block_given?
+          registrations[event] = Proc.new
+        end
+
+        def activate_all(events)
+          events = events.split(",")
+          events.each { |event| try_activate(event) }
+        end
+
+        def try_activate(event)
+          return unless registrations.key?(event)
+          registrations.delete(event).call
+        end
+
+        private
+
+        def registrations
+          @registrations ||= {}
+        end
+      end
+    end
+  end
+end
+
 require "test_prof/event_prof/custom_events/factory_create"
 require "test_prof/event_prof/custom_events/sidekiq_inline"
 require "test_prof/event_prof/custom_events/sidekiq_jobs"

data/lib/test_prof/event_prof/custom_events/factory_create.rb

@@ -44,7 +44,7 @@ module TestProf::EventProf::CustomEvents
   end
 end
 
-TestProf.activate('EVENT_PROF', 'factory.create') do
+TestProf::EventProf::CustomEvents.register("factory.create") do
   if defined? TestProf::FactoryBot
     TestProf::EventProf::CustomEvents::FactoryCreate.setup!
   else

data/lib/test_prof/event_prof/custom_events/sidekiq_inline.rb

@@ -40,7 +40,7 @@ module TestProf::EventProf::CustomEvents
   end
 end
 
-TestProf.activate('EVENT_PROF', 'sidekiq.inline') do
+TestProf::EventProf::CustomEvents.register("sidekiq.inline") do
   if TestProf.require(
     'sidekiq/testing',
     <<-MSG.strip_heredoc

data/lib/test_prof/event_prof/custom_events/sidekiq_jobs.rb

@@ -27,7 +27,7 @@ module TestProf::EventProf::CustomEvents
   end
 end
 
-TestProf.activate('EVENT_PROF', 'sidekiq.jobs') do
+TestProf::EventProf::CustomEvents.register("sidekiq.jobs") do
   if TestProf.require(
     'sidekiq/testing',
     <<-MSG.strip_heredoc

data/lib/test_prof/event_prof/minitest.rb

@@ -9,6 +9,9 @@ module Minitest
       def initialize(io = $stdout, options = {})
         super
         @profiler = configure_profiler(options)
+
+        log :info, "EventProf enabled (#{@profiler.events.join(', ')})"
+
         @formatter = EventProfFormatter.new(@profiler)
         @current_group = nil
         @current_example = nil
@@ -64,7 +67,10 @@ module Minitest
           config.rank_by = options[:rank_by] if options[:rank_by]
           config.top_count = options[:top_count] if options[:top_count]
           config.per_example = options[:per_example] if options[:per_example]
+
+          ::TestProf::EventProf::CustomEvents.activate_all config.event
         end
+
         ::TestProf::EventProf.build
       end
     end

data/lib/test_prof/event_prof/profiler.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module TestProf
+  module EventProf
+    class Profiler # :nodoc:
+      attr_reader :event, :total_count, :total_time, :rank_by, :top_count, :per_example,
+                  :time, :count, :example_time, :example_count
+
+      alias per_example? per_example
+
+      def initialize(event:, instrumenter:, rank_by: :time, top_count: 5, per_example: false)
+        @event = event
+        @rank_by = rank_by
+        @top_count = top_count
+        @per_example = per_example
+
+        instrumenter.subscribe(event) { |time| track(time) }
+
+        @groups = Utils::SizedOrderedSet.new(
+          top_count, sort_by: rank_by
+        )
+
+        @examples = Utils::SizedOrderedSet.new(
+          top_count, sort_by: rank_by
+        )
+
+        @total_count = 0
+        @total_time = 0.0
+      end
+
+      def track(time)
+        return if @current_group.nil?
+        @total_time += time
+        @total_count += 1
+
+        @time += time
+        @count += 1
+
+        return if @current_example.nil?
+
+        @example_time += time
+        @example_count += 1
+      end
+
+      def group_started(id)
+        reset_group!
+        @current_group = id
+      end
+
+      def group_finished(id)
+        data = { id: id, time: @time, count: @count, examples: @total_examples }
+
+        @groups << data unless data[rank_by].zero?
+
+        @current_group = nil
+      end
+
+      def example_started(id)
+        return unless per_example?
+        reset_example!
+        @current_example = id
+      end
+
+      def example_finished(id)
+        @total_examples += 1
+        return unless per_example?
+
+        data = { id: id, time: @example_time, count: @example_count }
+        @examples << data unless data[rank_by].zero?
+        @current_example = nil
+      end
+
+      def results
+        {
+          groups: @groups.to_a
+        }.tap do |data|
+          next unless per_example?
+
+          data[:examples] = @examples.to_a
+        end
+      end
+
+      private
+
+      def reset_group!
+        @time = 0.0
+        @count = 0
+        @total_examples = 0
+      end
+
+      def reset_example!
+        @example_count = 0
+        @example_time = 0.0
+      end
+    end
+
+    # Multiple profilers wrapper
+    class ProfilersGroup
+      attr_reader :profilers
+
+      def initialize(event:, **options)
+        events = event.split(",")
+        @profilers = events.map do |ev|
+          Profiler.new(event: ev, **options)
+        end
+      end
+
+      def each
+        if block_given?
+          @profilers.each(&Proc.new)
+        else
+          @profilers.each
+        end
+      end
+
+      def events
+        @profilers.map(&:event)
+      end
+
+      %i[group_started group_finished example_started example_finished].each do |name|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}(id)
+            @profilers.each { |profiler| profiler.#{name}(id) }
+          end
+        CODE
+      end
+    end
+  end
+end