RubyGems - omg-railties - Versions diffs - 8.0.0.alpha3 - Mend

omg-railties 8.0.0.alpha3

Files changed (351) hide show

data/lib/rails/templates/rails/welcome/index.html.erb ADDED Viewed

@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Ruby on Rails <%= Rails.version %></title>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width">
+  <link rel="icon" href="/icon.png" type="image/png">
+  <link rel="apple-touch-icon" href="/icon.png" sizes="512x512">
+  <style type="text/css">
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+    body {
+      align-items: center;
+      background-color: #F0E7E9;
+      background-image: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjEwMjQiIHZpZXdCb3g9IjAgMCAxNDQwIDEwMjQiIHdpZHRoPSIxNDQwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxwYXRoIGQ9Im0xNDQwIDUxMC4wMDA2NDh2LTUxMC4wMDA2NDhoLTE0NDB2Mzg0LjAwMDY0OGM0MTcuMzExOTM5IDEzMS4xNDIxNzkgODkxIDE3MS41MTMgMTQ0MCAxMjZ6IiBmaWxsPSIjZmZmIi8+PC9zdmc+);
+      background-position: center center;
+      background-repeat: no-repeat;
+      background-size: cover;
+      color: #261B23;
+      display: flex;
+      flex-direction: column;
+      font-family: Sans-Serif;
+      font-size: calc(0.9em + 0.5vw);
+      font-style: normal;
+      font-weight: 400;
+      justify-content: center;
+      line-height: 1.25;
+      min-height: 100vh;
+      text-align: center;
+    }
+    nav {
+      font-size: 0;
+      height: 20vw;
+      line-height: 0;
+      max-height: 280px;
+      max-width: 280px;
+      min-height: 86px;
+      min-width: 86px;
+      width: 20vw;
+    }
+    nav a {
+      background: #D30001;
+      border-radius: 100%;
+      display: flex;
+      transition: background 0.25s cubic-bezier(0.33, 1, 0.68, 1);
+      filter: drop-shadow(0 20px 13px rgb(0 0 0 / 0.03)) drop-shadow(0 8px 5px rgb(0 0 0 / 0.08));
+    }
+    nav a:hover {
+      background: #261B23;
+    }
+    nav a img {
+      height: auto;
+      max-width: 100%;
+      width: 100%;
+      cursor: pointer;
+    }
+    ul {
+      bottom: 0;
+      left: 0;
+      list-style: none;
+      margin: 0 2rem 2rem 2rem;
+      position: absolute;
+      right: 0;
+    }
+  </style>
+</head>
+<body>
+  <nav>
+    <a href="https://rubyonrails.org" target="_blank">
+      <img alt="" src="data:image/svg+xml;base64,<svg height="112" viewBox="0 0 112 112" width="112" xmlns="http://www.w3.org/2000/svg"><path d="m100.082357 48.9995403v4.1135034h-7.3003388v1.89854h3.6840717c1.9725091 0 4.0725341 1.4664311 4.1979971 3.9665124l.005913.2373977v1.5821167c-.087824 3.007959-2.5431211 4.1390018-4.0715389 4.2011773l-.1323712.0027328h-7.3907451v-4.0909018l7.4811518-.0226016v-1.9889467h-3.4806567c-1.7752583 0-4.0818321-1.3389153-4.2199942-3.9549201l-.0065176-.24899v-1.423905c0-2.6982402 2.2782129-4.182853 4.065464-4.2678491l.1610478-.003866zm-18.691579 0v11.8658752h6.1702551v4.1361051h-10.7357919v-16.0019803zm-6.4414751 0v16.0019803h-4.5881385v-16.0019803zm-15.210922 0h4.4073251l.187724.0066812c.0338609.0022735.0689457.0051499.1051601.0086643l.2300875.0290178c1.2913829.1985476 3.5463816 1.1213816 3.6751708 3.9068587l.0057677.2526881v11.7980702h-4.2717151v-2.8252084h-4.1361051v2.8252084h-4.4073251v-11.7980702c0-1.3184306 1.0040826-4.0468495 3.946899-4.197411zm-19.7398519-.0027581 8.5801857.0005749.2389234.0367462.1479459.029417.2741161.0653582.2125198.0599068.2323225.0747182c.0401793.0137704.0810402.0282201.122511.0433804l.2555691.0997376.2667618.1182852c1.3560515.6402866 3.0026855 2.0321583 3.0026855 5.016294 0 3.1830781-1.5465241 4.5014899-2.6988362 5.0420477l-.2109651.0925045-.1988828.0758655-.1839577.0608186-.1661898.0473636-.2097508.0493001-.2596493.0418363 5.0056895 5.0505836h-6.3749589l-3.7262083-3.8608906v3.8608906h-4.3098314zm22.0070603-3.0869193.4449917.4226807-.242968.1779881-.3482331.2693365-.1998573.1629204c-5.2398967-3.8745715-9.6476454-5.4221409-13.197119-5.8153537l-.5259807-.0504708c-1.0390742-.0842126-2.0007861-.0698101-2.8844302.0115462l-.4353132.0461111c-.0714668.0085662-.1423907.0175608-.2127712.0269653l-.4157595.0612005-.4026991.0701607-.3896194.0782415-.3765198.0854427c-.0616606.0147917-.1227746.0298468-.1833415.045147l-.3568339.0945957-.3436854.0995982-.3305174.1037213-.3173297.1069649-.3041225.109329-.2908956.1108137-.4115002.1670803-.5021902.2197615-.6533736.3088956-.610105.3005675c-4.6988866 2.6219788-6.8539294 6.8460711-7.7682002 10.8866463l-.1223101.5757838c-.0380504.1913833-.0734278.3821576-.1062732.5721301l-.0910804.5673196-.0767318.5613521-.0632275.5542277c-.0094594.0917134-.0183914.1830817-.0268134.2740808l-.044554.5413722-.0331601.5313556c-.0046242.0876603-.0088087.1748551-.0125713.2615602l-.0176525.5141618-.0083693.5012531.0000696.4871876.0140806.7018779.0283195.6637229.0397089.6216637.0482492.5756999.0539402.5258317.0758481.6167879.0741462.511937.0800002.4783756.0685995.3540863h-17.855317l.05849-.4417253.0463368-.2951448.0630206-.3647242.1132819-.5892069.1093787-.5150907.1820265-.7785088.1661376-.6486772.1259233-.4615943.2130474-.7338225.1589655-.5155042.1731728-.5354699.1879463-.5545226.2032857-.572662.2191913-.5898883.2356628-.6062014.2527004-.6216012c.043568-.1048328.0878694-.2102691.1329162-.3162901l.279318-.6429887.2977707-.6561056.3167894-.6683092.336374-.6795997.3565249-.689977c.3667889-.6948611.7646529-1.4039184 1.1961393-2.1230624 4.7463501-7.9105834 12.8377469-13.9000252 19.414832-14.4876686 5.0453806-.5054094 9.8925436.9276823 13.9443628 2.8796435l.6499858.3208582.6354768.3286093.6204019.335015c.1021126.0562949.2035736.1128007.304371.1694892l.5967286.3421013.580239.3451439.5631836.3468411.5455624.3471932.5273753.3461999.5086223.3438614c.0831762.0570406.1655475.1139277.247102.1706333l.479432.3378312.4592644.3321294.438531.3250825.4172317.3166902.5846736.4563569.5335674.4299071.6286237.5242179.6463432.5614015zm-30.7001056 14.5713243 2.4409801.881465c.1130083.8852319.2731034 1.7233771.4410464 2.4882761l.1013936.4499406-2.7122001-.9718717-.0338347-.2121618-.0660421-.4755843-.0611601-.5412195c-.0480285-.4774602-.0875814-1.0199003-.1101831-1.6188444zm31.5067239-7.6619652h-1.5143117c-.9400238 0-1.2391224.409772-1.3342901.670536l-.0282266.0950339c-.003237.014073-.0058266.0271526-.0078982.0390732l-.0081573.0715239-.0001295 3.9153864h4.1361051l-.0018533-3.9347694-.0102612-.0669913-.0257207-.0987241c-.0835357-.2591507-.3509135-.6910686-1.2052565-.6910686zm-50.4921242.339025 2.5991917.94927-.408641.9515839c-.2124882.4994644-.4277796 1.0148142-.6033575 1.457745l-.1180849.3028712-2.5991917-.94927.1323662-.3453033.2583889-.6392034.3057111-.7281974.3254875-.7536244c.0362438-.0827943.0723437-.1648823.1081297-.2458716zm35.4451209-.1434449h-3.4568439v3.6588673h3.4343968l.0547106-.025392.0865984-.0488983.1147536-.0786822c.2926428-.2211448.7316071-.7149797.7316071-1.6876847s-.4289878-1.4565634-.7149797-1.6710573l-.1121455-.0760741-.0846303-.0469301zm-15.4426456-.7606218 1.6273201 1.2882951c-.1808134.705172-.3182315 1.410344-.4122545 2.115516l-.0623806.528879-1.830735-1.4465067c.1808134-.81366.3842284-1.6499217.67805-2.4861834zm4.0004951-6.3058651 1.017075 1.5369134c-.3977893.4158707-.7666485.8317413-1.0950055 1.2707561l-.2384928.3339623-1.0848801-1.6273201c.40683-.5198383.8814651-1.0396767 1.4013034-1.5143117zm-16.1827936-3.3450467 1.6047183 1.4013034c-.40683.4237812-.8009465.8729894-1.1728146 1.3285542l-.3640987.4569775-1.7403284-1.4917101c.5198383-.5650416 1.08488-1.1300833 1.6725234-1.695125zm22.3982521-.0904067.4972366 1.4917101c-.5243586.162732-1.0487173.3688592-1.573076.6068095l-.393269.1842488-.5198384-1.559515c.5650417-.2486184 1.2204901-.4972367 1.9889468-.7232534zm5.28879-.54244c.5786027.0361627 1.1716705.1012555 1.7792033.2068505l.4583618.0869712-.0904067 1.4013034c-.596684-.1265694-1.193368-.2097435-1.790052-.2495224l-.447513-.0216976zm-18.5559686-6.2380601 1.017075 1.559515c-.4407325.2203663-.8687516.4661594-1.3031274.7278443l-.437201.2666291-1.0396767-1.5821167c.610245-.3616267 1.1978884-.67805 1.7629301-.9718717zm18.5107653.6328467.0904067-1.49171.4435073.1305564.3839803.1203252.3285458.1099079.2772037.0993048.3284915.128669.296488.1327112.1341451.0695838-.0904067 1.5143117c-.4821689-.1958811-.9643378-.381717-1.4532035-.5575078zm-8.5434301-2.8252084.4520333 1.3787017h-.2260167c-.4915862 0-.9831725.0127134-1.4747588.0476754l-.4915862.0427313-.4294317-1.3334984c.745855-.0904067 1.4691084-.13561 2.1697601-.13561z" fill="#fff"/></svg>" />
+    </a>
+  </nav>
+  <ul>
+    <li><strong>Rails version:</strong> <%= Rails.version %></li>
+    <li><strong>Rack version:</strong> <%= Rack.release %></li>
+    <li><strong>Ruby version:</strong> <%= RUBY_DESCRIPTION %></li>
+  </ul>
+</body>
+</html>

