cleo_codeowners 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c63f568dd1ca8df56852f25c7df28cb462e7684f3681d7b2921905344947a4f0
-  data.tar.gz: 4e6d293428da814ff5ab29f73a9095a1b4cb3bd8d37a856229b2829012be8462
+  metadata.gz: 95dabb73fd9d44328c2c7baed5ffbf4f91996ef2bad026d2f79175b98ba252f9
+  data.tar.gz: 4a65dca6d6efef99d01587612451b72293283a30aa0a99f3ada7f192b05added
 SHA512:
-  metadata.gz: 6dff31a87fd703933fdcdb92da9428c4908f735b9d3d48a3b5bf06c86fd7ab0e73ebc2728bb009e9e784975a889056393620cb964fb087c78a08ffcd0066f157
-  data.tar.gz: e1c87696a2ec2984d09152fac3cf5d54897ff59b8cee684a16e19f9e137e21f6f4a989da49add28a8d4381328c138b61ca6844a443b8bbc3e91dd6f814870e05
+  metadata.gz: 55b1e75f9bfbf6affb08442adb631c5fb96ab8a7ac3a1a31a433fc44235f5875964a98d4d77038965cd7c20db7cf022c5a8989db3c7a1acdfe80f32a864c792a
+  data.tar.gz: c69046a48d695beb1129a005fff5b87163b0cd4935fbb625017a123b1bc2f1ed291ee02d833cf6a2ee4ef0448d14a388a2f5324547cb7fb5fe79bfbe680b3f98

data/lib/cleo_codeowners/version.rb

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

data/lib/codeowners/generator.rb

@@ -1,6 +1,8 @@
 # typed: false
 # frozen_string_literal: true
 
+require 'pathname'
+
 module Codeowners
   class Generator
     DEFAULT_OUTPUT_PATH = '.github/CODEOWNERS'
@@ -105,32 +107,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

data/lib/codeowners/glob.rb

@@ -25,21 +25,24 @@ module Codeowners
     # Does this glob match the given filepath?
     # @param [String] filepath to match against
     # @note
+    #   Use `FNM_PATHNAME` so a single `*` stays within one path segment.
+    #   Use `FNM_DOTMATCH` so `*` still matches dotfiles/dot-dirs e.g.
+    #   `.github`, as GitHub does.
     #   Don't use `FNM_CASEFOLD`, GitHub uses a case sensitive file system.
     #   Don't use `FNM_EXTGLOB`, GitHub CODEOWNERS files don't support it.
-    #   Don't use `FNM_PATHNAME`, we want to match `*` against '/'.
     #
     # @see https://docs.ruby-lang.org/en/3.3/File.html#method-c-fnmatch
     # @return [Boolean]
     def match?(filepath)
-      fnmatch(pattern, filepath, File::FNM_DOTMATCH)
+      # Bitwise OR is how we combine flags.
+      fnmatch(pattern, filepath, File::FNM_PATHNAME | File::FNM_DOTMATCH)
     end
 
     private
 
     def normalize_string(string)
       string.to_s.delete_prefix('/') # remove leading slashes
-            .gsub(%r{/\Z}, '/**') # replace trailing slash with a recursive wildcard
+            .gsub(%r{/\Z}, '/**/*') # replace trailing slash with a recursive wildcard
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cleo_codeowners
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - "@agentAngelope"
@@ -97,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Cleo CODEOWNERS tooling
 test_files: []