code_owners 1.0.7 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd7998397d45dc60a1fb77fad414a119a9df181a61f5aa7b135ee674ebce9008
-  data.tar.gz: 3c3e4a62f8fb6a7650c90c7ac1975faf93edb91503092fa4f9a3092687e34587
+  metadata.gz: baea109754326800382bc8665df1e20634680187a1209f612bcc14f1447a962e
+  data.tar.gz: 25975f589029d740031c6c14832341a605fa885386be3f88bcb992cb427b1bf0
 SHA512:
-  metadata.gz: c635ae7dbc19ee970e7d8701545839437c20b8121af692d43c1b835693d53163f70fe5291984d28cbe4e41aecb9ce59dd43d75d33f3994b0e810e05dc87d26c9
-  data.tar.gz: fa2c93f8181119b3dc6a5d08ebaba882c9875c92835917de40a6e6650ec6e108aaedfb028d1843d695da537eaaf2a7f877828c3d0383003730ec512ca140a020
+  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,14 +1,16 @@
 PATH
   remote: .
   specs:
-    code_owners (1.0.7)
+    code_owners (2.0.0)
+      pathspec
       rake
 
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.3)
-    rake (12.3.3)
+    pathspec (0.2.1)
+    rake (13.0.6)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
@@ -31,4 +33,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.17.2
+   1.17.3

data/README.md

@@ -1,14 +1,33 @@
 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
 =======
 
     gem install code_owners
 
+Requirements
+============
+
+* Ruby
+* Git
+
 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
 ======
@@ -24,12 +43,12 @@ Development
 
 Maybe put it in a cleanliness test, like:
 
-```
-  it "does not introduce new unowned files" do
-    unowned_files = CodeOwners.ownerships.select { |f| f[:owner] == "UNOWNED" }
-    # 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
+```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!"
+end
 ```
 
 Author

data/bin/code_owners

@@ -2,9 +2,10 @@
 
 $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|
@@ -13,10 +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

@@ -8,10 +8,10 @@ Gem::Specification.new name, CodeOwners::VERSION do |s|
   s.description   = "utility gem for .github/CODEOWNERS introspection"
   s.authors       = "Jonathan Cheatham"
   s.email         = "coaxis@gmail.com"
-  s.homepage      = "http://github.com/jcheatham/#{s.name}"
+  s.homepage      = "https://github.com/jcheatham/#{s.name}"
   s.licenses      = "MIT"
 
-  s.files         = `git ls-files`.split("\n")
+  s.files         = `git -c "core.quotepath=off" ls-files`.split("\n")
   s.bindir        = 'bin'
   s.test_files    = `git ls-files -- test/*`.split("\n")
   s.require_paths = ["lib"]
@@ -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.7"
+  VERSION = "2.0.0"
 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)
+      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 }
@@ -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,136 @@ 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 ls-files | xargs -- git -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(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?