data/lib/rails/test_help.rb ADDED Viewed

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# :enddoc:
+# Make double-sure the RAILS_ENV is not set to production,
+# so fixtures aren't loaded into that environment
+abort("Abort testing: Your Rails environment is running in production mode!") if Rails.env.production?
+require "active_support/test_case"
+require "rails/generators/test_case"
+require "active_support/testing/autorun"
+require "rails/testing/maintain_test_schema"
+if defined?(ActiveRecord::Base)
+  require "active_record/testing/query_assertions"
+  ActiveSupport.on_load(:active_support_test_case) do
+    include ActiveRecord::TestDatabases
+    include ActiveRecord::TestFixtures
+    include ActiveRecord::Assertions::QueryAssertions
+    self.fixture_paths << "#{Rails.root}/test/fixtures/"
+    self.file_fixture_path = "#{Rails.root}/test/fixtures/files"
+  end
+  ActiveSupport.on_load(:action_dispatch_integration_test) do
+    self.fixture_paths += ActiveSupport::TestCase.fixture_paths
+  end
+else
+  ActiveSupport.on_load(:active_support_test_case) do
+    self.file_fixture_path = "#{Rails.root}/test/fixtures/files"
+  end
+end
+ActiveSupport.on_load(:action_controller_test_case) do
+  def before_setup
+    @routes = Rails.application.routes
+    super
+  end
+end
+ActiveSupport.on_load(:action_dispatch_integration_test) do
+  def before_setup
+    @routes = Rails.application.routes
+    super
+  end
+end

