tldr 0.1.0

data/lib/tldr/reporters/default.rb

@@ -0,0 +1,167 @@
+class TLDR
+  module Reporters
+    class Default < Base
+      def initialize(config, out = $stdout, err = $stderr)
+        super
+        @icons = @config.no_emoji ? IconProvider::Base.new : IconProvider::Emoji.new
+      end
+
+      def before_suite tests
+        @suite_start_time = Process.clock_gettime Process::CLOCK_MONOTONIC, :microsecond
+        @out.print <<~MSG
+          Command: #{tldr_command} #{@config.to_full_args}
+
+          #{@icons.run} Running:
+
+        MSG
+      end
+
+      def after_test result
+        @out.print case result.type
+        when :success then @icons.success
+        when :skip then @icons.skip
+        when :failure then @icons.failure
+        when :error then @icons.error
+        end
+      end
+
+      def time_diff start, stop = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+        ((stop - start) / 1000.0).round
+      end
+
+      def after_tldr planned_tests, wip_tests, test_results
+        stop_time = Process.clock_gettime Process::CLOCK_MONOTONIC, :microsecond
+
+        @out.print @icons.tldr
+        @err.print "\n\n"
+        wrap_in_horizontal_rule do
+          @err.print [
+            "too long; didn't run!",
+            "#{@icons.run} Completed #{test_results.size} of #{planned_tests.size} tests (#{((test_results.size.to_f / planned_tests.size) * 100).round}%) before running out of time.",
+            (<<~WIP.chomp if wip_tests.any?),
+              #{@icons.wip} #{plural wip_tests.size, "test was", "tests were"} cancelled in progress:
+              #{wip_tests.map { |wip_test| "  #{time_diff(wip_test.start_time, stop_time)}ms - #{describe(wip_test.test)}" }.join("\n")}
+            WIP
+            (<<~SLOW.chomp if test_results.any?),
+              #{@icons.slow} Your #{[10, test_results.size].min} slowest completed tests:
+              #{test_results.sort_by(&:runtime).last(10).reverse.map { |result| "  #{result.runtime}ms - #{describe(result.test)}" }.join("\n")}
+            SLOW
+            describe_tests_that_didnt_finish(planned_tests, test_results)
+          ].compact.join("\n\n")
+        end
+
+        after_suite test_results
+      end
+
+      def after_fail_fast planned_tests, wip_tests, test_results, last_result
+        unrun_tests = planned_tests - test_results.map(&:test) - wip_tests.map(&:test)
+
+        @err.print "\n\n"
+        wrap_in_horizontal_rule do
+          @err.print [
+            "Failing fast after #{describe(last_result.test, last_result.relevant_location)} #{last_result.error? ? "errored" : "failed"}.",
+            ("#{@icons.wip} #{plural wip_tests.size, "test was", "tests were"} cancelled in progress." if wip_tests.any?),
+            ("#{@icons.not_run} #{plural unrun_tests.size, "test was", "tests were"} not run at all." if unrun_tests.any?),
+            describe_tests_that_didnt_finish(planned_tests, test_results)
+          ].compact.join("\n\n")
+        end
+
+        after_suite test_results
+      end
+
+      def after_suite test_results
+        duration = time_diff @suite_start_time
+        test_results = test_results.sort_by { |result| [result.test.location.file, result.test.location.line] }
+
+        @out.print "\n\n"
+        @err.print summarize_failures(test_results).join("\n\n")
+
+        @out.print "\n\n"
+        @out.print summarize_skips(test_results).join("\n")
+
+        @out.print "\n\n"
+        @out.print "Finished in #{duration}ms."
+
+        @out.print "\n\n"
+        class_count = test_results.uniq { |result| result.test.class }.size
+        test_count = test_results.size
+        @out.print [
+          plural(class_count, "test class", "test classes"),
+          plural(test_count, "test method"),
+          plural(test_results.count(&:failure?), "failure"),
+          plural(test_results.count(&:error?), "error"),
+          plural(test_results.count(&:skip?), "skip")
+        ].join(", ")
+
+        @out.print "\n"
+      end
+
+      private
+
+      def summarize_failures results
+        failures = results.select { |result| result.failing? }
+        return failures if failures.empty?
+
+        ["Failing tests:"] + failures.map.with_index { |result, i| summarize_result result, i }
+      end
+
+      def summarize_result result, index
+        [
+          "#{index + 1}) #{describe(result.test, result.relevant_location)} #{result.failure? ? "failed" : "errored"}:",
+          result.error.message.chomp,
+          "\n  Re-run this test:",
+          "    #{tldr_command} #{@config.to_single_path_args(result.test.location.locator)}",
+          (TLDR.filter_backtrace(result.error.backtrace).join("\n") if @config.verbose)
+        ].compact.reject(&:empty?).join("\n").strip
+      end
+
+      def summarize_skips results
+        skips = results.select { |result| result.skip? }
+        return skips if skips.empty?
+
+        ["Skipped tests:\n"] + skips.map { |result| "  - #{describe(result.test)}" }
+      end
+
+      def describe test, location = test.location
+        "#{test.klass}##{test.method} [#{location.locator}]"
+      end
+
+      def plural count, singular, plural = "#{singular}s"
+        "#{count} #{(count == 1) ? singular : plural}"
+      end
+
+      def wrap_in_horizontal_rule
+        rule = @icons.alarm + "=" * 20 + " ABORTED RUN " + "=" * 20 + @icons.alarm
+        @err.print "#{rule}\n\n"
+        yield
+        @err.print "\n\n#{rule}\n\n"
+      end
+
+      def describe_tests_that_didnt_finish planned_tests, test_results
+        unrun = planned_tests - test_results.map(&:test)
+        return if unrun.empty?
+
+        unrun_locators = consolidate unrun
+        failed = test_results.select(&:failing?).map(&:test)
+        failed_locators = consolidate failed, exclude: unrun_locators
+        suggested_locators = unrun_locators + [
+          ("--comment \"Also include #{plural failed.size, "test"} that failed:\"" if failed_locators.any?)
+        ] + failed_locators
+        <<~MSG
+          #{@icons.rock_on} Run the #{plural unrun.size, "test"} that didn't finish:
+            #{tldr_command} #{@config.to_full_args exclude: [:paths]} #{suggested_locators.join(" \\\n    ")}
+        MSG
+      end
+
+      def consolidate tests, exclude: []
+        tests.group_by(&:file).map { |_, tests|
+          "\"#{tests.first.location.relative}:#{tests.map(&:line).uniq.sort.join(":")}\""
+        }.uniq - exclude
+      end
+
+      def tldr_command
+        "#{"bundle exec " if defined?(Bundler)}tldr"
+      end
+    end
+  end
+end

