test-prof 0.1.0.beta4 → 0.1.0.pre2

data/lib/test_prof/factory_default.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/factory_default/factory_girl_patch"
-
-module TestProf
-  # FactoryDefault allows use to re-use associated objects
-  # in factories implicilty
-  module FactoryDefault
-    module DefaultSyntax # :nodoc:
-      def create_default(name, *args, &block)
-        set_factory_default(
-          name,
-          FactoryGirl.create(name, *args, &block)
-        )
-      end
-
-      def set_factory_default(name, obj)
-        FactoryDefault.register(name, obj)
-      end
-    end
-
-    class << self
-      def init
-        FactoryGirl::Syntax::Methods.include DefaultSyntax
-        FactoryGirl.extend DefaultSyntax
-        FactoryGirl::Strategy::Create.prepend StrategyExt
-        FactoryGirl::Strategy::Build.prepend StrategyExt
-        FactoryGirl::Strategy::Stub.prepend StrategyExt
-
-        @store = {}
-      end
-
-      def register(name, obj)
-        store[name] = obj
-      end
-
-      def get(name)
-        store[name]
-      end
-
-      def exists?(name)
-        store.key?(name)
-      end
-
-      def remove(name)
-        store.delete(name)
-      end
-
-      def reset
-        @store.clear
-      end
-
-      private
-
-      attr_reader :store
-    end
-  end
-end

data/lib/test_prof/factory_default/factory_girl_patch.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module TestProf
-  module FactoryDefault # :nodoc: all
-    module RunnerExt
-      refine FactoryGirl::FactoryRunner do
-        def name
-          @name
-        end
-      end
-    end
-
-    using RunnerExt
-
-    module StrategyExt
-      def association(runner)
-        return super unless FactoryDefault.exists?(runner.name)
-        FactoryDefault.get(runner.name)
-      end
-    end
-  end
-end

data/lib/test_prof/factory_prof.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/factory_prof/factory_girl_patch"
-require "test_prof/factory_prof/printers/simple"
-require "test_prof/factory_prof/printers/flamegraph"
-
-module TestProf
-  # FactoryProf collects "factory stacks" that can be used to build
-  # flamegraphs or detect most popular factories
-  module FactoryProf
-    # FactoryProf configuration
-    class Configuration
-      attr_accessor :mode
-
-      def initialize
-        @mode = ENV['FPROF'] == 'flamegraph' ? :flamegraph : :simple
-      end
-
-      # Whether we want to generate flamegraphs
-      def flamegraph?
-        @mode == :flamegraph
-      end
-    end
-
-    class Result # :nodoc:
-      attr_reader :stacks, :raw_stats
-
-      def initialize(stacks, raw_stats)
-        @stacks = stacks
-        @raw_stats = raw_stats
-      end
-
-      # Returns sorted stats
-      def stats
-        return @stats if instance_variable_defined?(:@stats)
-
-        @stats = @raw_stats.values
-                           .sort_by { |el| -el[:total] }
-      end
-
-      def total
-        return @total if instance_variable_defined?(:@total)
-        @total = @raw_stats.values.sum { |v| v[:total] }
-      end
-
-      private
-
-      def sorted_stats(key)
-        @raw_stats.values
-                  .map { |el| [el[:name], el[key]] }
-                  .sort_by { |el| -el[1] }
-      end
-    end
-
-    class << self
-      include TestProf::Logging
-
-      def config
-        @config ||= Configuration.new
-      end
-
-      def configure
-        yield config
-      end
-
-      # Patch factory lib, init vars
-      def init
-        @running = false
-
-        log :info, "FactoryProf enabled (#{config.mode} mode)"
-
-        # Monkey-patch FactoryGirl
-        ::FactoryGirl::FactoryRunner.prepend(FactoryGirlPatch) if
-          defined?(::FactoryGirl)
-      end
-
-      # Inits FactoryProf and setups at exit hook,
-      # then runs
-      def run
-        init
-
-        printer = config.flamegraph? ? Printers::Flamegraph : Printers::Simple
-
-        at_exit { printer.dump(result) }
-
-        start
-      end
-
-      def start
-        reset!
-        @running = true
-      end
-
-      def stop
-        @running = false
-      end
-
-      def result
-        Result.new(@stacks, @stats)
-      end
-
-      def track(strategy, factory)
-        return yield if !running? || (strategy != :create)
-        begin
-          @depth += 1
-          @current_stack << factory if config.flamegraph?
-          @stats[factory][:total] += 1
-          @stats[factory][:top_level] += 1 if @depth == 1
-          yield
-        ensure
-          @depth -= 1
-          flush_stack if @depth.zero?
-        end
-      end
-
-      private
-
-      def reset!
-        @stacks = [] if config.flamegraph?
-        @depth = 0
-        @stats = Hash.new { |h, k| h[k] = { name: k, total: 0, top_level: 0 } }
-        flush_stack
-      end
-
-      def flush_stack
-        return unless config.flamegraph?
-        @stacks << @current_stack unless @current_stack.nil? || @current_stack.empty?
-        @current_stack = []
-      end
-
-      def running?
-        @running == true
-      end
-    end
-  end
-end
-
-TestProf.activate('FPROF') do
-  TestProf::FactoryProf.run
-end

