tldr 0.10.1 → 1.0.0

data/lib/tldr/value/config.rb

@@ -1,25 +1,26 @@
 class TLDR
   CONFLAGS = {
-    seed: "--seed",
-    no_helper: "--no-helper",
-    verbose: "--verbose",
-    print_interrupted_test_backtraces: "--print-interrupted-test-backtraces",
-    reporter: "--reporter",
-    helper_paths: "--helper",
-    load_paths: "--load-path",
+    timeout: "--[no-]timeout",
+    watch: "--watch",
+    fail_fast: "--fail-fast",
     parallel: "--[no-]parallel",
+    seed: "--seed",
     names: "--name",
-    fail_fast: "--fail-fast",
-    no_emoji: "--no-emoji",
+    exclude_names: "--exclude-name",
+    exclude_paths: "--exclude-path",
+    helper_paths: "--helper",
+    no_helper: "--no-helper",
     prepend_paths: "--prepend",
     no_prepend: "--no-prepend",
-    exclude_paths: "--exclude-path",
-    exclude_names: "--exclude-name",
+    load_paths: "--load-path",
     base_path: "--base-path",
-    no_dotfile: "--no-dotfile",
+    config_path: "--[no-]config",
+    reporter: "--reporter",
+    emoji: "--[no-]emoji",
     warnings: "--[no-]warnings",
-    watch: "--watch",
+    verbose: "--verbose",
     yes_i_know: "--yes-i-know",
+    print_interrupted_test_backtraces: "--print-interrupted-test-backtraces",
     i_am_being_watched: "--i-am-being-watched",
     paths: nil
   }.freeze
@@ -27,20 +28,23 @@ class TLDR
   PATH_FLAGS = [:paths, :helper_paths, :load_paths, :prepend_paths, :exclude_paths].freeze
   MOST_RECENTLY_MODIFIED_TAG = "MOST_RECENTLY_MODIFIED".freeze
   CONFIG_ATTRIBUTES = [
-    :paths, :seed, :no_helper, :verbose, :print_interrupted_test_backtraces, :reporter,
-    :helper_paths, :load_paths, :parallel, :names, :fail_fast, :no_emoji,
-    :prepend_paths, :no_prepend, :exclude_paths, :exclude_names, :base_path,
-    :no_dotfile, :warnings, :watch, :yes_i_know, :i_am_being_watched,
+    :timeout, :watch, :fail_fast, :parallel, :seed, :names, :exclude_names,
+    :exclude_paths, :helper_paths, :no_helper, :prepend_paths, :no_prepend,
+    :load_paths, :base_path, :config_path, :reporter, :emoji, :warnings,
+    :verbose, :yes_i_know, :print_interrupted_test_backtraces,
+    :i_am_being_watched, :paths,
     # Internal properties
     :config_intended_for_merge_only, :seed_set_intentionally, :cli_defaults
   ].freeze
 
   Config = Struct.new(*CONFIG_ATTRIBUTES, keyword_init: true) do
     def initialize(**args)
+      @argv_reconstructor = ArgvReconstructor.new
+
       original_base_path = Dir.pwd
       unless args[:config_intended_for_merge_only]
         change_working_directory_because_i_am_bad_and_i_should_feel_bad!(args[:base_path])
-        args = merge_dotfile_args(args) unless args[:no_dotfile]
+        args = merge_dotfile_args(args) unless args[:config_path].nil?
       end
       args = undefault_parallel_if_seed_set(args)
       unless args[:config_intended_for_merge_only]
@@ -54,50 +58,53 @@ class TLDR
     # These are for internal tracking and resolved at initialization-time
     undef_method :config_intended_for_merge_only=, :seed_set_intentionally=,
       # These must be set when the Config is first initialized
