codeowners-checker 1.0.4 → 1.0.5

data/lib/codeowners/cli/interactive_runner.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'interactive_resolver'
+require_relative 'interactive_ops'
+
+module Codeowners
+  module Cli
+    # Interactive session to resolve codeowners list issues
+    class InteractiveRunner
+      include InteractiveOps
+
+      attr_writer :validate_owners, :default_owner, :autocommit
+
+      def run_with(checker)
+        resolver = InteractiveResolver.new(checker, @validate_owners, @default_owner)
+        checker.fix!.each do |(error_type, inconsistencies, meta)|
+          resolver.handle(error_type, inconsistencies, meta)
+        end
+        resolver.print_epilogue
+        return unless resolver.made_changes?
+
+        write_changes(checker)
+        checker.commit_changes! if @autocommit || yes?('Commit changes?')
+      end
+
+      private
+
+      def write_changes(checker)
+        checker.codeowners.persist!
+        checker.owners_list.persist!
+      end
+    end
+  end
+end

data/lib/codeowners/cli/main.rb

@@ -1,32 +1,37 @@
 # frozen_string_literal: true
 
 require_relative '../checker'
+require_relative '../reporter'
 require_relative 'base'
 require_relative 'config'
 require_relative 'filter'
+require_relative 'owners_list_handler'
+require_relative '../github_fetcher'
 require_relative 'suggest_file_from_pattern'
 require_relative '../checker/owner'
+require_relative 'interactive_runner'
 
 module Codeowners
   module Cli
     # Command Line Interface used by bin/codeowners-checker.
-    class Main < Base # rubocop:disable Metrics/ClassLength
-      LABEL = { missing_ref: 'Missing references', useless_pattern: 'No files matching with the pattern' }.freeze
+    class Main < Base
       option :from, default: 'origin/master'
       option :to, default: 'HEAD'
       option :interactive, default: true, type: :boolean, aliases: '-i'
+      option :validateowners, default: true, type: :boolean, aliases: '-v'
       option :autocommit, default: false, type: :boolean, aliases: '-c'
       desc 'check REPO', 'Checks .github/CODEOWNERS consistency'
       # for pre-commit: --from HEAD --to index
       def check(repo = '.')
-        @codeowners_changed = false
-        @repo = repo
-        setup_checker
-        if options[:interactive]
-          interactive_mode
-        else
-          report_inconsistencies
+        checker = create_checker(repo)
+        if checker.consistent?
+          Reporter.print '✅ File is consistent'
+          exit 0
         end
+
+        options[:interactive] ? interactive_mode(checker) : report_inconsistencies(checker)
+
+        exit(-1)
       end
 
       desc 'filter <by-owner>', 'List owners of changed files'
@@ -35,234 +40,38 @@ module Codeowners
       desc 'config', 'Checks config is consistent or configure it'
       subcommand 'config', Codeowners::Cli::Config
 
+      desc 'fetch [REPO]', 'Fetches .github/OWNERS based on github organization'
+      subcommand 'fetch', Codeowners::Cli::OwnersListHandler
+
       private
 
-      def interactive_mode
-        @checker.fix!
-        return unless @codeowners_changed
+      def interactive_mode(checker)
+        runner = InteractiveRunner.new
+        runner.validate_owners = options[:validateowners]
+        runner.default_owner = @config.default_owner
+        runner.autocommit = options[:autocommit]
 
-        write_codeowners
-        @checker.commit_changes! if options[:autocommit] || yes?('Commit changes?')
+        runner.run_with(checker)
       end
 
-      def report_inconsistencies
-        if @checker.consistent?
-          puts '✅ File is consistent'
-          exit 0
-        else
-          puts "File #{@checker.codeowners_filename} is inconsistent:"
-          report_errors!
-          exit(-1)
-        end
+      def report_inconsistencies(checker)
+        Reporter.print "File #{checker.codeowners.filename} is inconsistent:"
+        report_errors!(checker)
       end
 
-      def setup_checker # rubocop:disable Metrics/AbcSize
+      def create_checker(repo)
+        from = options[:from]
         to = options[:to] != 'index' ? options[:to] : nil
