codeowners-checker 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e2f46c087d367f8963223d632e6231db0b4b010595fba6190dc362b06846af6
-  data.tar.gz: 48aecfde1e7f978742558e66752f05e6b452b565f04a43a0a951caf4c431d333
+  metadata.gz: fea710f9cf51fa064b3ac9fdd73290673959ebb8f1d3420fc10db85f38d427be
+  data.tar.gz: 81277d6cfdcb325372374a3ef09ef7d91526672b78c25f5b5e42bb756a150ab0
 SHA512:
-  metadata.gz: 154979b0d6a14f51fd914bcf6a2422e83e90ecf9c2afb3dfe19c476bfe0868ea1018fa6c8e53b0ee99342e8cbc7837bef2153fe8aa9f0385ef177600fd630719
-  data.tar.gz: 15fef3967b0859b85a6c053b1cd8dfcea829e02f2cdcc701c26906e3fea03b9e8c3823cfa63691cb4cfe7b0fb9d5b76070bd4698f38ceba86a15a5f3c12efd66
+  metadata.gz: 9170ec3459dcaeabb7cdd6abdde1faab7739db931f5bdb01e9a202cd6b2b794a1561a033272f6fd3c41798f8dc662ceb939e2ea17a121aca26ec8318639db875
+  data.tar.gz: 481e5e568f458f408e2d260538dfaba02da323f2267cca7969b662ece7ec61b163f7419f04221cac7a784c26aae59bbca48e677d394e5f66c37e218dd5f509bf

data/README.md

@@ -17,6 +17,35 @@ between two git revisions.
 
 It will configure `@owner` as the default owner in the config file.
 