-      :cli_defaults=, :no_dotfile=, :base_path=
+      :cli_defaults=, :config_path=, :base_path=
 
     def self.build_defaults cli_defaults: true
       common = {
-        seed: rand(10_000),
-        no_helper: false,
-        verbose: false,
-        print_interrupted_test_backtraces: false,
-        reporter: Reporters::Default,
+        timeout: -1,
+        watch: false,
+        fail_fast: false,
         parallel: true,
+        seed: rand(10_000),
         names: [],
-        fail_fast: false,
-        no_emoji: false,
-        no_prepend: false,
-        exclude_paths: [],
         exclude_names: [],
+        exclude_paths: [],
+        no_helper: false,
+        no_prepend: false,
         base_path: nil,
+        reporter: "TLDR::Reporters::Default",
+        emoji: false,
         warnings: true,
-        watch: false,
+        verbose: false,
         yes_i_know: false,
+        print_interrupted_test_backtraces: false,
         i_am_being_watched: false
       }
 
       if cli_defaults
         common.merge(
-          paths: Dir["test/**/*_test.rb", "test/**/test_*.rb"],
           helper_paths: ["test/helper.rb"],
+          prepend_paths: [MOST_RECENTLY_MODIFIED_TAG],
           load_paths: ["lib", "test"],
-          prepend_paths: [MOST_RECENTLY_MODIFIED_TAG]
+          config_path: nil,
+          paths: Dir["test/**/*_test.rb", "test/**/test_*.rb"]
         )
       else
         common.merge(
-          paths: [],
           helper_paths: [],
+          prepend_paths: [],
           load_paths: [],
-          prepend_paths: []
+          config_path: Config::DEFAULT_YAML_PATH, # ArgvParser#parse will set this default and if it sets nil that is intentionally blank b/c --no-config
+          paths: []
         )
       end
     end
 
     def undefault_parallel_if_seed_set args
       args.merge(
-        seed_set_intentionally: !args[:seed].nil?,
-        parallel: (args[:parallel].nil? ? args[:seed].nil? : args[:parallel])
+        parallel: (args[:parallel].nil? ? args[:seed].nil? : args[:parallel]),
+        seed_set_intentionally: !args[:seed].nil?
       )
     end
 
@@ -106,17 +113,17 @@ class TLDR
       defaults = Config.build_defaults(cli_defaults: merged_args[:cli_defaults])
 
       # Arrays
-      [:paths, :helper_paths, :load_paths, :names, :prepend_paths, :exclude_paths, :exclude_names].each do |key|
+      [:names, :exclude_names, :exclude_paths, :helper_paths, :prepend_paths, :load_paths, :paths].each do |key|
         merged_args[key] = defaults[key] if merged_args[key].nil? || merged_args[key].empty?
       end
 
       # Booleans
-      [:no_helper, :verbose, :print_interrupted_test_backtraces, :fail_fast, :no_emoji, :no_prepend, :warnings, :yes_i_know, :i_am_being_watched].each do |key|
+      [:watch, :fail_fast, :parallel, :no_helper, :no_prepend, :emoji, :warnings, :verbose, :yes_i_know, :print_interrupted_test_backtraces, :i_am_being_watched].each do |key|
         merged_args[key] = defaults[key] if merged_args[key].nil?
       end
 
       # Values
-      [:seed, :reporter].each do |key|
+      [:timeout, :seed, :base_path, :config_path, :reporter].each do |key|
         merged_args[key] ||= defaults[key]
       end
 
@@ -147,87 +154,20 @@ class TLDR
     end
 
     def to_full_args exclude: [], ensure_args: [], exclude_dotfile_matches: false
-      argv = to_cli_argv(
-        CONFLAGS.keys - exclude - [
-          (:seed unless seed_set_intentionally),
-          :watch,
-          :i_am_being_watched
-        ],
-        exclude_dotfile_matches:
-      )
-
-      ensure_args.each do |arg|
-        argv << arg unless argv.include?(arg)
-      end
-
-      argv.join(" ")
+      @argv_reconstructor.reconstruct(self, exclude:, ensure_args:, exclude_dotfile_matches:)
     end
 
     def to_single_path_args path, exclude_dotfile_matches: false
-      argv = to_cli_argv(CONFLAGS.keys - [
-        :seed, :parallel, :names, :fail_fast, :paths, :prepend_paths,
-        :no_prepend, :exclude_paths, :watch, :i_am_being_watched
-      ], exclude_dotfile_matches:)
-
-      (argv + [stringify(:paths, path)]).join(" ")
+      @argv_reconstructor.reconstruct_single_path_args(self, path, exclude_dotfile_matches:)
     end
 