data/lib/tldr/reporters/icon_provider.rb

@@ -0,0 +1,93 @@
+module IconProvider
+  class Base
+    def success
+      "."
+    end
+
+    def failure
+      "F"
+    end
+
+    def error
+      "E"
+    end
+
+    def skip
+      "S"
+    end
+
+    def tldr
+      "!"
+    end
+
+    def run
+      ""
+    end
+
+    def wip
+      ""
+    end
+
+    def slow
+      ""
+    end
+
+    def not_run
+      ""
+    end
+
+    def alarm
+      ""
+    end
+
+    def rock_on
+      ""
+    end
+  end
+
+  class Emoji < Base
+    def success
+      "😁"
+    end
+
+    def failure
+      "😡"
+    end
+
+    def error
+      "🤬"
+    end
+
+    def skip
+      "🫥"
+    end
+
+    def tldr
+      "🥵"
+    end
+
+    def run
+      "🏃"
+    end
+
+    def wip
+      "🙅"
+    end
+
+    def slow
+      "🐢"
+    end
+
+    def not_run
+      "🙈"
+    end
+
+    def alarm
+      "🚨"
+    end
+
+    def rock_on
+      "🤘"
+    end
+  end
+end

data/lib/tldr/reporters.rb

@@ -0,0 +1,4 @@
+require "tldr/reporters/icon_provider"
+
+require "tldr/reporters/base"
+require "tldr/reporters/default"

data/lib/tldr/runner.rb

