code_owners 1.0.8 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0c170835202aa29d1d863ac544a039dfa2aaca9b
-  data.tar.gz: 732f6a87815efa4092ea1404b55180d9bde78f39
+SHA256:
+  metadata.gz: 42ad83e6c56f3bb34904d52dde4eb0f689fde59ea59868ecd4c428f3f13c8762
+  data.tar.gz: f8abb4f85d6fdf586432d047d9c24a521ea4411853a4a36e88de57556698d6a1
 SHA512:
-  metadata.gz: b205789714617196c0e067504e8beae29dc585a6601a79279475a3a17cc36b249d61e896c6972d8d2fc2b4780e5df406a86c92226ef6013fd6fb262087733ae6
-  data.tar.gz: 4e7766d5ee8b1adf676974e8dce8345ce93d2b4b9e868d4295578d35b5656897621c0dcf00e227377024946e2d7429c695e2bf86539fbd24a5992fdce2c9e4fd
+  metadata.gz: 80e88fb5714e128bcb401a8ecd7be79e631c3105c370d7ac275bc2ffd60ac92182b5d6090ad60782cba0cc6af89a60a0758466d4ebc703269ad83ea8d8cf5e4e
+  data.tar.gz: fa22fe034e7256b8637564a74803c044e85c675399978e8ccfc4d114b1b88d958501f5143c205d8cc159c40a1f823f269567cf6e22a84df896e5161f6a385113

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,27 +1,29 @@
 PATH
   remote: .
   specs:
-    code_owners (1.0.8)
+    code_owners (2.0.1)
+      pathspec
       rake
 
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.3)
+    diff-lcs (1.5.0)
+    pathspec (0.2.1)
     rake (13.0.6)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
 
 PLATFORMS
   ruby

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.8"
+  VERSION = "2.0.1"
 end

data/lib/code_owners.rb

@@ -1,26 +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
+
+    # this maps the collection of ownership patterns and owners to actual files
+    def ownerships(opts = {})
+      log("Calculating ownerships for #{opts.inspect}", opts)
+      patowns = pattern_owners(codeowners_data(opts), opts)
+      if opts[:no_git]
+        files = files_to_own(opts)
+        ownerships_by_ruby(patowns, files, opts)
+      else
+        ownerships_by_gitignore(patowns, 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 }
@@ -35,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
@@ -71,18 +53,147 @@ 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"))
         file.rewind
-        `cd #{current_repo_path} && git -c \"core.quotepath=off\" ls-files | xargs -- git -c \"core.quotepath=off\" -c \"core.excludesfile=#{file.path}\" check-ignore --no-index -v -n`
+        `cd #{current_repo_path} && git -c \"core.quotepath=off\" ls-files -z | xargs -0 -- git -c \"core.quotepath=off\" -c \"core.excludesfile=#{file.path}\" check-ignore --no-index -v -n`
+      end
+    end
+
+
+    ###############
+    # ruby approach
+
+    def ownerships_by_ruby(patowns, files, opts = {})
+      pattern_list = build_ruby_patterns(patowns, opts)
+      unowned = { owner: NO_OWNER, line: nil, pattern: nil }
+
+      files.map do |file|
+        last_match = nil
+        # have a flag to go through in reverse order as potential optimization?
+        # really depends on the data
+        pattern_list.each do |p|
+          last_match = p if p[:pattern_regex].match(file)
+        end
+        (last_match || unowned).dup.tap{|h| h[:file] = file }
+      end
+    end
+
+    def build_ruby_patterns(patowns, opts = {})
+      pattern_list = []
+      patowns.each_with_index do |(pattern, owner), i|
+        next if pattern == ""
+        pattern_list << {
+          owner: owner,
+          line: i+1,
+          pattern: pattern,
+          # gsub because spec approach needs a little help matching remainder of tree recursively
+          pattern_regex: PathSpec::GitIgnoreSpec.new(pattern.gsub(/\/\*$/, "/**"))
+        }
       end
+      pattern_list
+    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?