code_owners 1.0.9 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: add8d9474667ea07ea6ad3e207e9a0e085109ac9
-  data.tar.gz: 86f55b021ef6314614ac2e5f2a59dfec43adbcd1
+SHA256:
+  metadata.gz: baea109754326800382bc8665df1e20634680187a1209f612bcc14f1447a962e
+  data.tar.gz: 25975f589029d740031c6c14832341a605fa885386be3f88bcb992cb427b1bf0
 SHA512:
-  metadata.gz: 6bc09a62ef1d0b86e7a9be070b27c5ed0e21be5b797f29b2597b3c06ffecc8210fd50906319f67028bc8e8a4df3aa2b575ab5ae49a083f2af029f43182d9d074
-  data.tar.gz: 62e13f5c44667eff192eabb510dca677a2088e58ce123e3dbaf4ccd16c8ebf9eb1dffa8125d5524161de36df730b9eea83093776ea6a55fb40c72df6f741eec3
+  metadata.gz: be4b52ceca387c455f3b597f47c3f61aed0d3c381eb4d52e6f2d9c25311d0505704ebb817af0ab73892521bdb1f804fc3a560bfb49c54e1f62b03bf20fe6b796
+  data.tar.gz: b31b2929d9023a3609bbd8286b4579ff87c8af5f4a6fc9025ccce9f8bdbddb65c09facf92c7a6873dd20423e925e083de41ba7de8800210ea2cf2b67b749082a

data/.github/CODEOWNERS

