codeowners-checker 1.0.0

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'line'
+
+module Codeowners
+  class Checker
+    class Group
+      # Define and manage comment line.
+      class Comment < Line
+        # Matches if the line is a comment.
+        # @return [Boolean] if the line start with `#`
+        def self.match?(line)
+          line.start_with?('#')
+        end
+
+        # Return the comment level if the comment works like a markdown
+        # headers.
+        # @return [Integer] with the heading level.
+        #
+        # @example
+        #   Comment.new('# First level').level # => 1
+        #   Comment.new('## Second').level # => 2
+        def level
+          (@line[/^#+/] || '').size
+        end
+      end
+    end
+  end
+end
+
+require_relative 'group_begin_comment'
+require_relative 'group_end_comment'

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'line'
+
+module Codeowners
+  class Checker
+    class Group
+      # Define line type empty line.
+      class Empty < Line
+        def self.match?(line)
+          line.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'comment'
+
+module Codeowners
+  class Checker
+    class Group
+      # Define line type GroupBeginComment which is used for defining the beggining
+      # of a group.
+      class GroupBeginComment < Comment
+        def self.match?(line)
+          line.lstrip.start_with?(/^#+ BEGIN/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'comment'
+
+module Codeowners
+  class Checker
+    class Group
+      # Define line type GroupEndComment which is used for defining the end
+      # of a group.
+      class GroupEndComment < Comment
+        def self.match?(line)
+          line.lstrip.start_with?(/^#+ END/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Codeowners
+  class Checker
+    class Group
+      # It sorts lines from CODEOWNERS file to different line types and holds
+      # shared methods for all lines.
+      class Line
+        attr_accessor :parent
+
+        def self.build(line, transform_line_procs: nil)
+          subclasses.each do |klass|
+            return klass.new(line) if klass.match?(line)
+          end
+          UnrecognizedLine.new(line)
+        end
+
+        def self.subclasses
+          [Empty, GroupBeginComment, GroupEndComment, Comment, Pattern]
+        end
+
+        def initialize(line)
+          @line = line
+        end
+
+        def to_s
+          @line
+        end
+
+        def to_content
+          to_s
+        end
+
+        def pattern?
+          is_a?(Pattern)
+        end
+
+        def to_tree(indentation)
+          indentation + to_s
+        end
+
+        def remove!
+          parent&.remove(self)
+          parent = nil
+        end
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          other.to_s == to_s
+        end
+
+        def <=>(other)
+          to_s <=> other.to_s
+        end
+
+        # Pick all files from parent folder of pattern.
+        # This is used to build a list of suggestions case the pattern is not
+        # matching.
+        # If the pattern use "*/*" it will consider "."
+        # If the pattern uses Static files, it tries to reach the parent.
+        # If the pattern revers to the root folder, pick all files from the
+        # current pattern dir.
+        def suggest_files_for_pattern
+          parent_folders = pattern.split('/')[0..-2]
+          parent_folders << '*' if parent_folders[-1] != '*'
+          files = Dir[File.join(*parent_folders)] || []
+          files.map(&method(:normalize_path))
+        end
+
+        def normalize_path(file)
+          Pathname.new(file)
+                  .relative_path_from(Pathname.new('.')).to_s
+        end
+      end
+    end
+  end
+end
+
+require_relative 'empty'
+require_relative 'comment'
+require_relative 'pattern'
+require_relative 'unrecognized_line'

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'line'
+
+module Codeowners
+  class Checker
+    class Group
+      # Defines and manages line type pattern.
+      class Pattern < Line
+        attr_accessor :pattern, :owners
+
+        def self.match?(line)
+          _pattern, *owners = line.split(/\s+/)
+          owners.any? && owners.all? { |owner| owner.include?('@') }
+        end
+
+        def initialize(line)
+          super
+          parse(line)
+        end
+
+        def owner
+          owners.first
+        end
+
+        def parse(line)
+          @pattern, *@owners = line.split(/\s+/)
+        end
+
+        def match_file?(file)
+          regex.match(file)
+        end
+
+        def to_s
+          [@pattern, @owners].join(' ')
+        end
+
+        private
+
+        def regex
+          Regexp.new(pattern.gsub(%r{/\*\*}, '(/[^/]+)+').gsub(/\*/, '[^/]+'))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'line'
+
+module Codeowners
+  class Checker
+    class Group
+      # Hold lines which are not defined in other line classes.
+      class UnrecognizedLine < Line
+      end
+    end
+  end
+end

data/lib/codeowners/checker/line_grouper.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Codeowners
+  class Checker
+    # Create groups and subgroups structure for the lines in the CODEOWNERS file.
+    class LineGrouper
+      def self.call(group, lines)
+        new(group, lines).call
+      end
+
+      def initialize(group, lines)
+        @group_buffer = [group]
+        @lines = lines
+      end
+
+      def call
+        lines.each_with_index do |line, index|
+          case line
+          when Codeowners::Checker::Group::Empty
+            ensure_groups_structure
+          when Codeowners::Checker::Group::GroupBeginComment
+            trim_groups(line.level)
+            create_groups_structure(line.level)
+          when Codeowners::Checker::Group::GroupEndComment
+            trim_subgroups(line.level)
+            create_groups_structure(line.level)
+          when Codeowners::Checker::Group::Comment
+            if previous_line_empty?(index)
+              trim_groups(line.level)
+            else
+              trim_subgroups(line.level)
+            end
+            create_groups_structure(line.level)
+          when Codeowners::Checker::Group::Pattern
+            if new_owner?(line, index)
+              trim_groups(current_level)
+              new_group
+            end
+            ensure_groups_structure
+          when Codeowners::Checker::Group::UnrecognizedLine
+            ensure_groups_structure
+          else
+            raise "Do not know how to handle line: #{line.inspect}"
+          end
+          current_group.add(line)
+        end
+        group_buffer.first
+      end
+
+      private
+
+      attr_reader :group_buffer, :lines
+
+      def previous_line_empty?(index)
+        index.positive? && lines[index - 1].is_a?(Codeowners::Checker::Group::Empty)
+      end
+
+      def new_owner?(line, index)
+        if previous_line_empty?(index)
+          offset = 2
+          while (index - offset).positive?
+            case lines[index - offset]
+            when Codeowners::Checker::Group::GroupEndComment
+              nil
+            when Codeowners::Checker::Group::Comment
+              return false
+            when Codeowners::Checker::Group::Pattern
+              return line.owner != lines[index - offset].owner
+            end
+            offset += 1
+          end
+        end
+        false
+      end
+
+      def current_group
+        group_buffer.last
+      end
+
+      def current_level
+        group_buffer.length - 1
+      end
+
+      def new_group
+        group = current_group.create_subgroup
+        group_buffer << group
+      end
+
+      def ensure_groups_structure
+        new_group if current_level.zero?
+      end
+
+      def create_groups_structure(level)
+        new_group while current_level < level
+      end
+
+      def trim_groups(level)
+        group_buffer.slice!(level..-1)
+      end
+
+      def trim_subgroups(level)
+        trim_groups(level + 1)
+      end
+    end
+  end
+end

data/lib/codeowners/checker/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Codeowners
+  class Checker
+    VERSION = '1.0.0'
+  end
+end

data/lib/codeowners/cli/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+require_relative '../config'
+
+module Codeowners
+  module Cli
+    # Base collects shared methods used by all CLI sub commands
+    # It loads and validate the default config file or output an explanation
+    # about how to configure it.
+    class Base < Thor
+      def initialize(args = [], options = {}, config = {})
+        super
+        @config ||= config[:config] || default_config
+      end
+
+      private
+
+      attr_reader :config
+
+      def default_config
+        Codeowners::Config.new
+      end
+
+      def help_stderr
+        save_stdout = $stdout
+        $stdout = $stderr
+        help
+        $stdout = save_stdout
+      end
+    end
+  end
+end

data/lib/codeowners/cli/check.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Codeowners
+  module Cli
+    class Check < Base
+    end
+  end
+end

data/lib/codeowners/cli/config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Codeowners
+  module Cli
+    # Provide options for configuring the default owner used for filtering changes.
+    class Config < Base
+      default_task :list
+
+      desc 'list', 'List the default owner configured in the config file'
+      def list
+        puts(config.to_h.map { |name, value| "#{name}: #{value.inspect}" })
+        help_stderr if config.default_owner.empty?
+      end
+
+      desc 'owner <name>', 'Configure a default owner name'
+      def owner(name)
+        config.default_owner = name
+        puts "Default owner configured to #{name}"
+      end
+    end
+  end
+end

data/lib/codeowners/cli/filter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Codeowners
+  module Cli
+    # List changed files. Provide an option to list all the changed files grouped by
+    # the owner of the file or filter them and show only the files owned by default owner.
+    class Filter < Base
+      option :from, default: 'origin/master'
+      option :to, default: 'HEAD'
+      option :verbose, default: false, type: :boolean, aliases: '-v'
+      desc 'by <owner>', <<~DESC
+        Lists changed files owned by owner.
+        If no owner is specified, default owner is taken from the config file.
+      DESC
+      # option :local, default: false, type: :boolean, aliases: '-l'
+      # option :branch, default: '', aliases: '-b'
+      def by(owner = config.default_owner)
+        return if owner.empty?
+
+        changes = checker.changes_with_ownership(owner)
+        if changes.key?(owner)
+          changes.values.each { |file| puts file }
+        else
+          puts "Owner #{owner} not defined in .github/CODEOWNERS"
+        end
+      end
+
+      option :from, default: 'origin/master'
+      option :to, default: 'HEAD'
+      option :verbose, default: false, type: :boolean, aliases: '-v'
+      desc 'all', 'Lists all changed files grouped by owner'
+      def all
+        changes = checker.changes_with_ownership.select { |_owner, val| val && !val.empty? }
+        changes.keys.each do |owner|
+          puts(owner + ":\n  " + changes[owner].join("\n  ") + "\n\n")
+        end
+      end
+
+      def initialize(args = [], options = {}, config = {})
+        super
+        @repo_base_path = `git rev-parse --show-toplevel`
+        if !@repo_base_path || @repo_base_path.empty?
+          raise 'You must be positioned in a git repository to use this tool'
+        end
+
+        @repo_base_path.chomp!
+        Dir.chdir(@repo_base_path)
+
+        @checker ||= config[:checker] || default_checker
+      end
+
+      default_task :by
+
+      private
+
+      attr_reader :checker
+
+      def default_checker
+        Codeowners::Checker.new(@repo_base_path, options[:from], options[:to])
+      end
+    end
+  end
+end