@@ -0,0 +1,113 @@
+require "irb"
+require "concurrent"
+
+class TLDR
+  class Runner
+    def initialize
+      @wip = Concurrent::Array.new
+      @results = Concurrent::Array.new
+      @run_aborted = Concurrent::AtomicBoolean.new false
+    end
+
+    def run config, plan
+      @wip.clear
+      @results.clear
+      reporter = config.reporter.new config
+      reporter.before_suite plan.tests
+
+      time_bomb = Thread.new {
+        explode = proc do
+          next if ENV["CI"] && !$stderr.tty?
+          next if @run_aborted.true?
+          @run_aborted.make_true
+          reporter.after_tldr plan.tests, @wip.dup, @results.dup
+          exit! 3
+        end
+
+        sleep 1.8
+        # Don't hard-kill the runner if user is debugging, it'll
+        # screw up their terminal slash be a bad time
+        if IRB.CurrentContext
+          IRB.conf[:AT_EXIT] << explode
+        else
+          explode.call
+        end
+      }
+
+      results = parallelize(plan.tests, config.parallel) { |test|
+        e = nil
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+        wip_test = WIPTest.new test, start_time
+        @wip << wip_test
+        runtime = time_it(start_time) do
+          instance = test.klass.new
+          instance.setup if instance.respond_to? :setup
+          instance.send(test.method)
+          instance.teardown if instance.respond_to? :teardown
+        rescue Skip, Failure, StandardError => e
+        end
+        TestResult.new(test, e, runtime).tap do |result|
+          next if @run_aborted.true?
+          @results << result
+          @wip.delete wip_test
+          reporter.after_test result
+          fail_fast reporter, plan, result if result.failing? && config.fail_fast
+        end
+      }.tap do
+        time_bomb.kill
+      end
+
+      unless @run_aborted.true?
+        reporter.after_suite results
+        exit exit_code results
+      end
+    end
+
+    private
+
+    def parallelize tests, parallel, &blk
+      return tests.map(&blk) if tests.size < 2 || !parallel
+      tldr_pool = Concurrent::ThreadPoolExecutor.new(
+        name: "tldr",
+        auto_terminate: true
+      )
+
+      tests.map { |test|
+        Concurrent::Promises.future_on(tldr_pool) {
+          blk.call test
+        }
+      }.flat_map(&:value)
+    end
+
+    def fail_fast reporter, plan, fast_failed_result
+      unless @run_aborted.true?
+        @run_aborted.make_true
+        abort = proc do
+          reporter.after_fail_fast plan.tests, @wip.dup, @results.dup, fast_failed_result
+          exit! exit_code([fast_failed_result])
+        end
+
+        if IRB.CurrentContext
+          IRB.conf[:AT_EXIT] << abort
+        else
+          abort.call
+        end
+      end
+    end
+
+    def time_it(start)
+      yield
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start) / 1000.0).round
+    end
+
+    def exit_code results
+      if results.any? { |result| result.error? }
+        2
+      elsif results.any? { |result| result.failure? }
+        1
+      else
+        0
+      end
+    end
+  end
+end

data/lib/tldr/skippable.rb

@@ -0,0 +1,7 @@
+class TLDR
+  module Skippable
+    def skip message = ""
+      raise Skip, message
+    end
+  end
+end

data/lib/tldr/sorbet_compatibility.rb

@@ -0,0 +1,9 @@
+class TLDR
+  class SorbetCompatibility
+    def self.unwrap_method method
+      return method unless defined? ::T::Private::Methods
+
+      T::Private::Methods.signature_for_method(method).method || method
+    end
+  end
+end

data/lib/tldr/value/config.rb