@@ -4,6 +4,7 @@
 
 # empty line followed by a comment?!  madness
 lib/*                   @jcheatham
+**/bar/** @jcheatham
 spec/*                  @jcheatham
 Rakefile                @jcheatham
 

data/Gemfile.lock

@@ -1,13 +1,15 @@
 PATH
   remote: .
   specs:
-    code_owners (1.0.9)
+    code_owners (2.0.0)
+      pathspec
       rake
 
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.3)
+    pathspec (0.2.1)
     rake (13.0.6)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)

data/README.md

@@ -1,5 +1,7 @@
 Utility gem for .github/CODEOWNERS introspection
 
+GitHub's [CODEOWNERS rules](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners) are allegedly based on the gitignore format with a few small exceptions.
+
 Install
 =======
 
@@ -14,7 +16,18 @@ Requirements
 Usage
 =====
 
-    your/repo/path$ code_owners
+```
+your/repo/path$ code_owners --help
+usage: code_owners [options]
+    -u, --unowned         Display unowned files only
+    -e, --error-unowned   Exit with error status if any files are unowned
+    -i, --ignore FILE     A file of gitignore patterns to filter out of results, may be specified multiple times, only supported by -n option for now
+    -l, --log             Log stuff
+    -n, --no-git          [experimental] Use a git-free, pure ruby based implementation
+    -v, --version         Display the version of the gem
+```
+
+Several of those get transformed into option flags that get passed along to CodeOwners.ownerships, see [bin/codeowners](https://github.com/jcheatham/code_owners/blob/main/bin/code_owners)
 
 Output
 ======
@@ -32,9 +45,9 @@ Maybe put it in a cleanliness test, like:
 
 ```ruby
 it "does not introduce new unowned files" do
-unowned_files = CodeOwners.ownerships.select { |f| f[:owner] == CodeOwners::NO_OWNER }
-# this number should only decrease, never increase!
-assert_equal 12345, unowned_files.count, "Claim ownership of your new files in .github/CODEOWNERS to fix this test!"
+  unowned_files = CodeOwners.ownerships.select { |f| f[:owner] == CodeOwners::NO_OWNER }
+  # this number should only decrease, never increase!
+  assert_equal 12345, unowned_files.count, "Claim ownership of your new files in .github/CODEOWNERS to fix this test!"
 end
 ```
 

data/bin/code_owners

@@ -1,21 +1,11 @@
 #!/usr/bin/env ruby
 
-unless system('git --version > /dev/null')
-  STDERR.puts 'Git does not appear to be installed.'
-  exit 2
-end
-
-unless system('git rev-parse --is-inside-work-tree > /dev/null')
-  STDERR.puts 'The current working directory must be a Git repo.'
-  exit 3
-end
-
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 require 'code_owners'
 require 'code_owners/version'
 require 'optparse'
 
-options = {}
+options = {ignores: []}
 OptionParser.new do |opts|
   opts.banner = "usage: code_owners [options]"
   opts.on('-u', '--unowned', TrueClass, 'Display unowned files only') do |u|
@@ -24,14 +14,35 @@ OptionParser.new do |opts|
   opts.on('-e', '--error-unowned', TrueClass, 'Exit with error status if any files are unowned') do |e|
     options[:error_unowned] = e
   end
+  opts.on('-i', '--ignore FILE', String, 'A file of gitignore patterns to filter out of results, may be specified multiple times, only supported by -n option for now') do |i|
+    options[:ignores] << i
+  end
+  opts.on('-l', '--log', TrueClass, 'Log stuff') do |l|
+    options[:log] = l
+  end
+  opts.on('-n', '--no-git', TrueClass, '[experimental] Use a git-free, pure ruby based implementation') do |n|
+     options[:no_git] = n
+   end
   opts.on('-v', '--version', TrueClass, 'Display the version of the gem') do |_|
     puts "Version: #{CodeOwners::VERSION}"
     exit 0
   end
 end.parse!
 
+unless options[:no_git]
+  unless system('git --version > /dev/null')
+    STDERR.puts 'Git does not appear to be installed.'
+    exit 2
+  end
+
+  unless system('git rev-parse --is-inside-work-tree > /dev/null')
+    STDERR.puts 'The current working directory must be a Git repo.'
+    exit 3
+  end
+end
+
 unowned_error = false
-CodeOwners.ownerships.each do |ownership_status|
+CodeOwners.ownerships(options).each do |ownership_status|
   owner_info = ownership_status[:owner].dup
   if owner_info != CodeOwners::NO_OWNER
     next if options[:unowned]

data/code_owners.gemspec

@@ -19,4 +19,5 @@ Gem::Specification.new name, CodeOwners::VERSION do |s|
 
   s.add_development_dependency "rspec"
   s.add_runtime_dependency "rake"
+  s.add_runtime_dependency "pathspec"
 end

data/lib/code_owners/version.rb

@@ -1,3 +1,3 @@
 module CodeOwners
-  VERSION = "1.0.9"
+  VERSION = "2.0.0"
 end

data/lib/code_owners.rb

@@ -1,30 +1,37 @@
 require "code_owners/version"
 require "tempfile"
+require "pathspec"
 
 module CodeOwners
+
   NO_OWNER = 'UNOWNED'
+  CODEOWNER_PATTERN = /(.*?)\s+((?:[^\s]*@[^\s]+\s*)+)/
+  POTENTIAL_LOCATIONS = ["CODEOWNERS", "docs/CODEOWNERS", ".github/CODEOWNERS"]
+
   class << self
 
-    # github's CODEOWNERS rules (https://help.github.com/articles/about-codeowners/) are allegedly based on the gitignore format.
-    # but you can't tell ls-files to ignore tracked files via an arbitrary pattern file
-    # so we need to jump through some hacky git-fu hoops
-    #
-    # -c "core.excludesfiles=somefile" -> tells git to use this as our gitignore pattern source
-    # check-ignore -> debug gitignore / exclude files
-    # --no-index -> don't look in the index when checking, can be used to debug why a path became tracked
-    # -v -> verbose, outputs details about the matching pattern (if any) for each given pathname
-    # -n -> non-matching, shows given paths which don't match any pattern
-
-    def log(message)
-      puts message
+    # helper function to create the lookup for when we have a file and want to find its owner
+    def file_ownerships(opts = {})
+      Hash[ ownerships(opts).map { |o| [o[:file], o] } ]
     end
 
-    def file_ownerships
-      Hash[ ownerships.map { |o| [o[:file], o] } ]
+    # this maps the collection of ownership patterns and owners to actual files
+    def ownerships(opts = {})
+      log("Calculating ownerships for #{opts.inspect}", opts)
+      patterns = pattern_owners(codeowners_data(opts), opts)
+      if opts[:no_git]
+        files = files_to_own(opts)
+        ownerships_by_ruby(patterns, files, opts)
+      else
+        ownerships_by_gitignore(patterns, opts)
+      end
     end
 
-    def ownerships
-      patterns = pattern_owners
+
+    ####################
+    # gitignore approach
+
+    def ownerships_by_gitignore(patterns, opts = {})
       git_owner_info(patterns.map { |p| p[0] }).map do |line, pattern, file|
         if line.empty?
           { file: file, owner: NO_OWNER, line: nil, pattern: nil }
@@ -39,35 +46,6 @@ module CodeOwners
       end
     end
 
-    def search_codeowners_file
-      paths = ["CODEOWNERS", "docs/CODEOWNERS", ".github/CODEOWNERS"]
-      for path in paths
-        current_file_path = File.join(current_repo_path, path)
-        return current_file_path if File.exist?(current_file_path)
-      end
-      abort("[ERROR] CODEOWNERS file does not exist.")
-    end
-
-    # read the github file and spit out a slightly formatted list of patterns and their owners
-    # Empty/invalid/commented lines are still included in order to preserve line numbering
-    def pattern_owners
-      codeowner_path = search_codeowners_file
-      patterns = []
-      File.read(codeowner_path).split("\n").each_with_index { |line, i|
-        path_owner = line.split(/\s+@/, 2)
-        if line.match(/^\s*(?:#.*)?$/)
-          patterns.push ['', ''] # Comment/empty line
-        elsif path_owner.length != 2 || (path_owner[0].empty? && !path_owner[1].empty?)
-          log "Parse error line #{(i+1).to_s}: \"#{line}\""
-          patterns.push ['', ''] # Invalid line
-        else
-          path_owner[1] = '@'+path_owner[1]
-          patterns.push path_owner
-        end
-      }
-      return patterns
-    end
-
     def git_owner_info(patterns)
       make_utf8(raw_git_owner_info(patterns)).lines.map do |info|
         _, _exfile, line, pattern, file = info.strip.match(/^(.*):(\d*):(.*)\t(.*)$/).to_a
@@ -75,8 +53,19 @@ module CodeOwners
       end
     end
 
-    # expects an array of gitignore compliant patterns
-    # generates a check-ignore formatted string for each file in the repo
+    # IN: an array of gitignore* check-ignore compliant patterns
+    # OUT: a check-ignore formatted string for each file in the repo
+    #
+    # * https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners#syntax-exceptions
+    # sadly you can't tell ls-files to ignore tracked files via an arbitrary pattern file
+    # so we jump through some hacky git-fu hoops
+    #
+    # -c "core.quotepath=off" ls-files -z   # prevent quoting the path and null-terminate each line to assist with matching stuff with spaces
+    # -c "core.excludesfiles=somefile"      # tells git to use this as our gitignore pattern source
+    # check-ignore                          # debug gitignore / exclude files
+    # --no-index                            # don't look in the index when checking, can be used to debug why a path became tracked
+    # -v                                    # verbose, outputs details about the matching pattern (if any) for each given pathname
+    # -n                                    # non-matching, shows given paths which don't match any pattern
     def raw_git_owner_info(patterns)
       Tempfile.open('codeowner_patterns') do |file|
         file.write(patterns.join("\n"))
@@ -85,8 +74,115 @@ module CodeOwners
       end
     end
 
+
+    ###############
+    # ruby approach
+
+    def ownerships_by_ruby(patterns, files, opts = {})
+      ownerships = files.map { |f| { file: f, owner: NO_OWNER, line: nil, pattern: nil } }
+
+      patterns.each_with_index do |(pattern, owner), i|
+        next if pattern == ""
+        pattern = pattern.gsub(/\/\*$/, "/**")
+        spec_pattern = PathSpec::GitIgnoreSpec.new(pattern)
+        ownerships.each do |o|
+          next unless spec_pattern.match(o[:file])
+          o[:owner]   = owner
+          o[:line]    = i+1
+          o[:pattern] = pattern
+        end
+      end
+
+      ownerships
+    end
+
+
+
+    ##############
+    # helper stuff
+
+    # read the github file and spit out a slightly formatted list of patterns and their owners
+    # Empty/invalid/commented lines are still included in order to preserve line numbering
+    def pattern_owners(codeowner_data, opts = {})
+      patterns = []
+      codeowner_data.split("\n").each_with_index do |line, i|
+        stripped_line = line.strip
+        if stripped_line == "" || stripped_line.start_with?("#")
+          patterns << ['', ''] # Comment / empty line
+
+        elsif stripped_line.start_with?("!")
+          # unsupported per github spec
+          log("Parse error line #{(i+1).to_s}: \"#{line}\"", opts)
+          patterns << ['', '']
+
+        elsif stripped_line.match(CODEOWNER_PATTERN)
+          patterns << [$1, $2]
+
+        else
+          log("Parse error line #{(i+1).to_s}: \"#{line}\"", opts)
+          patterns << ['', '']
+
+        end
+      end
+      patterns
+    end
+
+    def log(message, opts = {})
+      puts message if opts[:log]
+    end
+
     private
 
+    # https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners#codeowners-file-location
+    # To use a CODEOWNERS file, create a new file called CODEOWNERS in the root, docs/, or .github/ directory of the repository, in the branch where you'd like to add the code owners.
+
+    # if we have access to git, use that to figure out our current repo path and look in there for codeowners
+    # if we don't, this function will attempt to find it while walking back up the directory tree
+    def codeowners_data(opts = {})
+      if opts[:codeowner_data]
+        return opts[:codeowner_data]
+      elsif opts[:codeowner_path]
+        return File.read(opts[:codeowner_path]) if File.exist?(opts[:codeowner_path])
+      elsif opts[:no_git]
+        path = Dir.pwd.split(File::SEPARATOR)
+        while !path.empty?
+          POTENTIAL_LOCATIONS.each do |pl|
+            current_file_path = File.join(path, pl)
+            return File.read(current_file_path) if File.exist?(current_file_path)
+          end
+          path.pop
+        end
+      else
+        path = current_repo_path
+        POTENTIAL_LOCATIONS.each do |pl|
+          current_file_path = File.join(path, pl)
+          return File.read(current_file_path) if File.exist?(current_file_path)
+        end
+      end
+      raise("[ERROR] CODEOWNERS file does not exist.")
+    end
+
+    def files_to_own(opts = {})
+      # glob all files
+      all_files_pattern = File.join("**","**")
+
+      # optionally prefix with list of directories to scope down potential evaluation space
+      if opts[:scoped_dirs]
+        all_files_pattern = File.join("{#{opts[:scoped_dirs].join(",")}}", all_files_pattern)
+      end
+
+      all_files = Dir.glob(all_files_pattern, File::FNM_DOTMATCH)
+      all_files.reject!{|f| f.start_with?(".git/") || File.directory?(f) }
+
+      # filter out ignores if we have them
+      opts[:ignores]&.each do |ignore|
+        ignores = PathSpec.new(File.readlines(ignore, chomp: true).map{|i| i.end_with?("/*") ? "#{i}*" : i })
+        all_files.reject! { |f| ignores.specs.any?{|p| p.match(f) } }
+      end
+
+      all_files
+    end
+
     def make_utf8(input)
       input.force_encoding(Encoding::UTF_8)
       return input if input.valid_encoding?

data/spec/code_owners_spec.rb

@@ -1,5 +1,6 @@
 require 'code_owners'
 require 'tmpdir'
+require 'json'
 
 RSpec.describe CodeOwners do |rspec|
   describe ".file_ownerships" do
@@ -20,66 +21,119 @@ RSpec.describe CodeOwners do |rspec|
   end
 
   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(
-        [
-          { file: "pat2file", owner: "own2", line: "2", pattern: "pat2*" },
-          { file: "unowned/file", owner: "UNOWNED", line: nil, pattern: nil }
-        ]
-      )
+    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*"},
+          {:file=>"foo/bar.rb", :owner=>"own3", :line=>3, :pattern=>"foo/**"},
+          {:file=>"foo/bar/baz.rb", :owner=>"own3", :line=>3, :pattern=>"foo/**"},
+          {:file=>"foo/bar/baz/meow.txt", :owner=>"own3", :line=>3, :pattern=>"foo/**"},
+          {: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
+
+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/code owners/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
@@ -112,6 +166,71 @@ CODEOWNERS
     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
     VERSION_REGEX = /Version: \d+\.\d+\.\d+(-[a-z0-9]+)?/i
 
@@ -123,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/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