tldr 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3db38676fc9f10ee01f3332c6dfcafb5dc7c0b5405d9c687d13ba3c5b5be008e
-  data.tar.gz: 874cbd810ed0ebff0e2bc92bba4d703903c10beb51220817314a9e6528308a01
+  metadata.gz: c9ae325a1d7b5c16b255bce28975b4e9c08bc23291932a02d91d02d46c247655
+  data.tar.gz: 0e92807c78187999ea26dba8f3ff48aa8ec6442b8884def3b7fc6b58db4127f0
 SHA512:
-  metadata.gz: c79d10782d1d15ba8bd782358ad1b45ecbbc7096542aba5d487fd97822a61163049247a6cff2e050de95226e112653418b5cc656278a0fdf55cd7c5b09ce5ccb
-  data.tar.gz: 429100174c63d3e9d917ef7a5b4f5ff14f105453c53a854a21369595272507b47e4629bd50edd067a6aaf46986f583f8327b9e4f66555e390440c86cd584c04b
+  metadata.gz: 79a8a3c45bc03731c80e5d7b00103d69efe4a1185c758fdecde1451864677af433126634a717dd912d7032556562cbe3894b1e7db75ab811412c1cc9097a457e
+  data.tar.gz: f27b99c4502b3a803d9c0507a1a9888715e8d203e1fc97bcd3284baa34afed4d9f55f2c5c06424c49645526c92534a54b52946867606a89b738dcb9c481a4c5d

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.9.0]
+
+* Add a `--watch` option that will spawn fswatch | xargs and clear the screen
+between runs (requires fswatch to gbe installed)
+* Add "lib" as a default load path along with "test"
+
+## [0.8.0]
+
+* Add a `--yes-i-know` flag that will suppress the large warning when your test
+suite runs over the 1.8s limit
+
 ## [0.7.0]
 
 * Add a `tldt` alias for folks who have another executable named `tldr` on their

data/README.md

@@ -116,14 +116,17 @@ Usage: tldr [options] some_tests/**/*.rb some/path.rb:13 ...
         --no-helper                  Don't require any test helpers
         --prepend PATH               Prepend one or more paths to run before the rest (Default: most recently modified test)
         --no-prepend                 Don't prepend any tests before the rest of the suite
-    -l, --load-path PATH             Add one or more paths to the $LOAD_PATH (Default: ["test"])
+    -l, --load-path PATH             Add one or more paths to the $LOAD_PATH (Default: ["lib", "test"])
     -r, --reporter REPORTER          Set a custom reporter class (Default: "TLDR::Reporters::Default")
         --base-path PATH             Change the working directory for all relative paths (Default: current working directory)
         --no-dotfile                 Disable loading .tldr.yml dotfile
         --no-emoji                   Disable emoji in the output
     -v, --verbose                    Print stack traces for errors
         --[no-]warnings              Print Ruby warnings (Default: true)
-        --comment COMMENT            No-op comment, used internally for multi-line execution instructions
+        --watch                      Run your tests continuously on file save (requires 'fswatch' to be installed)
+        --yes-i-know                 Suppress TLDR report when suite runs over 1.8s
+        --i-am-being-watched         [INTERNAL] Signals to tldr it is being invoked under --watch mode
+        --comment COMMENT            [INTERNAL] No-op; used for multi-line execution instructions
 ```
 
 After being parsed, all the CLI options are converted into a
@@ -160,6 +163,17 @@ with these caveats:
   TLDR::Assertions::MinitestCompatibility` into the `TLDR` base class or
   individual test classesJust set it
 