@@ -0,0 +1,217 @@
+require "concurrent"
+
+class TLDR
+  CONFLAGS = {
+    seed: "--seed",
+    no_helper: "--no-helper",
+    verbose: "--verbose",
+    reporter: "--reporter",
+    helper: "--helper",
+    load_paths: "--load-path",
+    parallel: "--[no-]parallel",
+    names: "--name",
+    fail_fast: "--fail-fast",
+    no_emoji: "--no-emoji",
+    prepend_tests: "--prepend",
+    no_prepend: "--no-prepend",
+    exclude_paths: "--exclude-path",
+    exclude_names: "--exclude-name",
+    base_path: "--base-path",
+    no_dotfile: "--no-dotfile",
+    paths: nil
+  }.freeze
+
+  PATH_FLAGS = [:paths, :helper, :load_paths, :prepend_tests, :exclude_paths].freeze
+  MOST_RECENTLY_MODIFIED_TAG = "MOST_RECENTLY_MODIFIED".freeze
+
+  Config = Struct.new :paths, :seed, :no_helper, :verbose, :reporter,
+    :helper, :load_paths, :parallel, :names, :fail_fast, :no_emoji,
+    :prepend_tests, :no_prepend, :exclude_paths, :exclude_names, :base_path,
+    :no_dotfile,
+    :seed_set_intentionally, :cli_mode, keyword_init: true do
+    def initialize(**args)
+      change_working_directory_because_i_am_bad_and_i_should_feel_bad!(args[:base_path])
+      args = merge_dotfile_args(args) unless args[:no_dotfile]
+
+      super(**merge_defaults(args))
+    end
+
+    # Must be set when the Config is first initialized
+    undef_method :cli_mode=, :no_dotfile=, :base_path=
+
+    def self.build_defaults(cli_mode = false)
+      common = {
+        seed: rand(10_000),
+        no_helper: false,
+        verbose: false,
+        reporter: Reporters::Default,
+        parallel: true,
+        names: [],
+        fail_fast: false,
+        no_emoji: false,
+        no_prepend: false,
+        exclude_paths: [],
+        exclude_names: [],
+        base_path: nil
+      }
+
+      if cli_mode
+        common.merge(
+          paths: Dir["test/**/*_test.rb", "test/**/test_*.rb"],
+          helper: "test/helper.rb",
+          load_paths: ["test"],
+          prepend_tests: [MOST_RECENTLY_MODIFIED_TAG]
+        )
+      else
+        common.merge(
+          paths: [],
+          helper: nil,
+          load_paths: [],
+          prepend_tests: []
+        )
+      end
+    end
+
+    def merge_defaults(user_args)
+      merged_args = user_args.dup
+      defaults = Config.build_defaults(merged_args[:cli_mode])
+      merged_args[:seed_set_intentionally] = !merged_args[:seed].nil?
+
+      # Special cases
+      if merged_args[:parallel].nil?
+        # Disable parallelization if seed is set
+        merged_args[:parallel] = merged_args[:seed].nil?
+      end
+
+      # Arrays
+      [:paths, :load_paths, :names, :prepend_tests, :exclude_paths, :exclude_names].each do |key|
+        merged_args[key] = defaults[key] if merged_args[key].nil? || merged_args[key].empty?
+      end
+
+      # Booleans
+      [:no_helper, :verbose, :fail_fast, :no_emoji, :no_prepend].each do |key|
+        merged_args[key] = defaults[key] if merged_args[key].nil?
+      end
+
+      # Values
+      [:seed, :reporter, :helper].each do |key|
+        merged_args[key] ||= defaults[key]
+      end
+
+      merged_args
+    end
+
+    # We needed this hook (to be called by the planner), because we can't know
+    # the default prepend location until we have all the resolved test paths,
+    # so we have to mutate it after the fact.
+    def update_after_gathering_tests! tests
+      return unless prepend_tests.include?(MOST_RECENTLY_MODIFIED_TAG)
+
+      self.prepend_tests = prepend_tests.map { |path|
+        if path == MOST_RECENTLY_MODIFIED_TAG
+          most_recently_modified_test_file tests
+        else
+          path
+        end
+      }.compact
+    end
+
+    def to_full_args(exclude: [])
+      to_cli_argv(CONFLAGS.keys - exclude).join(" ")
+    end
+
+    def to_single_path_args(path)
+      argv = to_cli_argv(CONFLAGS.keys - [
+        :seed, :parallel, :names, :fail_fast, :paths, :prepend_tests,
+        :no_prepend, :exclude_paths
+      ])
+
+      (argv + [stringify(:paths, path)]).join(" ")
+    end
+
+    private
+
+    def to_cli_argv(options = CONFLAGS.keys)
+      defaults = Config.build_defaults(cli_mode)
+      options.map { |key|
+        flag = CONFLAGS[key]
+
+        # Special cases
+        if key == :prepend_tests
+          if prepend_tests.map { |s| stringify(key, s) }.sort == paths.map { |s| stringify(:paths, s) }.sort
+            # Don't print prepended tests if they're the same as the test paths
+            next
+          elsif no_prepend
+            # Don't print prepended tests if they're disabled
+            next
+          end
+        elsif key == :helper && no_helper
+          # Don't print the helper if it's disabled
+          next
+        elsif key == :parallel
+          val = if !seed_set_intentionally && !parallel
+            "--no-parallel"
+          elsif !seed.nil? && seed_set_intentionally && parallel
+            "--parallel"
+          end
+          next val
+        end
+
+        if defaults[key] == self[key]
+          next
+        elsif self[key].is_a?(Array)
+          self[key].map { |value| [flag, stringify(key, value)] }
+        elsif self[key].is_a?(TrueClass) || self[key].is_a?(FalseClass)
+          flag if self[key]
+        elsif self[key].is_a?(Class)
+          [flag, self[key].name]
+        elsif !self[key].nil?
+          [flag, stringify(key, self[key])]
+        end
+      }.flatten.compact
+    end
+
+    def stringify key, val
+      if PATH_FLAGS.include?(key) && val.start_with?(Dir.pwd)
+        val = val[Dir.pwd.length + 1..]
+      end
+
+      if val.nil? || val.is_a?(Integer)
+        val
+      else
+        "\"#{val}\""
+      end
+    end
+
+    def most_recently_modified_test_file(tests)
+      return if tests.empty?
+
+      tests.max_by { |test| File.mtime(test.file) }.file
+    end
+
+    # If the user sets a custom base path, we need to change the working directory
+    # ASAP, even before globbing to find default paths of tests. If there is
+    # a way to change all of our Dir.glob calls to be relative to base_path
+    # without a loss in accuracy, would love to not have to use Dir.chdir!
+    def change_working_directory_because_i_am_bad_and_i_should_feel_bad!(base_path)
+      Dir.chdir(base_path) unless base_path.nil?
+    end
+
+    def merge_dotfile_args(args)
+      return args if args[:no_dotfile] || !File.exist?(".tldr.yml")
+      require "yaml"
+
+      dotfile_args = YAML.load_file(".tldr.yml").transform_keys { |k| k.to_sym }
+      # Since we don't have shell expansion, we have to glob any paths ourselves
+      if dotfile_args.key?(:paths)
+        dotfile_args[:paths] = dotfile_args[:paths].flat_map { |path| Dir[path] }
+      end
+      # The argv parser normally does this:
+      if dotfile_args.key?(:reporter)
+        dotfile_args[:reporter] = Kernel.const_get(dotfile_args[:reporter])
+      end
+
+      dotfile_args.merge(args)
+    end
+  end
+end