-    private
-
-    def to_cli_argv options = CONFLAGS.keys, exclude_dotfile_matches:
-      defaults = Config.build_defaults(cli_defaults: true)
-      defaults = defaults.merge(dotfile_args) if exclude_dotfile_matches
-      options.map { |key|
-        flag = CONFLAGS[key]
-
-        # Special cases
-        if key == :prepend_paths
-          if prepend_paths.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_paths && 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
-        elsif key == :warnings && defaults[:warnings] != self[:warnings]
-          next warnings ? "--warnings" : "--no-warnings"
-        end
+    def dotfile_args config_path
+      return {} unless File.exist?(config_path)
 
-        if defaults[key] == self[key] && (key != :seed || !seed_set_intentionally)
-          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
+      @dotfile_args ||= YamlParser.new.parse(config_path)
     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
+    private
 
     def most_recently_modified_test_file tests
       return if tests.empty?
@@ -248,28 +188,10 @@ class TLDR
     end
 
     def merge_dotfile_args args
-      return args if args[:no_dotfile]
-
-      dotfile_args.merge(args)
-    end
-
-    def dotfile_args
-      return {} unless File.exist?(".tldr.yml")
-
-      require "yaml"
-      @dotfile_args ||= YAML.load_file(".tldr.yml").transform_keys { |k| k.to_sym }.tap do |dotfile_args|
-        # 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
-        if (invalid_args = dotfile_args.except(*CONFIG_ATTRIBUTES)).any?
-          raise Error, "Invalid keys in .tldr.yml file: #{invalid_args.keys.join(", ")}"
-        end
-      end
+      dotfile_args(args[:config_path]).merge(args)
     end
   end
+
+  Config::DEFAULT_YAML_PATH = ".tldr.yml"
+  Config::DEFAULT_TIMEOUT = 1.8
 end

data/lib/tldr/version.rb

@@ -1,3 +1,3 @@
 class TLDR
-  VERSION = "0.10.1"
+  VERSION = "1.0.0"
 end

data/lib/tldr/yaml_parser.rb

@@ -0,0 +1,29 @@
+require "optparse"
+
+class TLDR
+  class YamlParser
+    def parse path
+      require "yaml"
+      YAML.load_file(path)
+        .transform_keys { |k| k.to_sym }
+        .tap do |dotfile_args|
+          # 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
+          if dotfile_args.key?(:timeout)
+            dotfile_args[:timeout] = case dotfile_args[:timeout]
+            when true then Config::DEFAULT_TIMEOUT
+            when false then -1
+            when String then Float(dotfile_args[:timeout])
+            else dotfile_args[:timeout]
+            end
+          end
+
+          if (invalid_args = dotfile_args.except(*CONFIG_ATTRIBUTES)).any?
+            raise Error, "Invalid keys in #{File.basename(path)} file: #{invalid_args.keys.join(", ")}"
+          end
+        end
+    end
+  end
+end

data/lib/tldr.rb

@@ -1,6 +1,7 @@
 require "concurrent-ruby"
 
 require_relative "tldr/argv_parser"
+require_relative "tldr/argv_reconstructor"
 require_relative "tldr/assertions"
 require_relative "tldr/backtrace_filter"
 require_relative "tldr/class_util"
@@ -10,6 +11,7 @@ require_relative "tldr/hooks"
 require_relative "tldr/parallel_controls"
 require_relative "tldr/path_util"
 require_relative "tldr/planner"
+require_relative "tldr/minitest_compatibility"
 require_relative "tldr/reporters"
 require_relative "tldr/ruby_util"
 require_relative "tldr/runner"
@@ -19,6 +21,7 @@ require_relative "tldr/strategizer"
 require_relative "tldr/value"
 require_relative "tldr/version"
 require_relative "tldr/watcher"
+require_relative "tldr/yaml_parser"
 
 class TLDR
   include Assertions

data/script/test

@@ -5,10 +5,10 @@ set -e
 bundle exec rake
 
 cd example/a
-bundle exec tldr | grep "😁😁"
+bundle exec tldr | ruby -e 'exit(ARGF.read =~ /\n..\n/ ? 0 : 1)'
 cd ../..
 
 cd example/b
-bundle exec ruby -Itest test/some_test.rb | grep "😁"
-bundle exec rake tldr | grep "😁"
+bundle exec ruby -Itest test/some_test.rb | ruby -e 'exit(ARGF.read =~ /\n.\n/ ? 0 : 1)'
+bundle exec rake tldr | ruby -e 'exit(ARGF.read =~ /\n.\n/ ? 0 : 1)'
 cd ../..

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: tldr
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Justin Searls
 - Aaron Patterson
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-26 00:00:00.000000000 Z
+date: 2025-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: super_diff
@@ -38,6 +39,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description:
 email:
 - searls@gmail.com
 - tenderlove@ruby-lang.org
@@ -56,13 +72,15 @@ files:
 - exe/tldt
 - lib/tldr.rb
 - lib/tldr/argv_parser.rb
+- lib/tldr/argv_reconstructor.rb
 - lib/tldr/assertions.rb
-- lib/tldr/assertions/minitest_compatibility.rb
+- lib/tldr/autorun.rb
 - lib/tldr/backtrace_filter.rb
 - lib/tldr/class_util.rb
 - lib/tldr/error.rb
 - lib/tldr/executor.rb
 - lib/tldr/hooks.rb
+- lib/tldr/minitest_compatibility.rb
 - lib/tldr/parallel_controls.rb
 - lib/tldr/path_util.rb
 - lib/tldr/planner.rb
@@ -86,6 +104,7 @@ files:
 - lib/tldr/value/wip_test.rb
 - lib/tldr/version.rb
 - lib/tldr/watcher.rb
+- lib/tldr/yaml_parser.rb
 - script/setup
 - script/test
 - script/upgrade
@@ -96,6 +115,7 @@ metadata:
   homepage_uri: https://github.com/tendersearls/tldr
   source_code_uri: https://github.com/tendersearls/tldr
   changelog_uri: https://github.com/tendersearls/tldr/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -110,7 +130,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.3.27
+signing_key:
 specification_version: 4
 summary: TLDR will run your tests, but only for 1.8 seconds.
 test_files: []

data/lib/tldr/assertions/minitest_compatibility.rb

@@ -1,55 +0,0 @@
-# These methods are provided only for drop-in compatibility with Minitest:
-#
-#   require "tldr/assertions/minitest"
-#
-# Will load these methods for use in your tests
-#
-# While all the methods in this file were written for TLDR, they were designed
-# to maximize compatibility with minitest's assertions API and messages here:
-#
-#   https://github.com/minitest/minitest/blob/master/lib/minitest/assertions.rb
-#
-# As a result, many implementations are extremely similar to those found in
-# minitest. Any such implementations are Copyright © Ryan Davis, seattle.rb and
-# distributed under the MIT License
-
-class TLDR
-  module Assertions
-    module MinitestCompatibility
-      def assert_includes actual, expected, message = nil
-        assert_include? expected, actual, message
-      end
-
-      def refute_includes actual, expected, message = nil
-        refute_include? expected, actual, message
-      end
-
-      def assert_send receiver_method_args, message = nil
-        warn "DEPRECATED: assert_send. From #{TLDR.filter_backtrace(caller).first}"
-        receiver, method, *args = receiver_method_args
-        message = Assertions.msg(message) {
-          "Expected #{Assertions.h(receiver)}.#{method}(*#{Assertions.h(args)}) to return true"
-        }
-
-        assert receiver.__send__(method, *args), message
-      end
-
-      def capture_io &blk
-        Assertions.capture_io(&blk)
-      end
-
-      def mu_pp obj
-        s = obj.inspect.encode(Encoding.default_external)
-
-        if String === obj && (obj.encoding != Encoding.default_external ||
-                              !obj.valid_encoding?)
-          enc = "# encoding: #{obj.encoding}"
-          val = "#    valid: #{obj.valid_encoding?}"
-          "#{enc}\n#{val}\n#{s}"
-        else
-          s
-        end
-      end
-    end
-  end
-end