+### Running tests continuously with --watch
+
+The `tldr` CLI includes a `--watch` option which will watch for changes in any
+of the configured load paths (`["test", "lib"]` by default) and then execute
+your tests each time a file is changed. To keep the output up-to-date and easy
+to scan, it will also clear your console before each run.
+
+Here's what that might look like:
+
+![tldr-watch](https://github.com/tendersearls/tldr/assets/79303/364f0e52-5596-49ce-a470-5eaeddd11f03)
+
 ### Running TLDR with Rake
 
 TLDR ships with a [very](lib/tldr/rake.rb) minimal rake task that simply shells
@@ -239,8 +253,9 @@ encountered multiple times, only the first hook will be registered. If the
 
 #### Setting up the load path
 
-When running TLDR from a Ruby script, one thing the framework can't help you with
-is setting up load paths for you.
+By default, the `tldr` CLI adds `test` and `lib` directories to the load path
+for you, but when running TLDR from a Ruby script, it doesn't set those up for
+you.
 
 If you want to require code in `test/` or `lib/` without using
 `require_relative`, you'll need to add those directories to the load path. You
@@ -336,12 +351,26 @@ with the `--reporter` command line option. It can be set to any fully-qualified
 class name that extends from
 [TLDR::Reporters::Base](/lib/tldr/reporters/base.rb).
 
+### I know my tests are over 1.8s, how do I suppress the huge output?
+
+Plenty of test suites are over 1.8s and having TLDR repeatedly print out the
+huge summary at the end of each test run can be distracting and make it harder
+to spot test failures. If you know your test suite is too slow, you can simply
+add the `--yes-i-know` flag
+
 ### What about mocking?
 
 TLDR is laser-focused on running tests, so it doesn't provide a built-in mocking
 facility. Might we interest you in a refreshing
 [mocktail](https://github.com/testdouble/mocktail), instead?
 
+## Contributing to TLDR
+
+If you want to submit PRs on this repo, please know that the code style is
+[Kirkland-style Ruby](https://mastodon.social/@searls/111137666157318482), where
+method definitions have parentheses omitted but parentheses are generally
+expected for method invocations.
+
 ## Acknowledgements
 
 Thanks to [George Sheppard](https://github.com/fuzzmonkey) for freeing up the

data/lib/tldr/argv_parser.rb

@@ -4,7 +4,7 @@ class TLDR
   class ArgvParser
     PATTERN_FRIENDLY_SPLITTER = /,(?=(?:[^\/]*\/[^\/]*\/)*[^\/]*$)/
 
-    def parse(args, options = {cli_defaults: true})
+    def parse args, options = {cli_defaults: true}
       OptionParser.new do |opts|
         opts.banner = "Usage: tldr [options] some_tests/**/*.rb some/path.rb:13 ..."
 
@@ -22,12 +22,12 @@ class TLDR
 
         opts.on "-n", "#{CONFLAGS[:names]} PATTERN", "One or more names or /patterns/ of tests to run (like: foo_test, /test_foo.*/, Foo#foo_test)" do |name|
           options[:names] ||= []
-          options[:names] += name.split PATTERN_FRIENDLY_SPLITTER
+          options[:names] += name.split(PATTERN_FRIENDLY_SPLITTER)
         end
 
         opts.on "#{CONFLAGS[:exclude_names]} PATTERN", "One or more names or /patterns/ NOT to run" do |exclude_name|
           options[:exclude_names] ||= []
-          options[:exclude_names] += exclude_name.split PATTERN_FRIENDLY_SPLITTER
+          options[:exclude_names] += exclude_name.split(PATTERN_FRIENDLY_SPLITTER)
         end
 
         opts.on "#{CONFLAGS[:exclude_paths]} PATH", Array, "One or more paths NOT to run (like: foo.rb, \"test/bar/**\", baz.rb:3)" do |path|
@@ -53,7 +53,7 @@ class TLDR
           options[:no_prepend] = true
         end
 
-        opts.on "-l", "#{CONFLAGS[:load_paths]} PATH", Array, "Add one or more paths to the $LOAD_PATH (Default: [\"test\"])" do |load_path|
+        opts.on "-l", "#{CONFLAGS[:load_paths]} PATH", Array, "Add one or more paths to the $LOAD_PATH (Default: [\"lib\", \"test\"])" do |load_path|
           options[:load_paths] ||= []
           options[:load_paths] += load_path
         end
@@ -82,7 +82,19 @@ class TLDR
           options[:warnings] = warnings
         end
 
-        opts.on "--comment COMMENT", String, "No-op comment, used internally for multi-line execution instructions" do
+        opts.on CONFLAGS[:watch], "Run your tests continuously on file save (requires 'fswatch' to be installed)" do
+          options[:watch] = true
+        end
+
+        opts.on CONFLAGS[:yes_i_know], "Suppress TLDR report when suite runs over 1.8s" do
+          options[:yes_i_know] = true
+        end
+
+        opts.on CONFLAGS[:i_am_being_watched], "[INTERNAL] Signals to tldr it is being invoked under --watch mode" do
+          options[:i_am_being_watched] = true
+        end
+
+        opts.on "--comment COMMENT", String, "[INTERNAL] No-op; used for multi-line execution instructions" do
           # See "--comment" in lib/tldr/reporters/default.rb for an example of how this is used internally
         end
       end.parse!(args)

data/lib/tldr/assertions/minitest_compatibility.rb

@@ -34,7 +34,7 @@ class TLDR
         assert receiver.__send__(method, *args), message
       end
 
-      def capture_io(&blk)
+      def capture_io &blk
         Assertions.capture_io(&blk)
       end
 

data/lib/tldr/assertions.rb

@@ -74,7 +74,7 @@ class TLDR
     end
 
     def assert_equal expected, actual, message = nil
-      message = Assertions.msg(message) { Assertions.diff expected, actual }
+      message = Assertions.msg(message) { Assertions.diff(expected, actual) }
       assert expected == actual, message
     end
 
@@ -158,7 +158,7 @@ class TLDR
         "Expected #{Assertions.h(actual)} to match #{Assertions.h(matcher)}"
       }
       assert_respond_to matcher, :=~
-      matcher = Regexp.new Regexp.escape matcher if String === matcher
+      matcher = Regexp.new(Regexp.escape(matcher)) if String === matcher
       assert matcher =~ actual, message
       Regexp.last_match
     end
@@ -294,7 +294,7 @@ class TLDR
             "---Backtrace---",
             TLDR.filter_backtrace(e.backtrace).join("\n"),
             "---------------"
-          ].compact.join "\n"
+          ].compact.join("\n")
         }
       end
 

