code_owners 1.0.8 → 2.0.1

data/spec/code_owners_spec.rb

@@ -1,68 +1,139 @@
 require 'code_owners'
 require 'tmpdir'
+require 'json'
 
 RSpec.describe CodeOwners do |rspec|
-  describe ".ownerships" do
-    it "assigns owners to things" do
-      expect(CodeOwners).to receive(:pattern_owners).and_return([["pat1", "own1"], ["pat2*", "own2"], ["pat3", "own3"]])
-      expect(CodeOwners).to receive(:git_owner_info).and_return(
-        [
-          ["2", "pat2*", "pat2file"],
-          ["", "", "unowned/file"]
-        ]
-      )
-      expect(CodeOwners.ownerships).to eq(
+  describe ".file_ownerships" do
+    it "returns a hash of ownerships keyed by file path" do
+      expect(CodeOwners).to receive(:ownerships).and_return(
         [
           { file: "pat2file", owner: "own2", line: "2", pattern: "pat2*" },
           { file: "unowned/file", owner: "UNOWNED", line: nil, pattern: nil }
         ]
       )
+      expect(CodeOwners.file_ownerships).to eq(
+        {
+          "pat2file" => { file: "pat2file", owner: "own2", line: "2", pattern: "pat2*" },
+          "unowned/file" => { file: "unowned/file", owner: "UNOWNED", line: nil, pattern: nil }
+        }
+      )
+    end
+  end
+
+  describe ".ownerships" do
+    context "default path shelling out to git" do
+      it "assigns owners to things" do
+        expect(CodeOwners).to receive(:pattern_owners).and_return([["pat1", "own1"], ["pat2*", "own2"], ["pat3", "own3"]])
+        expect(CodeOwners).to receive(:git_owner_info).and_return(
+          [
+            ["2", "pat2*", "pat2file"],
+            ["", "", "unowned/file"]
+          ]
+        )
+        expect(CodeOwners.ownerships).to eq(
+          [
+            { file: "pat2file", owner: "own2", line: "2", pattern: "pat2*" },
+            { file: "unowned/file", owner: "UNOWNED", line: nil, pattern: nil }
+          ]
+        )
+      end
+    end
+
+    context "using no_git as an option" do
+      it "works" do
+        expect(CodeOwners).to receive(:pattern_owners).and_return([["foo", "own1"], ["foo*", "own2"], ["foo/**", "own3"]])
+        expect(CodeOwners).to receive(:files_to_own).and_return(["zip", "foo.rb", "foo/bar.rb", "foo/bar/baz.rb", "foo/bar/baz/meow.txt", "waffles"])
+        results = CodeOwners.ownerships(no_git: true)
+        expect(results).to match_array([
+          {:file=>"zip", :owner=>"UNOWNED", :line=>nil, :pattern=>nil},
+          {:file=>"foo.rb", :owner=>"own2", :line=>2, :pattern=>"foo*", pattern_regex: anything},
+          {:file=>"foo/bar.rb", :owner=>"own3", :line=>3, :pattern=>"foo/**", pattern_regex: anything},
+          {:file=>"foo/bar/baz.rb", :owner=>"own3", :line=>3, :pattern=>"foo/**", pattern_regex: anything},
+          {:file=>"foo/bar/baz/meow.txt", :owner=>"own3", :line=>3, :pattern=>"foo/**", pattern_regex: anything},
+          {:file=>"waffles", :owner=>"UNOWNED", :line=>nil, :pattern=>nil}
+        ])
+      end
+
+      it "behaves as expected of gitignore" do
+        mismatch_count = 0
+        permutations = JSON.parse(File.read("spec/permutations.json"))
+        puts "\nEvaluating #{permutations["permutations"].size} permutations, only printing the mismatches"
+
+        permutations["permutations"].each do |perm, git_matches|
+          expect(CodeOwners).to receive(:pattern_owners).and_return([[perm, "owner"]])
+          expect(CodeOwners).to receive(:files_to_own).and_return(permutations["all_files"])
+          ownerships = CodeOwners.ownerships(no_git: true)
+          spec_matches = ownerships.reject{|o| o[:pattern].nil? }.map{|o| o[:file] }.sort
+
+          diff1 = array_diff(spec_matches, git_matches)
+          diff2 = array_diff(git_matches, spec_matches)
+          unless diff1.empty? && diff2.empty?
+            mismatch_count += 1
+            puts "Permutation #{PathSpec::GitIgnoreSpec.new(perm).inspect}"
+            puts "gitignore matches: #{git_matches}"
+            puts "patchspec matches: #{spec_matches}\n\n"
+          end
+        end
+        puts "Counted #{mismatch_count} mismatches" if mismatch_count > 0
+      end
     end
   end
 
   describe ".pattern_owners" do
-    around(:each) do |example|
-      Dir.mktmpdir { |d|
-        @d = d
-        f = File.new(File.join(d, 'CODEOWNERS'), 'w+')
-        f.write <<-CODEOWNERS
+    before do
+      @data = <<-CODEOWNERS
 lib/* @jcheatham
 some/path/** @someoneelse
 other/path/* @someoneelse @anotherperson
-invalid/codeowners/line 
+
+this path/has spaces.txt        @spacelover spacer@example.com
+/this also has spaces.txt        spacer@example.com @spacelover
+
+invalid/code owners/line
      @AnotherInvalidLine
 #comment-line (empty line next)
+!this/is/unsupported.txt   @foo
+here/is/a/valid/path.txt   @jcheatham
 
-# another comment line
+#/another/comment/line @nobody
 CODEOWNERS
-        f.close
-        example.run
-      }
+    end
+
+    it "returns an empty array given an empty string" do
+      results = CodeOwners.pattern_owners("")
+      expect(results).to eq([])
     end
 
     it "returns a list of patterns and owners" do
-      expect(CodeOwners).to receive(:current_repo_path).and_return(@d)
-      expect(CodeOwners).to receive(:log).twice
-      pattern_owners = CodeOwners.pattern_owners
-      expect(pattern_owners).to include(["other/path/*", "@someoneelse @anotherperson"])
-    end
-
-    it "works when invoked in a repo's subdirectory" do
-      expect(CodeOwners).to receive(:current_repo_path).and_return(@d)
-      expect(CodeOwners).to receive(:log).twice
-      subdir = File.join(@d, 'spec')
-      Dir.mkdir(subdir)
-      Dir.chdir(subdir) do
-        pattern_owners = CodeOwners.pattern_owners
-        expect(pattern_owners).to include(["lib/*", "@jcheatham"])
-      end
+      expected_results = [
+        ["lib/*", "@jcheatham"],
+        ["some/path/**", "@someoneelse"],
+        ["other/path/*", "@someoneelse @anotherperson"],
+        ["", ""],
+        ["this path/has spaces.txt", "@spacelover spacer@example.com"],
+        ["/this also has spaces.txt", "spacer@example.com @spacelover"],
+        ["", ""],
+        ["", ""],
+        ["", ""],
+        ["", ""],
+        ["", ""],
+        ["here/is/a/valid/path.txt", "@jcheatham"],
+        ["", ""],
+        ["", ""]]
+
+      expect(CodeOwners).to receive(:log).exactly(3).times
+      results = CodeOwners.pattern_owners(@data)
+      # do this to compare elements with much nicer failure hints
+      expect(results).to match_array(expected_results)
+      # but do this to guarantee order
+      expect(results).to eq(expected_results)
     end
 
     it "prints validation errors and skips lines that aren't the expected format" do
-      expect(CodeOwners).to receive(:current_repo_path).and_return(@d)
-      expect(CodeOwners).to receive(:log).with("Parse error line 4: \"invalid/codeowners/line \"")
-      expect(CodeOwners).to receive(:log).with("Parse error line 5: \"     @AnotherInvalidLine\"")
-      pattern_owners = CodeOwners.pattern_owners
+      expect(CodeOwners).to receive(:log).with("Parse error line 8: \"invalid/code owners/line\"", {})
+      expect(CodeOwners).to receive(:log).with("Parse error line 9: \"     @AnotherInvalidLine\"", {})
+      expect(CodeOwners).to receive(:log).with("Parse error line 11: \"!this/is/unsupported.txt   @foo\"", {})
+      pattern_owners = CodeOwners.pattern_owners(@data)
       expect(pattern_owners).not_to include(["", "@AnotherInvalidLine"])
       expect(pattern_owners).to include(["", ""])
     end
@@ -86,6 +157,78 @@ CODEOWNERS
       expect(raw_ownership.size).to be >= 1
       expect(raw_ownership).to match(/^(?:.*:\d*:.*\t.*\n)+$/)
     end
+
+    context "when path includes a space" do
+      it "returns the path in single line" do
+        raw_ownership = CodeOwners.raw_git_owner_info(["/spec/files/*"])
+        expect(raw_ownership).to match(/.+:\d+:.+\tspec\/files\/file name\.txt\n/)
+      end
+    end
+  end
+
+  describe ".codeowners_data" do
+    context "when passed predefined data" do
+      it "returns the data" do
+        result = CodeOwners.send(:codeowners_data, codeowner_data: "foo")
+        expect(result).to eq("foo")
+      end
+    end
+
+    context "when passed a file path" do
+      it "loads the file" do
+        result = CodeOwners.send(:codeowners_data, codeowner_path: ".github/CODEOWNERS")
+        expect(result).to start_with("# This is a CODEOWNERS file.")
+      end
+    end
+
+    context "using git" do
+      it "works when in a sub-directory" do
+        Dir.chdir("lib") do
+          result = CodeOwners.send(:codeowners_data)
+          # assuming cloned to a directory named after the repo
+          expect(result).to start_with("# This is a CODEOWNERS file.")
+        end
+      end
+
+      it "fails when not in a repo" do
+        Dir.chdir("/") do
+          # this should also print out an error to stderror along the lines of
+          # fatal: not a git repository (or any of the parent directories): .git
+          expect { CodeOwners.send(:codeowners_data) }.to raise_error(RuntimeError)
+        end
+      end
+    end
+
+    context "not using git" do
+      it "works when in a sub-directory" do
+        Dir.chdir("lib") do
+          result = CodeOwners.send(:codeowners_data, no_git: true)
+          # assuming cloned to a directory named after the repo
+          expect(result).to start_with("# This is a CODEOWNERS file.")
+        end
+      end
+
+      it "fails when not in a repo" do
+        Dir.chdir("/") do
+          expect { CodeOwners.send(:codeowners_data, no_git: true) }.to raise_error(RuntimeError)
+        end
+      end
+    end
+  end
+
+  describe ".files_to_own" do
+    it "returns all files" do
+      result = CodeOwners.send(:files_to_own)
+      expect(result).to include('Gemfile')
+      expect(result).to include('lib/code_owners.rb')
+      expect(result).to include('spec/files/foo/fake_gem.gem')
+    end
+
+    it "removes ignored files" do
+      result = CodeOwners.send(:files_to_own, ignores: [".gitignore"])
+      expect(result).to include('spec/files/foo/bar/baz/baz.txt')
+      expect(result).not_to include('spec/files/foo/fake_gem.gem')
+    end
   end
 
   describe "code_owners" do
@@ -99,4 +242,16 @@ CODEOWNERS
       expect(`bin#{File::SEPARATOR}code_owners --version`).to match VERSION_REGEX
     end
   end
+
+  # yoinked from rspec match_array
+  def array_diff(array_1, array_2)
+    difference = array_1.dup
+    array_2.each do |element|
+      if index = difference.index(element)
+        difference.delete_at(index)
+      end
+    end
+    difference
+  end
+
 end

data/spec/files/.dot folder/.silly example.txt

@@ -0,0 +1 @@
+just git ignore things

data/spec/files/.dot folder/afoodle.txt

@@ -0,0 +1 @@
+This is afoodle.txt

data/spec/files/.dot folder/serious_example.txt

@@ -0,0 +1 @@
+This is serious business

data/spec/files/.gitignore

@@ -0,0 +1 @@
+blah blah blah

data/spec/files/file name.txt

@@ -0,0 +1 @@
+This file's name includes a space.

data/spec/files/foo/bar/bar

@@ -0,0 +1 @@
+This is bar

data/spec/files/foo/bar/bar.txt

@@ -0,0 +1 @@
+This is bar.txt

data/spec/files/foo/bar/baz/baz.txt

@@ -0,0 +1 @@
+This is spec/files/foo/bar/baz/baz.txt

data/spec/files/foo/bar/baz/baz2.txt

@@ -0,0 +1 @@
+This is baz2.txt

data/spec/files/foo/bar/some bar.txt

@@ -0,0 +1 @@
+This is some bar.txt

data/spec/files/foo/confoozing.txt

@@ -0,0 +1 @@
+This is confoozing.txt

data/spec/files/foo/fake_gem.gem

@@ -0,0 +1 @@
+This is a fake gem to trigger .gitignore

data/spec/files/foo/foo

@@ -0,0 +1 @@
+this is a foo file

data/spec/files/foo/foo.txt

@@ -0,0 +1 @@
+this is foo.txt

data/spec/files/foo/some foo.text

@@ -0,0 +1 @@
+true facts

data/spec/generate_permutations.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'code_owners'
+require 'tmpdir'
+require 'json'
+require 'pathname'
+require 'byebug'
+
+output = { permutations: {} }
+
+def reset_file_to(file, content)
+  file.rewind
+  file.write(content)
+  file.flush
+  file.truncate(file.pos)
+end
+
+# UGGGGGH
+# so, turns out, the part in git-scm where it says
+# > A trailing "/**" matches everything inside. For example, "abc/**" matches all files inside directory "abc", relative to the location of the .gitignore file, with infinite depth.
+# that "relative" bit gets REAL obnoxious when it comes to trying to evaluate using an adhoc core.excludesFile directive
+# speaking of, it seems like if you have one defined in the tree of a project git will STILL use that
+# see the special exception case mentioned below for the *.gem pattern conflicting with the project's .gitignore
+# there was no way to replace/unset it I could find that doesn't affect something more permanent >:/
+
+ignore_file = File.open("spec/files/.gitignore", "w+")
+
+Dir.chdir("spec/files") do
+  all_files = Dir.glob(File.join("**","**"), File::FNM_DOTMATCH)
+  all_files.reject! { |f| File.directory?(f) }
+  output[:all_files] = all_files
+
+  permutables = ["", "*", ".", "/", "*/", "/*", "**", "**/", "/**", "**/**", "*/**", "**/*"]
+  ignore_cases = permutables.map do |p1|
+    ["foo", "bar", "foo/bar"].map do |p2|
+      permutables.map do |p3|
+        "#{p1}#{p2}#{p3}"
+      end
+    end
+  end.flatten
+
+  # can add more one-off cases we want to evaluate here
+  ignore_cases << ".dot*"
+
+  ignore_cases.sort!
+  puts "Evaluating #{ignore_cases.size} permutations"
+
+  rootpath = Pathname.new(".")
+
+  ignore_cases.each do |perm|
+    puts "evaluating #{perm}"
+    reset_file_to(ignore_file, perm)
+    ignore_matches = []
+    ignore_results = `find . -type f | sed "s|^\./||" | tr '\n' '\\0' | xargs -0 -- git -c "core.quotepath=off" check-ignore --no-index -v -n`
+    ignore_results.scan(/^([^:]+):(\d+):([^\t]*)\t(.*)/).each do |m_source, m_line, m_pattern, m_file|
+      if m_source != ignore_file.path || m_line != "1" || m_pattern != perm
+        next if m_source == ".gitignore" && m_line == "1" && m_pattern == "*.gem"
+        puts "ERROR?!"
+        puts "expecting #{ignore_file.path.inspect}, got #{m_source.inspect}"
+        puts "expecting 1, got #{m_line.inspect}"
+        puts "expecting #{perm.inspect}, got #{m_pattern.inspect}"
+        puts ignore_results
+      end
+      ignore_matches << Pathname.new(m_file).relative_path_from(rootpath).to_s
+    end
+    output[:permutations][perm] = ignore_matches.sort
+  end
+
+  reset_file_to(ignore_file, "blah blah blah")
+end
+
+File.open("spec/permutations.json", "w+") do |perm_file|
+  perm_file.write(JSON.pretty_generate(output))
+end