data/lib/rails/test_unit/line_filtering.rb ADDED Viewed

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require "rails/test_unit/runner"
+module Rails
+  module LineFiltering # :nodoc:
+    def run(reporter, options = {})
+      options = options.merge(filter: Rails::TestUnit::Runner.compose_filter(self, options[:filter]))
+      super
+    end
+  end
+end

data/lib/rails/test_unit/railtie.rb ADDED Viewed

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require "rails/test_unit/line_filtering"
+module Rails
+  class TestUnitRailtie < Rails::Railtie
+    config.app_generators do |c|
+      c.test_framework :test_unit, fixture: true,
+                                   fixture_replacement: nil
+      c.integration_tool :test_unit
+      c.system_tests :test_unit
+    end
+    initializer "test_unit.line_filtering" do
+      ActiveSupport.on_load(:active_support_test_case) {
+        ActiveSupport::TestCase.extend Rails::LineFiltering
+      }
+    end
+    rake_tasks do
+      load "rails/test_unit/testing.rake"
+    end
+  end
+end

data/lib/rails/test_unit/reporter.rb ADDED Viewed

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+require "active_support/core_ext/class/attribute"
+require "minitest"
+module Rails
+  class TestUnitReporter < Minitest::StatisticsReporter
+    class_attribute :app_root
+    class_attribute :executable, default: "bin/rails test"
+    def prerecord(test_class, test_name)
+      super
+      if options[:verbose]
+        io.print "%s#%s = " % [test_class.name, test_name]
+      end
+    end
+    def record(result)
+      super
+      if options[:verbose]
+        io.puts color_output(format_line(result), by: result)
+      else
+        io.print color_output(result.result_code, by: result)
+      end
+      if output_inline? && result.failure && (!result.skipped? || options[:verbose])
+        io.puts
+        io.puts
+        io.puts color_output(result, by: result)
+        io.puts
+        io.puts format_rerun_snippet(result)
+        io.puts
+      end
+      if fail_fast? && result.failure && !result.skipped?
+        raise Interrupt
+      end
+    end
+    def report
+      return if output_inline? || filtered_results.empty?
+      io.puts
+      io.puts "Failed tests:"
+      io.puts
+      io.puts aggregated_results
+    end
+    def aggregated_results # :nodoc:
+      filtered_results.map { |result| format_rerun_snippet(result) }.join "\n"
+    end
+    def filtered_results
+      if options[:verbose]
+        results
+      else
+        results.reject(&:skipped?)
+      end
+    end
+    def relative_path_for(file)
+      if app_root
+        file.sub(/^#{app_root}\/?/, "")
+      else
+        file
+      end
+    end
+    private
+      def output_inline?
+        options[:output_inline]
+      end
+      def fail_fast?
+        options[:fail_fast]
+      end
+      def format_line(result)
+        "%.2f s = %s" % [result.time, result.result_code]
+      end
+      def format_rerun_snippet(result)
+        location, line = if result.respond_to?(:source_location)
+          result.source_location
+        else
+          result.method(result.name).source_location
+        end
+        "#{executable} #{relative_path_for(location)}:#{line}"
+      end
+      def app_root
+        @app_root ||= self.class.app_root ||
+          if defined?(ENGINE_ROOT)
+            ENGINE_ROOT
+          elsif Rails.respond_to?(:root)
+            Rails.root
+          end
+      end
+      def colored_output?
+        options[:color] && io.respond_to?(:tty?) && io.tty?
+      end
+      codes = { red: 31, green: 32, yellow: 33 }
+      COLOR_BY_RESULT_CODE = {
+        "." => codes[:green],
+        "E" => codes[:red],
+        "F" => codes[:red],
+        "S" => codes[:yellow]
+      }
+      def color_output(string, by:)
+        if colored_output?
+          "\e[#{COLOR_BY_RESULT_CODE[by.result_code]}m#{string}\e[0m"
+        else
+          string
+        end
+      end
+  end
+end

data/lib/rails/test_unit/runner.rb ADDED Viewed

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+require "shellwords"
+require "rake/file_list"
+require "active_support"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/range"
+require "rails/test_unit/test_parser"
+module Rails
+  module TestUnit
+    class InvalidTestError < StandardError
+      def initialize(path, suggestion)
+        super(<<~MESSAGE.squish)
+          Could not load test file: #{path}.
+          #{suggestion}
+        MESSAGE
+      end
+    end
+    class Runner
+      TEST_FOLDERS = [:models, :helpers, :channels, :controllers, :mailers, :integration, :jobs, :mailboxes]
+      PATH_ARGUMENT_PATTERN = %r"^(?!/.+/$)[.\w]*[/\\]"
+      mattr_reader :filters, default: []
+      class << self
+        def attach_before_load_options(opts)
+          opts.on("--warnings", "-w", "Run with Ruby warnings enabled") { }
+          opts.on("-e", "--environment ENV", "Run tests in the ENV environment") { }
+        end
+        def parse_options(argv)
+          # Perform manual parsing and cleanup since option parser raises on unknown options.
+          env_index = argv.index("--environment") || argv.index("-e")
+          if env_index
+            argv.delete_at(env_index)
+            environment = argv.delete_at(env_index).strip
+          end
+          ENV["RAILS_ENV"] = environment || "test"
+          w_index = argv.index("--warnings") || argv.index("-w")
+          $VERBOSE = argv.delete_at(w_index) if w_index
+        end
+        def run_from_rake(test_command, argv = [])
+          # Ensure the tests run during the Rake Task action, not when the process exits
+          success = system("rails", test_command, *argv, *Shellwords.split(ENV["TESTOPTS"] || ""))
+          success || exit(false)
+        end
+        def run(argv = [])
+          load_tests(argv)
+          require "active_support/testing/autorun"
+        end
+        def load_tests(argv)
+          patterns = extract_filters(argv)
+          tests = list_tests(patterns)
+          tests.to_a.each do |path|
+            abs_path = File.expand_path(path)
+            require abs_path
+          rescue LoadError => exception
+            if exception.path == abs_path
+              all_tests = list_tests([default_test_glob])
+              corrections = DidYouMean::SpellChecker.new(dictionary: all_tests).correct(path)
+              if corrections.empty?
+                raise exception
+              end
+              raise InvalidTestError.new(path, DidYouMean::Formatter.message_for(corrections))
+            else
+              raise
+            end
+          end
+        end
+        def compose_filter(runnable, filter)
+          filter = normalize_declarative_test_filter(filter)
+          if filters.any? { |_, lines| lines.any? }
+            CompositeFilter.new(runnable, filter, filters)
+          else
+            filter
+          end
+        end
+        private
+          def extract_filters(argv)
+            # Extract absolute and relative paths but skip -n /.*/ regexp filters.
+            argv.filter_map do |path|
+              next unless path_argument?(path)
+              path = path.tr("\\", "/")
+              case
+              when /(:\d+(-\d+)?)+$/.match?(path)
+                file, *lines = path.split(":")
+                filters << [ file, lines ]
+                file
+              when Dir.exist?(path)
+                "#{path}/**/*_test.rb"
+              else
+                filters << [ path, [] ]
+                path
+              end
+            end
+          end
+          def default_test_glob
+            ENV["DEFAULT_TEST"] || "test/**/*_test.rb"
+          end
+          def default_test_exclude_glob
+            ENV["DEFAULT_TEST_EXCLUDE"] || "test/{system,dummy,fixtures}/**/*_test.rb"
+          end
+          def regexp_filter?(arg)
+            arg.start_with?("/") && arg.end_with?("/")
+          end
+          def path_argument?(arg)
+            PATH_ARGUMENT_PATTERN.match?(arg)
+          end
+          def list_tests(patterns)
+            tests = Rake::FileList[patterns.any? ? patterns : default_test_glob]
+            tests.exclude(default_test_exclude_glob) if patterns.empty?
+            tests
+          end
+          def normalize_declarative_test_filter(filter)
+            if filter.is_a?(String)
+              if regexp_filter?(filter)
+                # Minitest::Spec::DSL#it does not replace whitespace in method
+                # names, so match unmodified method names as well.
+                filter = filter.gsub(/\s+/, "_").delete_suffix("/") + "|" + filter.delete_prefix("/")
+              elsif !filter.start_with?("test_")
+                filter = "test_#{filter.gsub(/\s+/, "_")}"
+              end
+            end
+            filter
+          end
+      end
+    end
+    class CompositeFilter # :nodoc:
+      attr_reader :named_filter
+      def initialize(runnable, filter, patterns)
+        @runnable = runnable
+        @named_filter = derive_named_filter(filter)
+        @filters = [ @named_filter, *derive_line_filters(patterns) ].compact
+      end
+      # minitest uses === to find matching filters.
+      def ===(method)
+        @filters.any? { |filter| filter === method }
+      end
+      private
+        def derive_named_filter(filter)
+          if filter.respond_to?(:named_filter)
+            filter.named_filter
+          elsif filter =~ %r%/(.*)/% # Regexp filtering copied from minitest.
+            Regexp.new $1
+          elsif filter.is_a?(String)
+            filter
+          end
+        end
+        def derive_line_filters(patterns)
+          patterns.flat_map do |file, lines|
+            if lines.empty?
+              Filter.new(@runnable, file, nil) if file
+            else
+              lines.map { |line| Filter.new(@runnable, file, line) }
+            end
+          end
+        end
+    end
+    class Filter # :nodoc:
+      def initialize(runnable, file, line_or_range)
+        @runnable, @file = runnable, File.expand_path(file)
+        if line_or_range
+          first, last = line_or_range.split("-").map(&:to_i)
+          last ||= first
+          @line_range = Range.new(first, last)
+        end
+      end
+      def ===(method)
+        return unless @runnable.method_defined?(method)
+        if @line_range
+          test_file, test_range = definition_for(@runnable.instance_method(method))
+          test_file == @file && @line_range.overlaps?(test_range)
+        else
+          @runnable.instance_method(method).source_location.first == @file
+        end
+      end
+      private
+        def definition_for(method)
+          TestParser.definition_for(method)
+        end
+    end
+  end
+end

data/lib/rails/test_unit/test_parser.rb ADDED Viewed

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+begin
+  require "prism"
+rescue LoadError
+  # If Prism isn't available (because of using an older Ruby version) then we'll
+  # define a fallback parser using ripper.
+end
+if defined?(Prism)
+  module Rails
+    module TestUnit
+      # Parse a test file to extract the line ranges of all tests in both
+      # method-style (def test_foo) and declarative-style (test "foo" do)
+      module TestParser
+        # Helper to translate a method object into the path and line range where
+        # the method was defined.
+        def self.definition_for(method)
+          filepath, start_line = method.source_location
+          queue = [Prism.parse_file(filepath).value]
+          while (node = queue.shift)
+            case node.type
+            when :def_node
+              if node.location.start_line == start_line
+                return [filepath, start_line..node.location.end_line]
+              end
+            when :call_node
+              if node.location.start_line == start_line
+                return [filepath, start_line..node.location.end_line]
+              end
+            end
+            queue.concat(node.compact_child_nodes)
+          end
+          nil
+        end
+      end
+    end
+  end
+  # If we have Prism, then we don't need to define the fallback parser using
+  # ripper.
+  return
+end
+require "ripper"
+module Rails
+  module TestUnit
+    # Parse a test file to extract the line ranges of all tests in both
+    # method-style (def test_foo) and declarative-style (test "foo" do)
+    class TestParser < Ripper # :nodoc:
+      # Helper to translate a method object into the path and line range where
+      # the method was defined.
+      def self.definition_for(method_obj)
+        path, begin_line = method_obj.source_location
+        begins_to_ends = new(File.read(path), path).parse
+        return unless end_line = begins_to_ends[begin_line]
+        [path, (begin_line..end_line)]
+      end
+      def initialize(*)
+        # A hash mapping the 1-indexed line numbers that tests start on to where they end.
+        @begins_to_ends = {}
+        super
+      end
+      def parse
+        super
+        @begins_to_ends
+      end
+      # method test e.g. `def test_some_description`
+      # This event's first argument gets the `ident` node containing the method
+      # name, which we have overridden to return the line number of the ident
+      # instead.
+      def on_def(begin_line, *)
+        @begins_to_ends[begin_line] = lineno
+      end
+      # Everything past this point is to support declarative tests, which
+      # require more work to get right because of the many different ways
+      # methods can be invoked in ruby, all of which are parsed differently.
+      #
+      # The approach is just to store the current line number when the
+      # "test" method is called and pass it up the tree so it's available at
+      # the point when we also know the line where the associated block ends.
+      def on_method_add_block(begin_line, end_line)
+        if begin_line && end_line
+          @begins_to_ends[begin_line] = end_line
+        end
+      end
+      def on_command_call(*, begin_lineno, _args)
+        begin_lineno
+      end
+      def first_arg(arg, *)
+        arg
+      end
+      def just_lineno(*)
+        lineno
+      end
+      alias on_method_add_arg first_arg
+      alias on_command first_arg
+      alias on_stmts_add first_arg
+      alias on_arg_paren first_arg
+      alias on_bodystmt first_arg
+      alias on_ident just_lineno
+      alias on_do_block just_lineno
+      alias on_stmts_new just_lineno
+      alias on_brace_block just_lineno
+      def on_args_new
+        []
+      end
+      def on_args_add(parts, part)
+        parts << part
+      end
+      def on_args_add_block(args, *rest)
+        args.first
+      end
+    end
+  end
+end

data/lib/rails/test_unit/testing.rake ADDED Viewed

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require "minitest"
+require "rails/test_unit/runner"
+task default: :test
+desc "Run all tests in test folder except system ones"
+task :test do
+  Rails::TestUnit::Runner.run_from_rake("test", Array(ENV["TEST"]))
+end
+namespace :test do
+  task :prepare do
+    # Placeholder task for other Railtie and plugins to enhance.
+    # If used with Active Record, this task runs before the database schema is synchronized.
+  end
+  task run: %w[test]
+  desc "Reset the database and run `bin/rails test`"
+  task :db do
+    success = system({ "RAILS_ENV" => ENV.fetch("RAILS_ENV", "test") }, "rake", "db:test:prepare", "test")
+    success || exit(false)
+  end
+  [
+    *Rails::TestUnit::Runner::TEST_FOLDERS,
+    :all,
+    :generators,
+    :units,
+    :functionals,
+    :system,
+  ].each do |name|
+    task name do
+      Rails::TestUnit::Runner.run_from_rake("test:#{name}")
+    end
+  end
+end