data/lib/tldr/backtrace_filter.rb

@@ -14,19 +14,19 @@ class TLDR
     private
 
     def trim_leading_frames backtrace
-      if (trimmed = backtrace.take_while { |frame| meaningful? frame }).any?
+      if (trimmed = backtrace.take_while { |frame| meaningful?(frame) }).any?
         trimmed
       end
     end
 
     def trim_internal_frames backtrace
-      if (trimmed = backtrace.select { |frame| meaningful? frame }).any?
+      if (trimmed = backtrace.select { |frame| meaningful?(frame) }).any?
         trimmed
       end
     end
 
     def meaningful? frame
-      !internal? frame
+      !internal?(frame)
     end
 
     def internal? frame
@@ -35,6 +35,6 @@ class TLDR
   end
 
   def self.filter_backtrace backtrace
-    BacktraceFilter.new.filter backtrace
+    BacktraceFilter.new.filter(backtrace)
   end
 end

data/lib/tldr/class_util.rb

@@ -2,13 +2,13 @@ class TLDR
   module ClassUtil
     def self.gather_descendants root_klass
       root_klass.subclasses + root_klass.subclasses.flat_map { |subklass|
-        gather_descendants subklass
+        gather_descendants(subklass)
       }
     end
 
     def self.gather_tests klass
       klass.instance_methods.grep(/^test_/).sort.map { |method|
-        Test.new klass, method
+        Test.new(klass, method)
       }
     end
   end

data/lib/tldr/path_util.rb

@@ -1,7 +1,7 @@
 class TLDR
   module PathUtil
     def self.expand_paths path_strings, globs: true
