test-prof 0.1.0.beta1

data/lib/test_prof/rspec_stamp/parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+# rubocop: disable Metrics/CyclomaticComplexity
+
+module TestProf
+  module RSpecStamp
+    # Parse examples headers
+    module Parser
+      # Contains the result of parsing
+      class Result
+        attr_accessor :fname, :desc
+        attr_reader :tags, :htags
+
+        def add_tag(v)
+          @tags ||= []
+          @tags << v
+        end
+
+        def add_htag(k, v)
+          @htags ||= []
+          @htags << [k, v]
+        end
+      end
+
+      class << self
+        def parse(code)
+          sexp = Ripper.sexp(code)
+          return unless sexp
+
+          # sexp has the following format:
+          # [:program,
+          #   [
+          #     [
+          #       :command,
+          #       [:@ident, "it", [1, 0]],
+          #       [:args_add_block, [ ... ]]
+          #     ]
+          #   ]
+          # ]
+          #
+          # or
+          #
+          # [:program,
+          #   [
+          #     [
+          #       :vcall,
+          #       [:@ident, "it", [1, 0]]
+          #     ]
+          #   ]
+          # ]
+          res = Result.new
+
+          fcall = sexp[1][0][1]
+          fcall = fcall[1] if fcall.first == :fcall
+          res.fname = fcall[1]
+
+          args_block = sexp[1][0][2]
+
+          return res if args_block.nil?
+
+          args_block = args_block[1] if args_block.first == :arg_paren
+
+          args = args_block[1]
+
+          if args.first.first == :string_literal
+            res.desc = parse_literal(args.shift)
+          end
+
+          parse_arg(res, args.shift) until args.empty?
+
+          res
+        end
+
+        private
+
+        def parse_arg(res, arg)
+          if arg.first == :symbol_literal
+            res.add_tag parse_literal(arg)
+          elsif arg.first == :bare_assoc_hash
+            parse_hash(res, arg[1])
+          end
+        end
+
+        def parse_hash(res, hash_arg)
+          hash_arg.each do |(_, label, val)|
+            res.add_htag label[1][0..-2].to_sym, parse_literal(val)
+          end
+        end
+
+        # Expr of the form:
+        #  [:string_literal, [:string_content, [:@tstring_content, "is", [1, 4]]]]
+        def parse_literal(expr)
+          val = expr[1][1][1]
+          val = val.to_sym if expr[0] == :symbol_literal ||
+                              expr[0] == :assoc_new
+          val
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/rspec_stamp/rspec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module TestProf
+  module RSpecStamp
+    class RSpecListener # :nodoc:
+      include Logging
+
+      NOTIFICATIONS = %i[
+        example_failed
+      ].freeze
+
+      def initialize
+        @failed = 0
+        @ignored = 0
+        @total = 0
+        @examples = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def example_failed(notification)
+        return if notification.example.pending?
+
+        location = notification.example.metadata[:location]
+
+        file, line = location.split(":")
+
+        @examples[file] << line.to_i
+      end
+
+      def stamp!
+        @examples.each do |file, lines|
+          stamp_file(file, lines.uniq)
+        end
+
+        msgs = []
+
+        msgs <<
+          <<~MSG
+            RSpec Stamp results
+
+            Total patches: #{@total}
+            Total files: #{@examples.keys.size}
+
+            Failed patches: #{@failed}
+            Ignored files: #{@ignored}
+          MSG
+
+        log :info, msgs.join
+      end
+
+      private
+
+      def stamp_file(file, lines)
+        @total += lines.size
+        return if ignored?(file)
+
+        log :info, "(dry-run) Patching #{file}" if dry_run?
+
+        code = File.readlines(file)
+
+        @failed += RSpecStamp.apply_tags(code, lines, RSpecStamp.config.tags)
+
+        File.write(file, code.join) unless dry_run?
+      end
+
+      def ignored?(file)
+        ignored = RSpecStamp.config.ignore_files.find do |pattern|
+          file =~ pattern
+        end
+
+        return unless ignored
+        log :warn, "Ignore stamping file: #{file}"
+        @ignored += 1
+      end
+
+      def dry_run?
+        RSpecStamp.config.dry_run?
+      end
+    end
+  end
+end
+
+# Register EventProf listener
+TestProf.activate('RSTAMP') do
+  RSpec.configure do |config|
+    listener = TestProf::RSpecStamp::RSpecListener.new
+
+    config.reporter.register_listener(listener, *TestProf::RSpecStamp::RSpecListener::NOTIFICATIONS)
+
+    config.after(:suite) { listener.stamp! }
+  end
+end

data/lib/test_prof/rspec_stamp.rb

@@ -0,0 +1,135 @@
+# 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)

data/lib/test_prof/rubocop.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "test_prof/cops/rspec/aggregate_failures"

data/lib/test_prof/ruby_prof/rspec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Shared example for RSpec to profile specific examples with RubyProf
+RSpec.shared_context "ruby-prof", rprof: true do
+  prepend_before do
+    @ruby_prof_report = TestProf::RubyProf.profile
+  end
+
+  append_after do |ex|
+    next unless @ruby_prof_report
+    @ruby_prof_report.dump ex.full_description.parameterize
+  end
+end