-        @checker = Codeowners::Checker.new(@repo, options[:from], to)
-        @checker.when_useless_pattern = method(:suggest_fix_for)
-        @checker.when_new_file = method(:suggest_add_to_codeowners)
-        @checker.transformers << method(:unrecognized_line) if options[:interactive]
-      end
-
-      def write_codeowners
-        @checker.codeowners.persist!
-      end
-
-      def suggest_add_to_codeowners(file)
-        case add_to_codeowners_dialog(file)
-        when 'y' then add_to_codeowners(file)
-        when 'i' then nil
-        when 'q' then throw :user_quit
-        end
-      end
-
-      def add_to_codeowners_dialog(file)
-        ask(<<~QUESTION, limited_to: %w[y i q])
-          File added: #{file.inspect}. Add owner to the CODEOWNERS file?
-          (y) yes
-          (i) ignore
-          (q) quit and save
-        QUESTION
-      end
-
-      def add_to_codeowners(file)
-        new_line = create_new_pattern(file)
-
-        subgroups = @checker.main_group.subgroups_owned_by(new_line.owner)
-        add_pattern(new_line, subgroups)
-
-        @codeowners_changed = true
-      end
-
-      def create_new_pattern(file)
-        sorted_owners = @checker.main_group.owners.sort
-        list_owners(sorted_owners)
-        loop do
-          owner = new_owner(sorted_owners)
-
-          unless Codeowners::Checker::Owner.valid?(owner)
-            puts "#{owner.inspect} is not a valid owner name. Try again."
-            next
-          end
-
-          return Codeowners::Checker::Group::Pattern.new("#{file} #{owner}")
-        end
-      end
-
-      def list_owners(sorted_owners)
-        puts 'Owners:'
-        sorted_owners.each_with_index { |owner, i| puts "#{i + 1} - #{owner}" }
-        puts "Choose owner, add new one or leave empty to use #{@config.default_owner.inspect}."
-      end
-
-      def new_owner(sorted_owners)
-        owner = ask('New owner: ')
-
-        if owner.to_i.between?(1, sorted_owners.length)
-          sorted_owners[owner.to_i - 1]
-        elsif owner.empty?
-          @config.default_owner
-        else
-          owner
-        end
-      end
-
-      def add_pattern(pattern, subgroups)
-        unless subgroups.empty?
-          return if insert_pattern_into_subgroup(pattern, subgroups)
-        end
-
-        @checker.main_group.add(pattern) if yes?('Add to the end of the CODEOWNERS file?')
-      end
-
-      def insert_pattern_into_subgroup(pattern, subgroups)
-        subgroup = suggest_subgroups_for_pattern(subgroups).to_i - 1
-        return unless subgroup >= 0 && subgroup < subgroups.length
-
-        subgroups[subgroup].insert(pattern)
-        true
-      end
-
-      def suggest_subgroups_for_pattern(subgroups)
-        puts 'Possible groups to which the pattern belongs: '
-        subgroups.each_with_index { |group, i| puts "#{i + 1} - #{group.title}" }
-        ask('Choose group: ')
+        checker = Codeowners::Checker.new(repo, from, to)
+        checker.owners_list.validate_owners = options[:validateowners]
+        checker
       end
 
-      def suggest_fix_for(line)
-        return unless options[:interactive]
-
-        puts "Pattern #{line.pattern.inspect} doesn't match."
-        suggestion = Codeowners::Cli::SuggestFileFromPattern.new(line.pattern).pick_suggestion
-
-        # TODO: Handle duplicate patterns.
-        if suggestion
-          apply_suggestion(line, suggestion)
-        else
-          pattern_fix(line)
-        end
-
-        @codeowners_changed = true
-      end
-
-      def apply_suggestion(line, suggestion)
-        case make_suggestion(suggestion)
-        when 'i' then nil
-        when 'y' then line.pattern = suggestion
-        when 'e' then pattern_change(line)
-        when 'd' then line.remove!
-        when 'q' then throw :user_quit
-        end
-      end
-
-      def make_suggestion(suggestion)
-        ask(<<~QUESTION, limited_to: %w[y i e d q])
-          Replace with: #{suggestion.inspect}?
-          (y) yes
-          (i) ignore
-          (e) edit the pattern
-          (d) delete the pattern
-          (q) quit and save
-        QUESTION
-      end
-
-      def pattern_fix(line)
-        case pattern_suggest_fixing
-        when 'e' then pattern_change(line)
-        when 'i' then nil
-        when 'd' then line.remove!
-        when 'q' then throw :user_quit
-        end
-      end
-
-      def pattern_suggest_fixing
-        ask(<<~QUESTION, limited_to: %w[i e d q])
-          (e) edit the pattern
-          (d) delete the pattern
-          (i) ignore
-          (q) quit and save
-        QUESTION
-      end
-
-      def pattern_change(line)
-        new_pattern = ask("Replace pattern #{line.pattern.inspect} with: ")
-        return if new_pattern.empty?
-
-        line.pattern = new_pattern
-      end
-
-      def unrecognized_line(line)
-        return line unless line.is_a?(Codeowners::Checker::Group::UnrecognizedLine)
-
-        case unrecognized_line_suggest_fixing(line)
-        when 'i' then line
-        when 'y' then unrecognized_line_new_line
-        when 'd' then nil
-        end
-      end
-
-      def unrecognized_line_suggest_fixing(line)
-        ask(<<~QUESTION, limited_to: %w[y i d])
-          #{line.to_s.inspect} is in unrecognized format. Would you like to edit?
-          (y) yes
-          (i) ignore
-          (d) delete the line
-        QUESTION
-      end
-
-      def unrecognized_line_new_line
-        line = nil
-        loop do
-          new_line_string = ask('New line: ')
-          line = Codeowners::Checker::Group::Line.build(new_line_string)
-          break unless line.is_a?(Codeowners::Checker::Group::UnrecognizedLine)
-        end
-        @codeowners_changed = true
-        line
-      end
-
-      def ask(message, *opts)
-        return unless options[:interactive]
-
-        super
-      end
-
-      def yes?(message, *opts)
-        return unless options[:interactive]
-
-        super
-      end
-
-      LABELS = {
-        missing_ref: 'No owner defined',
-        useless_pattern: 'Useless patterns'
-      }.freeze
-
-      def report_errors!
-        @checker.fix!.each do |error_type, inconsistencies|
-          next if inconsistencies.empty?
-
-          puts LABELS[error_type], '-' * 30, inconsistencies, '-' * 30
+      def report_errors!(checker)
+        checker.fix!.reduce(nil) do |prev_error_type, (error_type, inconsistencies, meta)|
+          Reporter.print_delimiter_line(error_type) if prev_error_type != error_type
+          Reporter.print_error(error_type, inconsistencies, meta)
+          error_type
         end
       end
     end