data/lib/test_prof/factory_prof/factory_girl_patch.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module TestProf
-  module FactoryProf
-    # Wrap #run method with FactoryProf tracking
-    module FactoryGirlPatch
-      def run(strategy = @strategy)
-        FactoryProf.track(strategy, @name) { super }
-      end
-    end
-  end
-end

data/lib/test_prof/factory_prof/printers/flamegraph.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module TestProf::FactoryProf
-  module Printers
-    module Flamegraph # :nodoc: all
-      class << self
-        include TestProf::Logging
-
-        def dump(result)
-          report_data = {
-            total_stacks: result.stacks.size,
-            total: result.total
-          }
-
-          report_data[:roots] = convert_stacks(result)
-
-          path = generate_html(report_data)
-
-          log :info, "FactoryFlame report generated: #{path}"
-        end
-
-        def convert_stacks(result)
-          res = []
-
-          paths = {}
-
-          result.stacks.each do |stack|
-            parent = nil
-            path = ""
-
-            stack.each do |sample|
-              path = "#{path}/#{sample}"
-
-              if paths[path]
-                node = paths[path]
-                node[:value] += 1
-              else
-                node = { name: sample, value: 1, total: result.raw_stats.fetch(sample)[:total] }
-                paths[path] = node
-
-                if parent.nil?
-                  res << node
-                else
-                  parent[:children] ||= []
-                  parent[:children] << node
-                end
-              end
-
-              parent = node
-            end
-          end
-
-          res
-        end
-
-        private
-
-        def generate_html(data)
-          template = File.read(TestProf.asset_path("flamegraph.template.html"))
-          template.sub! '/**REPORT-DATA**/', data.to_json
-
-          outpath = TestProf.artefact_path("factory-flame.html")
-          File.write(outpath, template)
-          outpath
-        end
-      end
-    end
-  end
-end

data/lib/test_prof/factory_prof/printers/simple.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module TestProf::FactoryProf
-  module Printers
-    module Simple # :nodoc: all
-      class << self
-        include TestProf::Logging
-
-        def dump(result)
-          msgs = []
-
-          msgs <<
-            <<~MSG
-              Factories usage
-
-               total      top-level                            name
-            MSG
-
-          result.stats.each do |stat|
-            msgs << format("%6d    %11d  %30s", stat[:total], stat[:top_level], stat[:name])
-          end
-
-          log :info, msgs.join("\n")
-        end
-      end
-    end
-  end
-end

data/lib/test_prof/recipes/minitest/sample.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module TestProf
-  # Add ability to run only a specified number of example groups (randomly selected)
-  module MinitestSample
-    # Do not add these classes to resulted sample
-    CORE_RUNNABLES = [
-      Minitest::Test,
-      Minitest::Unit::TestCase,
-      Minitest::Spec
-    ].freeze
-
-    def run(*)
-      unless ENV['SAMPLE'].nil?
-        sample_size = ENV['SAMPLE'].to_i
-        # Make sure that sample contains only _real_ suites
-        runnables = Minitest::Runnable.runnables
-                                      .sample(sample_size + CORE_RUNNABLES.size)
-                                      .reject { |suite| CORE_RUNNABLES.include?(suite) }
-                                      .take(sample_size)
-        Minitest::Runnable.reset
-        runnables.each { |r| Minitest::Runnable.runnables << r }
-      end
-      super
-    end
-  end
-end
-
-Minitest.singleton_class.prepend(TestProf::MinitestSample)

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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/factory_default"
-
-TestProf::FactoryDefault.init
-
-RSpec.configure do |config|
-  config.after(:each) { TestProf::FactoryDefault.reset }
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module TestProf
-  # Add ability to run only a specified number of example groups (randomly selected)
-  module RspecSample
-    def ordered_example_groups
-      @example_groups = @example_groups.sample(ENV['SAMPLE'].to_i) unless ENV['SAMPLE'].nil?
-      super
-    end
-  end
-end
-
-RSpec::Core::World.prepend(TestProf::RspecSample)