-      path_strings = expand_globs path_strings if globs
+      path_strings = expand_globs(path_strings) if globs
 
       path_strings.flat_map { |path_string|
         File.directory?(path_string) ? Dir["#{path_string}/**/*.rb"] : path_string
@@ -10,7 +10,7 @@ class TLDR
         line_numbers = path_string.scan(/:(\d+)/).flatten.map(&:to_i)
 
         if line_numbers.any?
-          line_numbers.map { |line_number| Location.new absolute_path, line_number }
+          line_numbers.map { |line_number| Location.new(absolute_path, line_number) }
         else
           [Location.new(absolute_path, nil)]
         end

data/lib/tldr/planner.rb

@@ -8,14 +8,14 @@ class TLDR
 
     def plan config
       $VERBOSE = config.warnings
-      search_locations = PathUtil.expand_paths config.paths, globs: false
+      search_locations = PathUtil.expand_paths(config.paths, globs: false)
 
-      prepend_load_paths config
-      require_test_helper config
-      require_tests search_locations
+      prepend_load_paths(config)
+      require_test_helper(config)
+      require_tests(search_locations)
 
       tests = gather_tests
-      config.update_after_gathering_tests! tests
+      config.update_after_gathering_tests!(tests)
       tests_to_run = prepend(
         shuffle(
           exclude_by_path(
@@ -40,7 +40,7 @@ class TLDR
         config
       )
 
-      Plan.new tests_to_run, strategy
+      Plan.new(tests_to_run, strategy)
     end
 
     private
@@ -53,9 +53,9 @@ class TLDR
 
     def prepend tests, config
       return tests if config.no_prepend
-      prepended_locations = PathUtil.expand_paths config.prepend_paths
+      prepended_locations = PathUtil.expand_paths(config.prepend_paths)
       prepended, rest = tests.partition { |test|
-        PathUtil.locations_include_test? prepended_locations, test
+        PathUtil.locations_include_test?(prepended_locations, test)
       }
       prepended + rest
     end
@@ -65,18 +65,18 @@ class TLDR
     end
 
     def exclude_by_path tests, exclude_paths
-      excluded_locations = PathUtil.expand_paths exclude_paths
+      excluded_locations = PathUtil.expand_paths(exclude_paths)
       return tests if excluded_locations.empty?
 
       tests.reject { |test|
-        PathUtil.locations_include_test? excluded_locations, test
+        PathUtil.locations_include_test?(excluded_locations, test)
       }
     end
 
     def exclude_by_name tests, exclude_names
       return tests if exclude_names.empty?
 
-      name_excludes = expand_names_with_patterns exclude_names
+      name_excludes = expand_names_with_patterns(exclude_names)
 
       tests.reject { |test|
         name_excludes.any? { |filter|
@@ -90,14 +90,14 @@ class TLDR
       return tests if line_specific_locations.empty?
 
       tests.select { |test|
-        PathUtil.locations_include_test? line_specific_locations, test
+        PathUtil.locations_include_test?(line_specific_locations, test)
       }
     end
 
     def filter_by_name tests, names
       return tests if names.empty?
 
-      name_filters = expand_names_with_patterns names
+      name_filters = expand_names_with_patterns(names)
 
       tests.select { |test|
         name_filters.any? { |filter|
@@ -108,7 +108,7 @@ class TLDR
 
     def prepend_load_paths config
       config.load_paths.each do |load_path|
-        $LOAD_PATH.unshift File.expand_path(load_path, Dir.pwd)
+        $LOAD_PATH.unshift(File.expand_path(load_path, Dir.pwd))
       end
     end
 
@@ -130,7 +130,7 @@ class TLDR
     def expand_names_with_patterns names
       names.map { |name|
         if name.is_a?(String) && name =~ /^\/(.*)\/$/
-          Regexp.new $1
+          Regexp.new($1)
         else
           name
         end

data/lib/tldr/rake.rb

@@ -7,7 +7,7 @@ class TLDR
   class Task
     include Rake::DSL
 
-    def initialize(name: "tldr", config: Config.new)
+    def initialize name: "tldr", config: Config.new
       define name, config
     end
 

data/lib/tldr/reporters/base.rb

@@ -1,7 +1,7 @@
 class TLDR
   module Reporters
     class Base
-      def initialize(config, out = $stdout, err = $stderr)
+      def initialize config, out = $stdout, err = $stderr
         out.sync = true
         err.sync = true
 

data/lib/tldr/reporters/default.rb

@@ -1,13 +1,14 @@
 class TLDR
   module Reporters
     class Default < Base
-      def initialize(config, out = $stdout, err = $stderr)
+      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
+        clear_screen_if_being_watched!
+        @suite_start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
         @out.print <<~MSG
           Command: #{tldr_command} #{@config.to_full_args}
           #{@icons.seed} #{CONFLAGS[:seed]} #{@config.seed}
@@ -31,32 +32,34 @@ class TLDR
         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
+        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")
+
+        if @config.yes_i_know
+          @err.print "🚨 TLDR! Display summary by omitting --yes-i-know"
+        else
+          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),
+              "🙈 Suppress this summary with --yes-i-know"
+            ].compact.join("\n\n")
+          end
         end
 
-        after_suite test_results
+        after_suite(test_results)
       end
 
       def after_fail_fast planned_tests, wip_tests, test_results, last_result
@@ -66,17 +69,17 @@ class TLDR
         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?),
+            ("#{@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
+        after_suite(test_results)
       end
 
       def after_suite test_results
-        duration = time_diff @suite_start_time
+        duration = time_diff(@suite_start_time)
         test_results = test_results.sort_by { |result| [result.test.location.file, result.test.location.line] }
 
         @err.print summarize_failures(test_results).join("\n\n")
@@ -102,11 +105,15 @@ class TLDR
 
       private
 
+      def time_diff start, stop = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+        ((stop - start) / 1000.0).round
+      end
+
       def summarize_failures results
         failures = results.select { |result| result.failing? }
         return failures if failures.empty?
 
-        ["\n\nFailing tests:"] + failures.map.with_index { |result, i| summarize_result result, i }
+        ["\n\nFailing tests:"] + failures.map.with_index { |result, i| summarize_result(result, i) }
       end
 
       def summarize_result result, index
@@ -138,22 +145,22 @@ class TLDR
         rule = @icons.alarm + "=" * 20 + " ABORTED RUN " + "=" * 20 + @icons.alarm
         @err.print "#{rule}\n\n"
         yield
-        @err.print "\n\n#{rule}\n\n"
+        @err.print "\n\n#{rule}"
       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
+        unrun_locators = consolidate(unrun)
         failed = test_results.select(&:failing?).map(&:test)
-        failed_locators = consolidate failed, exclude: unrun_locators
+        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
+          ("--comment \"Also include #{plural(failed.size, "test")} that failed:\"" if failed_locators.any?)
+        ].compact + 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    ")}
+          #{@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
 
@@ -166,6 +173,12 @@ class TLDR
       def tldr_command
         "#{"bundle exec " if defined?(Bundler)}tldr"
       end
+
+      def clear_screen_if_being_watched!
+        if @config.i_am_being_watched
+          @out.print "\e[2J\e[f"
+        end
+      end
     end
   end
 end

data/lib/tldr/runner.rb

@@ -6,7 +6,7 @@ class TLDR
       @executor = Executor.new
       @wip = Concurrent::Array.new
       @results = Concurrent::Array.new
-      @run_aborted = Concurrent::AtomicBoolean.new false
+      @run_aborted = Concurrent::AtomicBoolean.new(false)
     end
 
     def run config, plan
@@ -20,11 +20,11 @@ class TLDR
           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
+          reporter.after_tldr(plan.tests, @wip.dup, @results.dup)
+          exit!(3)
         end
 
-        sleep 1.8
+        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
@@ -41,8 +41,8 @@ class TLDR
       end
 
       unless @run_aborted.true?
-        reporter.after_suite results
-        exit exit_code results
+        reporter.after_suite(results)
+        exit(exit_code(results))
       end
     end
 
@@ -51,12 +51,12 @@ class TLDR
     def run_test test, config, plan, reporter
       e = nil
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-      wip_test = WIPTest.new test, start_time
+      wip_test = WIPTest.new(test, start_time)
       @wip << wip_test
       runtime = time_it(start_time) do
         instance = test.test_class.new
-        instance.setup if instance.respond_to? :setup
-        if instance.respond_to? :around
+        instance.setup if instance.respond_to?(:setup)
+        if instance.respond_to?(:around)
           did_run = false
           instance.around {
             did_run = true
@@ -66,15 +66,15 @@ class TLDR
         else
           instance.send(test.method_name)
         end
-        instance.teardown if instance.respond_to? :teardown
+        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
+        @wip.delete(wip_test)
+        reporter.after_test(result)
+        fail_fast(reporter, plan, result) if result.failing? && config.fail_fast
       end
     end
 
@@ -82,8 +82,8 @@ class TLDR
       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])
+          reporter.after_fail_fast(plan.tests, @wip.dup, @results.dup, fast_failed_result)
+          exit!(exit_code([fast_failed_result]))
         end
 
         if IRB.CurrentContext
@@ -94,7 +94,7 @@ class TLDR
       end
     end
 
-    def time_it(start)
+    def time_it start
       yield
       ((Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start) / 1000.0).round
     end

data/lib/tldr/strategizer.rb

@@ -1,8 +1,8 @@
 class TLDR
   class Strategizer
-    Strategy = Struct.new :parallel?, :prepend_sequential_tests,
+    Strategy = Struct.new(:parallel?, :prepend_sequential_tests,
       :parallel_tests_and_groups, :append_sequential_tests,
-      keyword_init: true
+      keyword_init: true)
 
     # Combine all discovered test methods with any methods grouped by run_these_together!
     #
@@ -16,11 +16,11 @@ class TLDR
       thread_unsafe_tests, thread_safe_tests = partition_unsafe(all_tests, thread_unsafe_test_groups)
       prepend_sequential_tests, append_sequential_tests = partition_prepend(thread_unsafe_tests, config)
 
-      grouped_tests = prepare_run_together_groups run_these_together_groups, thread_safe_tests, append_sequential_tests
+      grouped_tests = prepare_run_together_groups(run_these_together_groups, thread_safe_tests, append_sequential_tests)
       already_included_groups = []
       parallel_tests_and_groups = thread_safe_tests.map { |test|
-        if (group = grouped_tests.find { |group| group.tests.include? test })
-          if already_included_groups.include? group
+        if (group = grouped_tests.find { |group| group.tests.include?(test) })
+          if already_included_groups.include?(group)
             next
           elsif (other = already_included_groups.find { |other| (group.tests & other.tests).any? })
             other.tests |= group.tests
@@ -49,7 +49,7 @@ class TLDR
 
     def partition_unsafe tests, thread_unsafe_test_groups
       tests.partition { |test|
-        thread_unsafe_test_groups.any? { |group| group.tests.include? test }
+        thread_unsafe_test_groups.any? { |group| group.tests.include?(test) }
       }
     end
 
@@ -57,10 +57,10 @@ class TLDR
     # Suboptimal, but we do indeed need to do this work in two places ¯\_(ツ)_/¯
     def partition_prepend thread_unsafe_tests, config
       prepend_paths = config.no_prepend ? [] : config.prepend_paths
-      locations = PathUtil.expand_paths prepend_paths
+      locations = PathUtil.expand_paths(prepend_paths)
 
       thread_unsafe_tests.partition { |test|
-        PathUtil.locations_include_test? locations, test
+        PathUtil.locations_include_test?(locations, test)
       }
     end
 

data/lib/tldr/value/config.rb

@@ -17,6 +17,9 @@ class TLDR
     base_path: "--base-path",
     no_dotfile: "--no-dotfile",
     warnings: "--[no-]warnings",
+    watch: "--watch",
+    yes_i_know: "--yes-i-know",
+    i_am_being_watched: "--i-am-being-watched",
     paths: nil
   }.freeze
 
@@ -26,7 +29,7 @@ class TLDR
     :paths, :seed, :no_helper, :verbose, :reporter,
     :helper_paths, :load_paths, :parallel, :names, :fail_fast, :no_emoji,
     :prepend_paths, :no_prepend, :exclude_paths, :exclude_names, :base_path,
-    :no_dotfile, :warnings,
+    :no_dotfile, :warnings, :watch, :yes_i_know, :i_am_being_watched,
     # Internal properties
     :config_intended_for_merge_only, :seed_set_intentionally, :cli_defaults
   ].freeze
@@ -64,14 +67,17 @@ class TLDR
         exclude_paths: [],
         exclude_names: [],
         base_path: nil,
-        warnings: true
+        warnings: true,
+        watch: false,
+        yes_i_know: false,
+        i_am_being_watched: false
       }
 
       if cli_defaults
         common.merge(
           paths: Dir["test/**/*_test.rb", "test/**/test_*.rb"],
           helper_paths: ["test/helper.rb"],
-          load_paths: ["test"],
+          load_paths: ["lib", "test"],
           prepend_paths: [MOST_RECENTLY_MODIFIED_TAG]
         )
       else
@@ -101,7 +107,7 @@ class TLDR
       end
 
       # Booleans
-      [:no_helper, :verbose, :fail_fast, :no_emoji, :no_prepend, :warnings].each do |key|
+      [:no_helper, :verbose, :fail_fast, :no_emoji, :no_prepend, :warnings, :yes_i_know, :i_am_being_watched].each do |key|
         merged_args[key] = defaults[key] if merged_args[key].nil?
       end
 
@@ -129,26 +135,34 @@ class TLDR
 
       self.prepend_paths = prepend_paths.map { |path|
         if path == MOST_RECENTLY_MODIFIED_TAG
-          most_recently_modified_test_file tests
+          most_recently_modified_test_file(tests)
         else
           path
         end
       }.compact
     end
 
-    def to_full_args(exclude: [])
-      to_cli_argv(
+    def to_full_args exclude: [], ensure_args: []
+      argv = to_cli_argv(
         CONFLAGS.keys -
         exclude - [
-          (:seed unless seed_set_intentionally)
+          (:seed unless seed_set_intentionally),
+          :watch,
+          :i_am_being_watched
         ]
-      ).join(" ")
+      )
+
+      ensure_args.each do |arg|
+        argv << arg unless argv.include?(arg)
+      end
+
+      argv.join(" ")
     end
 
-    def to_single_path_args(path)
+    def to_single_path_args path
       argv = to_cli_argv(CONFLAGS.keys - [
         :seed, :parallel, :names, :fail_fast, :paths, :prepend_paths,
-        :no_prepend, :exclude_paths
+        :no_prepend, :exclude_paths, :watch, :i_am_being_watched
       ])
 
       (argv + [stringify(:paths, path)]).join(" ")
@@ -210,7 +224,7 @@ class TLDR
       end
     end
 
-    def most_recently_modified_test_file(tests)
+    def most_recently_modified_test_file tests
       return if tests.empty?
 
       tests.max_by { |test| File.mtime(test.file) }.file
@@ -220,11 +234,11 @@ class TLDR
     # 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)
+    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)
+    def merge_dotfile_args args
       return args if args[:no_dotfile] || !File.exist?(".tldr.yml")
       require "yaml"
 

data/lib/tldr/value/location.rb

@@ -1,5 +1,5 @@
 class TLDR
-  Location = Struct.new :file, :line do
+  Location = Struct.new(:file, :line) do
     def relative
       if file.start_with?(Dir.pwd)
         file[Dir.pwd.length + 1..]

data/lib/tldr/value/plan.rb

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

data/lib/tldr/value/test.rb

@@ -1,17 +1,17 @@
 class TLDR
-  Test = Struct.new :test_class, :method_name do
+  Test = Struct.new(:test_class, :method_name) do
     attr_reader :file, :line, :location
 
     def initialize(*args)
       super
       @file, @line = SorbetCompatibility.unwrap_method(test_class.instance_method(method_name)).source_location
-      @location = Location.new file, line
+      @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 test_class.instance_method(method_name)
+        test_method = SorbetCompatibility.unwrap_method(test_class.instance_method(method_name))
         RubyVM::AbstractSyntaxTree.of(test_method).last_lineno
       end
     end

data/lib/tldr/value/test_group.rb

@@ -1,16 +1,16 @@
 class TLDR
-  TestGroup = Struct.new :configuration do
+  TestGroup = Struct.new(:configuration) do
     attr_writer :tests
 
     def tests
       @tests ||= configuration.flat_map { |(klass, method)|
-        klass = Kernel.const_get(klass) if klass.is_a? String
+        klass = Kernel.const_get(klass) if klass.is_a?(String)
         if method.nil?
           ([klass] + ClassUtil.gather_descendants(klass)).flat_map { |klass|
             ClassUtil.gather_tests(klass)
           }
         else
-          Test.new klass, method
+          Test.new(klass, method)
         end
       }
     end

data/lib/tldr/value/test_result.rb

@@ -1,5 +1,5 @@
 class TLDR
-  TestResult = Struct.new :test, :error, :runtime do
+  TestResult = Struct.new(:test, :error, :runtime) do
     attr_reader :type, :error_location
 
     def initialize(*args)

data/lib/tldr/value/wip_test.rb

@@ -1,3 +1,3 @@
 class TLDR
-  WIPTest = Struct.new :test, :start_time
+  WIPTest = Struct.new(:test, :start_time)
 end

data/lib/tldr/version.rb

@@ -1,3 +1,3 @@
 class TLDR
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

data/lib/tldr/watcher.rb

@@ -0,0 +1,32 @@
+class TLDR
+  class Watcher
+    def watch config
+      require_fs_watch!
+      command = "fswatch -o #{config.load_paths.reverse.join(" ")} | xargs -n1 -I{} #{tldr_command} #{config.to_full_args}"
+
+      puts <<~MSG
+        Watching #{config.load_paths.map(&:inspect).join(", ")} for changes...
+      MSG
+
+      exec command
+    end
+
+    private
+
+    def require_fs_watch!
+      `which fswatch`
+      return if $?.success?
+
+      warn <<~MSG
+        Error: fswatch must be installed and on your PATH to run TLDR in --watch mode
+
+        See: https://github.com/emcrisostomo/fswatch
+      MSG
+      exit 1
+    end
+
+    def tldr_command
+      "#{"bundle exec " if defined?(Bundler)}tldr"
+    end
+  end
+end

data/lib/tldr.rb

@@ -16,6 +16,7 @@ require_relative "tldr/sorbet_compatibility"
 require_relative "tldr/strategizer"
 require_relative "tldr/value"
 require_relative "tldr/version"
+require_relative "tldr/watcher"
 
 class TLDR
   include Assertions
@@ -29,25 +30,29 @@ class TLDR
 
   module Run
     def self.cli argv
-      config = ArgvParser.new.parse argv
-      tests config
+      config = ArgvParser.new.parse(argv)
+      tests(config)
     end
 
     def self.tests config = Config.new
-      Runner.new.run config, Planner.new.plan(config)
+      if config.watch
+        Watcher.new.watch(config)
+      else
+        Runner.new.run(config, Planner.new.plan(config))
+      end
     end
 
     @@at_exit_registered = false
     def self.at_exit! config = Config.new
       # Ignore at_exit when running tldr CLI, since that will run any tests
-      return if $PROGRAM_NAME.end_with? "tldr"
+      return if $PROGRAM_NAME.end_with?("tldr")
       # Also ignore if we're running from within our rake task
-      return if caller.any? { |line| line.include? "lib/tldr/rake.rb" }
+      return if caller.any? { |line| line.include?("lib/tldr/rake.rb") }
       # Ignore at_exit when we've already registered an at_exit hook
       return if @@at_exit_registered
 
       Kernel.at_exit do
-        Run.tests config
+        Run.tests(config)
       end
 
       @@at_exit_registered = true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tldr
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Justin Searls
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-03 00:00:00.000000000 Z
+date: 2023-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: super_diff
@@ -85,6 +85,7 @@ files:
 - lib/tldr/value/test_result.rb
 - lib/tldr/value/wip_test.rb
 - lib/tldr/version.rb
+- lib/tldr/watcher.rb
 - script/setup
 - script/test
 homepage: https://github.com/tenderlove/tldr