data/lib/codeowners/cli/owners_list_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../checker/owners_list'
+
+module Codeowners
+  module Cli
+    # Command Line Interface dealing with OWNERS generation and validation
+    class OwnersListHandler < Base
+      default_task :fetch
+
+      desc 'fetch [REPO]', 'Fetches .github/OWNERS based on github organization'
+      def fetch(repo = '.')
+        @repo = repo
+        owners = owners_from_github
+        owners_list = Checker::OwnersList.new(repo)
+        owners_list.owners = owners
+        owners_list.persist!
+      end
+
+      no_commands do
+        def owners_from_github
+          organization = ENV['GITHUB_ORGANIZATION']
+          organization ||= ask('GitHub organization (e.g. github): ')
+          token = ENV['GITHUB_TOKEN']
+          token ||= ask('Enter GitHub token: ', echo: false)
+          puts 'Fetching owners list from GitHub ...'
+          Codeowners::GithubFetcher.get_owners(organization, token)
+        end
+      end
+    end
+  end
+end

data/lib/codeowners/cli/wizards.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Codeowners
+  module Cli
+    # Contains helper classes that prompt the user for information
+    # required to resolve detected issues in interactive mode.
+    # They only return acquired information without applying any modifications.
+    module Wizards
+    end
+  end
+end

data/lib/codeowners/cli/wizards/new_file_wizard.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../interactive_ops'
+
+module Codeowners
+  module Cli
+    module Wizards
+      # Suggests to add new files to the codeowners list.
+      # Only returns decision without applying any modifications.
+      class NewFileWizard
+        include InteractiveOps
+
+        def initialize(default_owner)
+          @default_owner = default_owner
+        end
+
+        def suggest_adding(file, main_group)
+          case prompt(file)
+          when 'y' then [:add, create_pattern(file, main_group)]
+          when 'i' then :ignore
+          when 'q' then :quit
+          end
+        end
+
+        def select_operation(pattern, main_group)
+          subgroups = main_group.subgroups_owned_by(pattern.owner)
+          if subgroups.any? && (subgroup = prompt_subgroup(subgroups))
+            [:insert_into_subgroup, subgroup]
+          elsif yes?('Add to the end of the CODEOWNERS file?')
+            :add_to_main_group
+          else
+            :ignore
+          end
+        end
+
+        private
+
+        def prompt(file)
+          ask(<<~QUESTION, limited_to: %w[y i q])
+            File added: #{file.inspect}. Add owner to the CODEOWNERS file?
+            (y) yes
+            (i) ignore
+            (q) quit and save
+          QUESTION
+        end
+
+        def create_pattern(file, main_group)
+          sorted_owners = main_group.owners.sort
+          owner = prompt_owner(sorted_owners)
+          Codeowners::Checker::Group::Pattern.new("#{file} #{owner}")
+        end
+
+        def prompt_owner(sorted_owners)
+          list_existing_owners(sorted_owners)
+          loop do
+            owner = do_prompt_owner(sorted_owners)
+
+            unless Codeowners::Checker::Owner.valid?(owner)
+              puts "#{owner.inspect} is not a valid owner name. Try again."
+              next
+            end
+
+            return owner
+          end
+        end
+
+        def list_existing_owners(sorted_owners)
+          puts 'Owners:'
+          sorted_owners.each_with_index { |owner, i| puts "#{i + 1} - #{owner}" }
+          puts "Choose owner, add new one or leave empty to use #{@default_owner.inspect}."
+        end
+
+        def do_prompt_owner(sorted_owners)
+          input = ask('New owner: ')
+
+          if input.to_i.between?(1, sorted_owners.length)
+            sorted_owners[input.to_i - 1]
+          elsif input.empty?
+            @default_owner
+          else
+            input
+          end
+        end
+
+        def prompt_subgroup(subgroups)
+          puts 'Possible groups to which the pattern belongs: '
+          subgroups.each_with_index { |group, i| puts "#{i + 1} - #{group.title}" }
+          choice = ask('Choose group: ').to_i
+          subgroups[choice - 1] if choice.between?(1, subgroups.length)
+        end
+      end
+    end
+  end
+end