data/lib/test_prof/rspec_stamp.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/logging"
-require "test_prof/rspec_stamp/parser"
-
-module TestProf
-  # Mark RSpec examples with provided tags
-  module RSpecStamp
-    EXAMPLE_RXP = /(\s*)(\w+\s*(?:.*)\s*)(do|{)/
-
-    # RSpecStamp configuration
-    class Configuration
-      attr_accessor :ignore_files, :dry_run, :tags
-
-      def initialize
-        @ignore_files = [%r{spec/support}]
-        @dry_run = ENV['RSTAMP_DRY_RUN'] == '1'
-        self.tags = ENV['RSTAMP']
-      end
-
-      def dry_run?
-        @dry_run == true
-      end
-
-      def tags=(val)
-        @tags = if val.is_a?(String)
-                  parse_tags(val)
-                else
-                  val
-                end
-      end
-
-      private
-
-      def parse_tags(str)
-        str.split(/\s*,\s*/).each_with_object([]) do |tag, acc|
-          k, v = tag.split(":")
-          acc << if v.nil?
-                   k.to_sym
-                 else
-                   Hash[k.to_sym, v.to_sym]
-                 end
-        end
-      end
-    end
-
-    class << self
-      include TestProf::Logging
-
-      def config
-        @config ||= Configuration.new
-      end
-
-      def configure
-        yield config
-      end
-
-      # Accepts source code (as array of lines),
-      # line numbers (of example to apply tags)
-      # and an array of tags.
-      def apply_tags(code, lines, tags)
-        failed = 0
-
-        lines.each do |line|
-          unless stamp_example(code[line - 1], tags)
-            failed += 1
-            log :warn, "Failed to stamp: #{code[line - 1]}"
-          end
-        end
-        failed
-      end
-
-      private
-
-      # rubocop: disable Metrics/CyclomaticComplexity
-      # rubocop: disable Metrics/PerceivedComplexity
-      def stamp_example(example, tags)
-        matches = example.match(EXAMPLE_RXP)
-        return false unless matches
-
-        code = matches[2]
-        block = matches[3]
-
-        parsed = Parser.parse(code)
-        return false unless parsed
-
-        parsed.desc ||= 'works'
-
-        tags.each do |t|
-          if t.is_a?(Hash)
-            t.keys.each { |k| parsed.add_htag(k, t[k]) }
-          else
-            parsed.add_tag(t)
-          end
-        end
-
-        need_parens = block == "{"
-
-        tags_str = parsed.tags.map { |t| t.is_a?(Symbol) ? ":#{t}" : t }.join(", ") unless
-          parsed.tags.nil?
-
-        unless parsed.htags.nil?
-          htags_str = parsed.htags.map do |(k, v)|
-            vstr = v.is_a?(Symbol) ? ":#{v}" : quote(v)
-
-            "#{k}: #{vstr}"
-          end
-        end
-
-        replacement = "\\1#{parsed.fname}#{need_parens ? '(' : ' '}"\
-                      "#{[quote(parsed.desc), tags_str, htags_str].compact.join(', ')}"\
-                      "#{need_parens ? ') ' : ' '}\\3"
-
-        if config.dry_run?
-          log :info, "Patched: #{example.sub(EXAMPLE_RXP, replacement)}"
-        else
-          example.sub!(EXAMPLE_RXP, replacement)
-        end
-        true
-      end
-      # rubocop: enable Metrics/CyclomaticComplexity
-      # rubocop: enable Metrics/PerceivedComplexity
-
-      def quote(str)
-        if str.include?("'")
-          "\"#{str}\""
-        else
-          "'#{str}'"
-        end
-      end
-    end
-  end
-end
-
-require "test_prof/rspec_stamp/rspec" if defined?(RSpec)