cleo_codeowners 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ab9ff74ae21e83712d2331afa49e4a58fb361afb592489c608662d190adfaac
-  data.tar.gz: af9b4ec93a30218aef50319329d3594ca97cff39c4b203282abf7ab763ed968b
+  metadata.gz: 3da6d91b323d359c5906252cef6cf83727342be78baca1dcf576f5d43ac01be7
+  data.tar.gz: d4092679171b3762a76ac338546cf31c02a0b158fb50eecb7d1c8d818ef9b239
 SHA512:
-  metadata.gz: bcf8aebdba6312e71130c7ddcd9cf66f39c6e90c7b63d66fb57dd59d0410391938a676e895f9f82245543acfec10fa44acc4db30b49cdc794619c7bfa4cb0ee6
-  data.tar.gz: 87892f76e750c5ebbbead2dabf13ac1727e6c6fc1104e5ea237b06f4c22e05fb0038f6bbfe66bb73b1ae1a22384c2a756e162927f6fd114f9d405cd678f13601
+  metadata.gz: 2c847488207f368367a95244a5cd025449961b1df3f8454658144898d552761463bf5d97c07018c1813ccb89e088a1360fa7d9c3614ac9368aa5aa3decedcf93
+  data.tar.gz: e2b9f252b9054559deb915e2f68ed6d526b4953438d5457ae6249cdd189daae688cc329ac3c37b8b52994efc81bffb06a889239f99b94e2981c0310847f556cf

data/README.md

@@ -60,27 +60,35 @@ Create YAML files under `.cleo/codeowners/`.
 # .cleo/codeowners/features.yml
 features:
   session management:
+    session administration:
     session expiry:
   billing:
 ```
 
+Child features inherit their parent's owners, or can override with their own.
+An owner can be one or more teams.
+
 ```yaml
 # .cleo/codeowners/owners.yml
 owners:
+  session administration:
+    - operations
   session management: identity-platform
-  billing: payments
+  billing:
+    - payments
+    - finance
 ```
 
-Child features inherit their parent owner unless they define one.
-
 ```yaml
 # .cleo/codeowners/files/session_management.yml
 files:
+  session administration:
+    - /app/controllers/admin/sessions/
+  session expiry:
+    - /app/services/session_expiry/
   session management:
     - /app/controllers/sessions/
     - /app/models/session.rb
-  session expiry:
-    - /app/services/session_expiry/
 
 # .cleo/codeowners/files/billing.yml
 files:

data/lib/cleo_codeowners/version.rb

@@ -3,5 +3,5 @@
 ##
 # Root module for this gem
 module CleoCodeowners
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

data/lib/codeowners/generator.rb

@@ -1,6 +1,9 @@
 # typed: false
 # frozen_string_literal: true
 
+require 'active_support/core_ext/array/conversions'
+require 'pathname'
+
 module Codeowners
   class Generator
     DEFAULT_OUTPUT_PATH = '.github/CODEOWNERS'
@@ -57,15 +60,18 @@ module Codeowners
       @files ||= definitions_file.file_config
     end
 
-    def calculate_owners_and_output_in_human_format(features:, current_owner: nil, depth: 0)
+    def calculate_owners_and_output_in_human_format(features:, current_owners: [], depth: 0)
       return unless present?(features)
 
       features.sort_by(&:first).each do |feature, children|
         output(feature.upcase, depth:)
-        owner = owners.fetch(feature, current_owner)
+        feature_owners = Array(
+          owners.fetch(feature, current_owners)
+        ).reject { |owner| blank?(owner) }
+
         feature_files = files[feature]
 
-        if blank?(owner)
+        if feature_owners.empty?
           raise "Please assign an owner for #{feature} in owners.yaml!"
         elsif blank?(feature_files) && blank?(children)
           raise "Please assign files or child features to #{feature}, or remove it!"
@@ -73,20 +79,22 @@ module Codeowners
           all_features << feature
         end
 