data/lib/tldr/value/location.rb

@@ -0,0 +1,15 @@
+class TLDR
+  Location = Struct.new :file, :line do
+    def relative
+      if file.start_with?(Dir.pwd)
+        file[Dir.pwd.length + 1..]
+      else
+        file
+      end
+    end
+
+    def locator
+      "#{relative}:#{line}"
+    end
+  end
+end

data/lib/tldr/value/plan.rb

@@ -0,0 +1,3 @@
+class TLDR
+  Plan = Struct.new :tests
+end

data/lib/tldr/value/test.rb

@@ -0,0 +1,23 @@
+class TLDR
+  Test = Struct.new :klass, :method, :file, :line do
+    attr_reader :location
+
+    def initialize(*args)
+      super
+      @location = Location.new(file, line)
+    end
+
+    # Memoizing at call time, because re-parsing isn't free and isn't usually necessary
+    def end_line
+      @end_line ||= begin
+        test_method = SorbetCompatibility.unwrap_method klass.instance_method(method)
+        RubyVM::AbstractSyntaxTree.of(test_method).last_lineno
+      end
+    end
+
+    # Test exact match starting line condition first to save us a potential re-parsing to look up end_line
+    def covers_line? l
+      line == l || (l >= line && l <= end_line)
+    end
+  end
+end