Load spec files in the order that files and dirs were specified in the CLI.

This fixes #2247 and addresses some of the feedback from #2251.

Author: myronmarston

Changelog.md

@@ -8,6 +8,11 @@ Enhancements:
   by using `bundle exec`. (Myron Marston, #2240)
 * HTML Formatter uses exception presenter to get failure message
   for consistency with other formatters. (@mrageh, #2222)
+* Load spec files in the order of the directories or files passed
+  at the command line, making it easy to make some specs run before
+  others in a one-off manner.  For example, `rspec spec/unit
+  spec/acceptance --order defined` will run unit specs before acceptance
+  specs. (Myron Marston, #2253)
 
 Bug Fixes:
 

lib/rspec/core/configuration.rb

@@ -1782,7 +1782,7 @@ def get_files_to_run(paths)
         files = FlatMap.flat_map(paths_to_check(paths)) do |path|
           path = path.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
           File.directory?(path) ? gather_directories(path) : extract_location(path)
-        end.sort.uniq
+        end.uniq
 
         return files unless only_failures?
         relative_files = files.map { |f| Metadata.relative_path(File.expand_path f) }
@@ -1802,11 +1802,12 @@ def pattern_might_load_specs_from_vendored_dirs?
       def gather_directories(path)
         include_files = get_matching_files(path, pattern)
         exclude_files = get_matching_files(path, exclude_pattern)
-        (include_files - exclude_files).sort.uniq
+        (include_files - exclude_files).uniq
       end
 
       def get_matching_files(path, pattern)
-        Dir[file_glob_from(path, pattern)].map { |file| File.expand_path(file) }
+        raw_files = Dir[file_glob_from(path, pattern)]
+        raw_files.map { |file| File.expand_path(file) }.sort
       end
 
       def file_glob_from(path, pattern)

spec/rspec/core/configuration_spec.rb

@@ -554,58 +554,51 @@ def loaded_files
         end
       end
 
-      def specify_consistent_ordering_of_files_to_run
-        allow(File).to receive(:directory?).and_call_original
-        allow(File).to receive(:directory?).with('a') { true }
-        globbed_files = nil
-        allow(Dir).to receive(:[]).with(/^\{?a/) { globbed_files }
-        allow(Dir).to receive(:[]).with(a_string_starting_with(Dir.getwd)) { [] }
-
-        orderings = [
-          %w[ a/1.rb a/2.rb a/3.rb ],
-          %w[ a/2.rb a/1.rb a/3.rb ],
-          %w[ a/3.rb a/2.rb a/1.rb ]
-        ].map do |files|
-          globbed_files = files
-          yield
-          config.files_to_run
-        end
+      it 'loads files in passed directories in alphabetical order to avoid OS-specific file-globbing non-determinism' do
+        define_dirs "spec/unit" => [
+          ["spec/unit/b_spec.rb", "spec/unit/a_spec.rb"],
+          ["spec/unit/a_spec.rb", "spec/unit/b_spec.rb"]
+        ]
 
-        expect(orderings.uniq.size).to eq(1)
+        expect(assign_files_or_directories_to_run "spec/unit").to match [
+          file_at("spec/unit/a_spec.rb"),
+          file_at("spec/unit/b_spec.rb")
+        ]
+        expect(assign_files_or_directories_to_run "spec/unit").to match [
+          file_at("spec/unit/a_spec.rb"),
+          file_at("spec/unit/b_spec.rb")
+        ]
       end
 
-      context 'when the given directories match the pattern' do
-        it 'orders the files in a consistent ordering, regardless of the underlying OS ordering' do
-          specify_consistent_ordering_of_files_to_run do
-            config.pattern = 'a/*.rb'
-            assign_files_or_directories_to_run 'a'
-          end
-        end
-      end
+      it 'respects the user-specified order of files and directories passed at the command line' do
+        define_dirs "spec/b" => [["spec/b/1_spec.rb", "spec/b/2_spec.rb"]],
+                    "spec/c" => [["spec/c/1_spec.rb", "spec/c/2_spec.rb"]]
 
-      context 'when the pattern is given relative to the given directories' do
-        it 'orders the files in a consistent ordering, regardless of the underlying OS ordering' do
-          specify_consistent_ordering_of_files_to_run do
-            config.pattern = '*.rb'
-            assign_files_or_directories_to_run 'a'
-          end
-        end
+        expect(assign_files_or_directories_to_run "spec/b", "spec/a1_spec.rb", "spec/c", "spec/a2_spec.rb").to match [
+          file_at("spec/b/1_spec.rb"), file_at("spec/b/2_spec.rb"),
+          file_at("spec/a1_spec.rb"),
+          file_at("spec/c/1_spec.rb"), file_at("spec/c/2_spec.rb"),
+          file_at("spec/a2_spec.rb")
+        ]
       end
 
-      context 'when given multiple file paths' do
-        it 'orders the files in a consistent ordering, regardless of the given order' do
-          allow(File).to receive(:directory?) { false } # fake it into thinking these a full file paths
-
-          files = ['a/b/c_spec.rb', 'c/b/a_spec.rb']
-          assign_files_or_directories_to_run(*files)
-          ordering_1 = config.files_to_run
+      def define_dirs(dirs_hash)
+        allow(File).to receive(:directory?) do |path|
+          !path.end_with?(".rb")
+        end
 
-          assign_files_or_directories_to_run(*files.reverse)
-          ordering_2 = config.files_to_run
+        allow(Dir).to receive(:[]).and_return([])
 
-          expect(ordering_1).to eq(ordering_2)
+        dirs_hash.each do |dir, sequential_glob_return_values|
+          allow(Dir).to receive(:[]).with(
+            a_string_including(dir, config.pattern)
+          ).and_return(*sequential_glob_return_values)
         end
       end
+
+      def file_at(relative_path)
+        eq(relative_path).or eq(File.expand_path(relative_path))
+      end
     end
 
     describe "#pattern" do