data/lib/test_prof/ruby_prof.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module TestProf
+  # RubyProf wrapper.
+  #
+  # Has 2 modes: global and per-example.
+  #
+  # Example:
+  #
+  #   # To activate global profiling you can use env variable
+  #   TEST_RUBY_PROF=1 rspec ...
+  #
+  #   # or in your code
+  #   TestProf::RubyProf.run
+  #
+  # To profile a specific examples add :rprof tag to it:
+  #
+  #   it "is doing heavy stuff", :rprof do
+  #     ...
+  #   end
+  #
+  module RubyProf
+    # RubyProf configuration
+    class Configuration
+      # Default list of methods to exclude from profile.
+      # Contains a lot of RSpec stuff.
+      ELIMINATE_METHODS = [
+        /instance_exec/,
+        /ExampleGroup>?#run/,
+        /Procsy/,
+        /AroundHook#execute_with/,
+        /HookCollections/,
+        /Array#(map|each)/
+      ].freeze
+
+      PRINTERS = {
+        'flat' => 'FlatPrinter',
+        'flat_wln' => 'FlatWithLineNumbers',
+        'graph' => 'GraphPrinter',
+        'graph_html' => 'GraphHtmlPrinter',
+        'dot' => 'DotPrinter',
+        '.' => 'DotPrinter',
+        'call_stack' => 'CallStackPrinter',
+        'call_tree' => 'CallTreePrinter'
+      }.freeze
+
+      attr_accessor :printer, :mode, :min_percent,
+                    :include_threads, :eliminate_methods
+
+      def initialize
+        @printer = :call_stack
+        @mode = :wall
+        @min_percent = 1
+        @include_threads = false
+        @eliminate_methods = ELIMINATE_METHODS
+      end
+
+      def include_threads?
+        include_threads == true
+      end
+
+      def eliminate_methods?
+        !eliminate_methods.nil? &&
+          !eliminate_methods.empty?
+      end
+
+      # Returns an array of printer type (ID) and class.
+      # Takes ENV variable TEST_RUBY_PROF_PRINTER into account.
+      def resolve_printer
+        type = ENV['TEST_RUBY_PROF_PRINTER'] || printer
+
+        return ['custom', type] if type.is_a?(Module)
+
+        type = type.to_s
+
+        raise ArgumentError, "Unknown printer: #{type}" unless
+          PRINTERS.key?(type)
+
+        [type, ::RubyProf.const_get(PRINTERS[type])]
+      end
+    end
+
+    # Wrapper over RubyProf profiler and printer
+    class Report
+      include TestProf::Logging
+
+      def initialize(profiler)
+        @profiler = profiler
+      end
+
+      # Stop profiling and generate the report
+      # using provided name.
+      def dump(name)
+        result = @profiler.stop
+
+        if config.eliminate_methods?
+          result.eliminate_methods!(config.eliminate_methods)
+        end
+
+        printer_type, printer_class = config.resolve_printer
+        path = build_path name, printer_type
+
+        File.open(path, 'w') do |f|
+          printer_class.new(result).print(f, min_percent: config.min_percent)
+        end
+
+        log :info, "RubyProf report generated: #{path}"
+      end
+
+      private
+
+      def build_path(name, printer)
+        TestProf.artefact_path(
+          "ruby-prof-report-#{printer}-#{config.mode}-#{name}.html"
+        )
+      end
+
+      def config
+        RubyProf.config
+      end
+    end
+
+    class << self
+      include Logging
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Run RubyProf and automatically dump
+      # a report when the process exits.
+      #
+      # Use this method to profile the whole run.
+      def run
+        report = profile
+
+        return unless report
+
+        @locked = true
+
+        log :info, "RubyProf enabled"
+
+        at_exit { report.dump("total") }
+      end
+
+      def profile
+        return if locked?
+        return unless init_ruby_prof
+
+        options = {
+          merge_fibers: true
+        }
+
+        options[:include_threads] = [Thread.current] unless
+          config.include_threads?
+
+        profiler = ::RubyProf::Profile.new(options)
+        profiler.start
+
+        Report.new(profiler)
+      end
+
+      private
+
+      def locked?
+        @locked == true
+      end
+
+      def init_ruby_prof
+        return @initialized if instance_variable_defined?(:@initialized)
+        ENV["RUBY_PROF_MEASURE_MODE"] = config.mode.to_s
+        @initialized = TestProf.require(
+          'ruby-prof',
+          <<~MSG
+            Please, install 'ruby-prof' first:
+               # Gemfile
+              gem 'ruby-prof', require: false
+          MSG
+        )
+      end
+    end
+  end
+end
+
+require "test_prof/ruby_prof/rspec" if defined?(RSpec)
+
+# Hook to run RubyProf globally
+TestProf.activate('TEST_RUBY_PROF') do
+  TestProf::RubyProf.run
+end