-        if owner == 'unowned'
+        long_names = feature_owners.map { |owner| Owner.new(owner).long_name }.uniq
+
+        if feature_owners == ['unowned']
           output('Currently unowned', depth:)
         else
-          output("Currently owned by @meetcleo/#{owner}", depth:)
+          output("Currently owned by #{long_names.to_sentence}", depth:)
         end
 
         if present?(feature_files)
           feature_files.sort.uniq.each do |file|
-            record_calculated_owner(file, Owner.new(owner).long_name)
-            output("#{file} #{Owner.new(owner).long_name}", depth:, comment: false)
+            long_names.each { |long_name| record_calculated_owner(file, long_name) }
+            output("#{file} #{long_names.join(' ')}", depth:, comment: false)
           end
         end
 
-        calculate_owners_and_output_in_human_format(features: children, current_owner: owner, depth: depth + 1)
+        calculate_owners_and_output_in_human_format(features: children, current_owners: feature_owners, depth: depth + 1)
       end
     end
 
@@ -105,32 +113,40 @@ module Codeowners
       calculated_owners.push({ path:, owner: })
     end
 
+    # GitHub applies the *last* matching CODEOWNERS rule, so rules are listed
+    # least-specific first: by number of path segments (`/app/` is broader than
+    # `/app/models/user.rb`), then by path so a wildcard such as `/foo/*` sorts
+    # ahead of the `/foo/bar/` it would otherwise shadow.
     def output_in_machine_format
-      file_rules, folder_rules = calculated_owners.partition { |owner| owner[:path].include?('.') }
-      group_by_path_segments_and_output(folder_rules)
-      group_by_path_segments_and_output(file_rules)
+      merge_owners_by_path(calculated_owners)
+        .sort_by { |path, _owners| [path_depth(path), path] }
+        .each { |path, rule_owners| output_file << "#{path} #{rule_owners.join(' ')}\n" }
     end
 
-    def group_by_path_segments_and_output(rules)
-      grouped_by_path_segments_number = rules
-                                        .group_by { |owner| sanitised_path(owner[:path]).split('/').reject(&:empty?).size }
-                                        .each_value do |rule|
-        rule.sort_by! do |owner|
-          owner[:path]
-        end
+    # Combines the owners of rules that share a path onto one line.
+    def merge_owners_by_path(rules)
+      rules_by_path = rules.group_by { |owner| sanitised_path(owner[:path]) }
+      reject_trailing_slash_conflicts(rules_by_path.keys)
+      rules_by_path.map do |path, owners_for_path|
+        [path, owners_for_path.map { |owner| owner[:owner] }.uniq.sort]
       end
-                                                                                                                                        .sort
-                                                                                                                                        .to_h
-
-      grouped_by_path_segments_number
-        .each_value
-        .map { |files_and_owners| files_and_owners.group_by { |owner| owner[:path] } }
-        .each do |files_and_owners|
-          files_and_owners.each do |file, owners_list|
-            rule_owners = owners_list.map { |owner| owner[:owner] }.uniq.sort
-            output_file << "#{sanitised_path(file)} #{rule_owners.join(' ')}\n"
-          end
-        end
+    end
+
+    # A path written both with and without a trailing slash is rejected rather
+    # than guessed at: `/foo` and `/foo/` are effectively same rule, but on disk
+    # they differ (a directory needs its slash to match recursively, a file must
+    # not have one), so the definitions must pick one.
+    def reject_trailing_slash_conflicts(paths)
+      paths.group_by { |path| path.chomp('/') }.each_value do |variants|
+        next if variants.uniq.size == 1
+
+        raise "#{variants.min} is declared both with and without a trailing slash " \
+              "(#{variants.uniq.sort.join(', ')}); pick one so it is clear whether it is a file or a directory."
+      end
+    end
+
+    def path_depth(path)
+      Pathname.new(path).each_filename.count
     end
 
     def blurb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cleo_codeowners
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - "@agentAngelope"