+
+### Fetching and validating owners
+
+By default, [check](#check-file-consistency) command will validate owners either against the prepopulated file (OWNERS)
+or against data fetched from github.
+Format of OWNERS is one owner per line.
+
+Example OWNERS:
+```
+@company/backend-devs
+@company/frontend-devs
+@john.smith
+```
+GitHub credentials are taken from the following environment variables. You might want to put them into your .bashrc or equivalent:
+
+    $ export GITHUB_TOKEN='your GitHub PAT' # your personal access token from GitHub
+    $ export GITHUB_ORGANIZATION='company' # name of your GitHub organization
+
+You can generate your PAT in [Settings -> Developer settings -> Personal access tokens on GitHub](https://github.com/settings/tokens) and `read:org` scope is **required**.
+
+If you don't want to fetch the list from GitHub every-time you run codeowners-checker, you can fetch it and store in your repository
+alongside of CODEOWNERS. The following prompt will also ask for your GitHub PAT/organization in case it is not already in environment:
+
+    $  codeowners-checker fetch
+
+You can also turn off the validation using the following
+
+    $  codeowners-checker check --no-validateowners
+
 ### Check file consistency
 
 To check if your CODEOWNERS file is consistent with your current project you can run

data/bin/codeowners-checker

@@ -4,5 +4,4 @@
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 
 require 'codeowners/cli/main'
-
 Codeowners::Cli::Main.start ARGV

data/codeowners-checker.gemspec

@@ -22,6 +22,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'fuzzy_match', '~> 2.1'
   spec.add_dependency 'git', '~> 1.5'
+  spec.add_dependency 'json', '~> 2.1'
+  spec.add_dependency 'rest-client', '~> 2.1'
   spec.add_dependency 'thor', '~> 0.20.3'
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'pry', '~> 0.12.2'

data/lib/codeowners/checker.rb

@@ -6,13 +6,16 @@ require 'logger'
 require_relative 'checker/code_owners'
 require_relative 'checker/file_as_array'
 require_relative 'checker/group'
+require_relative 'checker/owners_list'
 
 module Codeowners
   # Check if code owners are consistent between a git repository and the CODEOWNERS file.
   # It compares what's being changed in the PR and check if the current files and folders
   # are also being declared in the CODEOWNERS file.
+  # By default (:validate_owners property) it also reads OWNERS with list of all
+  # possible/valid owners and validates every owner in CODEOWNERS is defined in OWNERS
   class Checker
-    attr_accessor :when_useless_pattern, :when_new_file
+    attr_reader :owners_list
 
     # Get repo metadata and compare with the owners
     def initialize(repo, from, to)
@@ -20,10 +23,7 @@ module Codeowners
       @repo_dir = repo
       @from = from || 'HEAD'
       @to = to
-    end
-
-    def transformers
-      @transformers ||= []
+      @owners_list = OwnersList.new(@repo_dir)
     end
 
     def changes_to_analyze
@@ -35,7 +35,7 @@ module Codeowners
     end
 
     def fix!
-      catch(:user_quit) { results }
+      Enumerator.new { |yielder| catch(:user_quit) { results.each { |r| yielder << r } } }
     end
 
     def changes_for_patterns(patterns)
@@ -64,18 +64,13 @@ module Codeowners
     end
 
     def useless_pattern
-      codeowners.select do |line|
-        next unless line.pattern?
-
-        unless pattern_has_files(line.pattern)
-          @when_useless_pattern&.call(line)
-          true
-        end
+      @useless_pattern ||= codeowners.select do |line|
+        line.pattern? && !pattern_has_files(line.pattern)
       end
     end
 
     def missing_reference
-      added_files.reject(&method(:defined_owner?))
+      @missing_reference ||= added_files.reject(&method(:defined_owner?))
     end
 
     def pattern_has_files(pattern)
@@ -89,14 +84,12 @@ module Codeowners
         return true if line.match_file?(file)
       end
 
-      @when_new_file&.call(file) if @when_new_file
       false
     end
 
     def codeowners
       @codeowners ||= CodeOwners.new(
-        FileAsArray.new(codeowners_filename),
-        transformers: transformers
+        FileAsArray.new(CodeOwners.filename(@repo_dir))
       )
     end
 
@@ -105,28 +98,32 @@ module Codeowners
     end
 
     def consistent?
-      results.values.all?(&:empty?)
+      results.none?
     end
 
     def commit_changes!
-      @git.add(codeowners_filename)
+      @git.add(File.realpath(@codeowners.filename))
+      @git.add(File.realpath(@owners_list.filename))
       @git.commit('Fix pattern :robot:')
     end
 
-    def codeowners_filename
-      directories = ['', '.github', 'docs', '.gitlab']
-      paths = directories.map { |dir| File.join(@repo_dir, dir, 'CODEOWNERS') }
-      Dir.glob(paths).first || paths.first
+    def unrecognized_line
+      @unrecognized_line ||= codeowners.select { |line| line.is_a?(Codeowners::Checker::Group::UnrecognizedLine) }
     end
 
     private
 
+    def invalid_owners
+      @invalid_owners ||= @owners_list.invalid_owners(codeowners)
+    end
+
     def results
-      @results ||=
-        {
-          missing_ref: missing_reference,
-          useless_pattern: useless_pattern
-        }
+      @results ||= Enumerator.new do |yielder|
+        missing_reference.each { |ref| yielder << [:missing_ref, ref] }
+        useless_pattern.each { |pattern| yielder << [:useless_pattern, pattern] }
+        invalid_owners.each { |(owner, missing)| yielder << [:invalid_owner, owner, missing] }
+        unrecognized_line.each { |line| yielder << [:unrecognized_line, line] }
+      end
     end
   end
 end

data/lib/codeowners/checker/code_owners.rb

@@ -9,18 +9,15 @@ module Codeowners
     class CodeOwners
       include Enumerable
 
-      attr_reader :file_manager, :transform_line_procs
+      attr_reader :file_manager
 
-      def initialize(file_manager, transformers: nil)
+      def initialize(file_manager)
         @file_manager = file_manager
-        @transform_line_procs = [
-          method(:build_line),
-          *transformers
-        ]
       end
 
       def persist!
         file_manager.content = main_group.to_file
+        file_manager.persist!
       end
 
       def main_group
@@ -35,16 +32,20 @@ module Codeowners
         main_group.to_content
       end
 
+      def self.filename(repo_dir)
+        directories = ['', '.github', 'docs', '.gitlab']
+        paths = directories.map { |dir| File.join(repo_dir, dir, 'CODEOWNERS') }
+        Dir.glob(paths).first || paths.first
+      end
+
+      def filename
+        @file_manager.filename
+      end
+
       private
 
       def list
-        @list ||= begin
-          list = @file_manager.content
-          transform_line_procs.each do |transform_line_proc|
-            list = list.flat_map { |line| transform_line_proc.call(line) }.compact
-          end
-          list
-        end
+        @list ||= @file_manager.content.flat_map { |line| build_line(line) }.compact
       end
 
       def build_line(line)

data/lib/codeowners/checker/file_as_array.rb

@@ -4,26 +4,27 @@ module Codeowners
   class Checker
     # Convert CODEOWNERS file content to an array.
     class FileAsArray
-      def initialize(file)
-        @file = file
-        @target_dir, = File.split(@file)
+      attr_writer :content
+      attr_reader :filename
+
+      def initialize(filename)
+        @filename = filename
+        @target_dir, = File.split(@filename)
       end
 
       # @return <Array> of lines chomped
       def content
-        @content ||= File.readlines(@file).map(&:chomp)
+        @content ||= File.readlines(@filename).map(&:chomp)
       rescue Errno::ENOENT
         @content = []
       end
 
       # Save content to the @file
       # Creates the directory of the file if needed
-      def content=(content)
-        @content = content
-
+      def persist!
         Dir.mkdir(@target_dir) unless Dir.exist?(@target_dir)
 
-        File.open(@file, 'w+') do |f|
+        File.open(@filename, 'w+') do |f|
           f.puts content
         end
       end

data/lib/codeowners/checker/group/pattern.rb

@@ -26,6 +26,11 @@ module Codeowners
           owners.first
         end
 
+        def rename_owner(owner, new_owner)
+          owners.delete(owner)
+          owners << new_owner unless owners.include?(new_owner)
+        end
+
         # Parse the line counting whitespaces between pattern and owners.
         def parse(line)
           @pattern, *@owners = line.split(/\s+/)

data/lib/codeowners/checker/owners_list.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'file_as_array'
+
+module Codeowners
+  class Checker
+    # Manage OWNERS file reading, re-writing and fetching
+    class OwnersList
+      attr_accessor :validate_owners, :filename
+      attr_writer :owners
+
+      def initialize(repo)
+        @validate_owners = true
+        # doing gsub here ensures the files are always in the same directory
+        @filename = CodeOwners.filename(repo).gsub('CODEOWNERS', 'OWNERS')
+      end
+
+      def persist!
+        owners_file = FileAsArray.new(@filename)
+        owners_file.content = @owners
+        owners_file.persist!
+      end
+
+      def valid_owner?(owner)
+        !@validate_owners || owners.include?(owner)
+      end
+
+      def owners
+        return [] unless @validate_owners
+
+        @owners ||=
+          if github_credentials_exist?
+            Codeowners::GithubFetcher.get_owners(ENV['GITHUB_ORGANIZATION'], ENV['GITHUB_TOKEN'])
+          else
+            FileAsArray.new(@filename).content
+          end
+      end
+
+      def github_credentials_exist?
+        token = ENV['GITHUB_TOKEN']
+        organization = ENV['GITHUB_ORGANIZATION']
+        token && organization
+      end
+
+      def invalid_owners(codeowners)
+        return [] unless @validate_owners
+
+        codeowners.each_with_object([]) do |line, acc|
+          next unless line.pattern?
+
+          missing = line.owners - owners
+          acc.push([line, missing]) if missing.any?
+        end
+      end
+
+      def <<(owner)
+        return if @owners.include?(owner)
+
+        @owners << owner
+      end
+    end
+  end
+end

data/lib/codeowners/checker/version.rb

@@ -2,6 +2,6 @@
 
 module Codeowners
   class Checker
-    VERSION = '1.0.4'
+    VERSION = '1.0.5'
   end
 end

data/lib/codeowners/cli/interactive_ops.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Codeowners
+  module Cli
+    # Provides convenience methods like :ask, :yes? without subclassing Thor
+    module InteractiveOps
+      def yes?(statement, color = nil)
+        thor.yes?(statement, color)
+      end
+
+      def ask(statement, *args)
+        thor.ask(statement, *args)
+      end
+
+      private
+
+      def thor
+        @thor ||= Thor.new
+      end
+    end
+  end
+end

data/lib/codeowners/cli/interactive_resolver.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative 'wizards/new_file_wizard'
+require_relative 'wizards/new_owner_wizard'
+require_relative 'wizards/unrecognized_line_wizard'
+require_relative 'wizards/useless_pattern_wizard'
+
+module Codeowners
+  module Cli
+    # Resolve issues in interactive mode
+    # handle_* methods will throw :user_quit
+    # if the user chose to save and quit
+    class InteractiveResolver
+      def initialize(checker, validate_owners, default_owner)
+        @checker = checker
+        @ignored_owners = []
+        @validate_owners = validate_owners
+        @default_owner = default_owner
+        create_wizards
+      end
+
+      def handle(error_type, inconsistencies, meta)
+        case error_type
+        when :useless_pattern then handle_useless_pattern(inconsistencies)
+        when :missing_ref then handle_new_file(inconsistencies)
+        when :invalid_owner then handle_new_owners(inconsistencies, meta)
+        when :unrecognized_line then process_parsed_line(inconsistencies)
+        else raise ArgumentError, "unknown error_type: #{error_type}"
+        end
+      end
+
+      def handle_new_file(file) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        choice, pattern = @new_file_wizard.suggest_adding(file, @checker.main_group)
+        throw :user_quit if choice == :quit
+        return unless choice == :add
+
+        validate_owner(pattern, pattern.owner) if @validate_owners
+        op, subgroup = @new_file_wizard.select_operation(pattern, @checker.main_group)
+        case op
+        when :insert_into_subgroup
+          subgroup.insert(pattern)
+          @made_changes = true
+        when :add_to_main_group
+          @checker.main_group.add(pattern)
+          @made_changes = true
+        end
+      end
+
+      def handle_new_owners(line, missing_owners)
+        missing_owners.each { |owner| handle_new_owner(line, owner) }
+      end
+
+      def handle_new_owner(line, owner) # rubocop:disable Metrics/MethodLength
+        return if @ignored_owners.include?(owner)
+
+        choice, new_owner = @new_owner_wizard.suggest_fixing(line, owner)
+        case choice
+        when :add
+          @checker.owners_list << owner
+          @made_changes = true
+        when :rename
+          line.rename_owner(owner, new_owner)
+          @checker.owners_list << new_owner
+          @made_changes = true
+        when :ignore
+          @ignored_owners << owner
+        when :quit then throw :user_quit
+        end
+      end
+
+      def handle_useless_pattern(line)
+        choice, new_pattern = @useless_pattern_wizard.suggest_fixing(line)
+        case choice
+        when :replace
+          line.pattern = new_pattern
+          @made_changes = true
+        when :delete
+          line.remove!
+          @made_changes = true
+        when :quit then throw :user_quit
+        end
+      end
+
+      def process_parsed_line(line) # rubocop:disable Metrics/MethodLength
+        return line unless line.is_a?(Codeowners::Checker::Group::UnrecognizedLine)
+
+        choice, new_line = @unrecognized_line_wizard.suggest_fixing(line)
+        case choice
+        when :replace
+          @made_changes = true
+          new_line
+        when :delete
+          @made_changes = true
+          nil
+        when :ignore then line
+        end
+      end
+
+      def print_epilogue
+        return unless @ignored_owners.any?
+
+        puts 'Ignored owners:'
+        @ignored_owners.each do |owner|
+          puts " * #{owner}"
+        end
+      end
+
+      def made_changes?
+        @made_changes
+      end
+
+      private
+
+      def create_wizards
+        @new_owner_wizard = Wizards::NewOwnerWizard.new(@checker.owners_list)
+        @new_file_wizard = Wizards::NewFileWizard.new(@default_owner)
+        @useless_pattern_wizard = Wizards::UselessPatternWizard.new
+        @unrecognized_line_wizard = Wizards::UnrecognizedLineWizard.new
+      end
+
+      def validate_owner(pattern, owner)
+        return if @checker.owners_list.valid_owner?(pattern.owner)
+
+        handle_new_owners(pattern, [owner])
+      end
+    end
+  end
+end