libcodeowners 0.0.1

data/Cargo.toml

@@ -0,0 +1,7 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/libcodeowners"]
+resolver = "2"

data/README.md

@@ -0,0 +1,27 @@
+# Libcodeowners
+
+A thin Ruby wrapper around [codeowners-rs](https://github.com/rubyatscale/codeowners-rs)
+
+## Why?
+
+The [codeowners-rs](https://github.com/rubyatscale/codeowners-rs) CLI is a fast alternative to the Ruby gem [code_ownership](https://github.com/rubyatscale/code_ownership). However, since codeowners-rs is written in Rust, it can't provide direct Ruby APIs.
+
+**libcodeowners** provides Ruby APIs that delegate to codeowners-rs. Much of this code was lifted from [code_ownership](https://github.com/rubyatscale/code_ownership).
+
+## Installation
+
+```bash
+gem install libcodeowners
+```
+
+## Usage
+
+```ruby
+require 'libcodeowners'
+
+team = Libcodeowners.for_file('path/to/file.rb')
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubyatscale/libcodeowners.

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rb_sys/extensiontask'
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load('libcodeowners.gemspec')
+
+RbSys::ExtensionTask.new('libcodeowners', GEMSPEC) do |ext|
+  ext.lib_dir = 'lib/libcodeowners'
+  ext.cross_compile = true
+end
+
+task default: %i[compile spec]

data/ext/libcodeowners/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "libcodeowners"
+version = "0.1.0"
+edition = "2024"
+authors = ["Perry Hertler <perry.hertler@gusto.com>"]
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.7.1" }
+serde = { version = "1.0.218", features = ["derive"] }
+serde_magnus = "0.9.0"
+codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", tag = "v0.2.4" }

data/ext/libcodeowners/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('libcodeowners/libcodeowners')

data/ext/libcodeowners/src/lib.rs

@@ -0,0 +1,76 @@
+use std::{env, path::PathBuf};
+
+use codeowners::runner::{self, RunConfig};
+use magnus::{Error, Ruby, Value, function, prelude::*};
+use serde::{Deserialize, Serialize};
+use serde_magnus::serialize;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Team {
+    pub team_name: String,
+    pub team_config_yml: String,
+}
+
+fn for_file(file_path: String) -> Result<Option<Value>, Error> {
+    let run_config = build_run_config();
+
+    match runner::team_for_file_from_codeowners(&run_config, &file_path) {
+        Ok(Some(team_rs)) => {
+            let team = Team {
+                team_name: team_rs.name,
+                team_config_yml: team_rs.path.to_string_lossy().to_string(),
+            };
+            let serialized: Value = serialize(&team)?;
+            Ok(Some(serialized))
+        }
+        Ok(None) => Ok(None),
+        Err(e) => Err(Error::new(
+            magnus::exception::runtime_error(),
+            e.to_string(),
+        )),
+    }
+}
+
+fn generate_and_validate() -> Result<Value, Error> {
+    let run_config = build_run_config();
+    let run_result = runner::generate_and_validate(&run_config, vec![]);
+    if run_result.validation_errors.len() > 0 {
+        Err(Error::new(
+            magnus::exception::runtime_error(),
+            run_result.validation_errors.join("\n"),
+        ))
+    } else if run_result.io_errors.len() > 0 {
+        Err(Error::new(
+            magnus::exception::runtime_error(),
+            run_result.io_errors.join("\n"),
+        ))
+    } else {
+        let serialized: Value = serialize(&run_result.info_messages)?;
+        Ok(serialized)
+    }
+}
+
+fn build_run_config() -> RunConfig {
+    let project_root = match env::current_dir() {
+        Ok(path) => path,
+        _ => PathBuf::from("."),
+    };
+    let codeowners_file_path = project_root.join(".github/CODEOWNERS");
+    let config_path = project_root.join("config/code_ownership.yml");
+
+    RunConfig {
+        project_root,
+        codeowners_file_path,
+        config_path,
+        no_cache: false,
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("RustCodeOwners")?;
+    module.define_singleton_method("for_file", function!(for_file, 1))?;
+    module.define_singleton_method("generate_and_validate", function!(generate_and_validate, 0))?;
+
+    Ok(())
+}

data/ext/libcodeowners/tests/fixtures/valid_project/config/teams/bar.yml

@@ -0,0 +1,5 @@
+name: Bar
+github:
+  team: '@BarTeam'
+owned_globs:
+  - ruby/app/bar/**/*

data/ext/libcodeowners/tests/fixtures/valid_project/config/teams/foo.yml

@@ -0,0 +1,5 @@
+name: Foo
+github:
+  team: '@FooTeam'
+owned_globs:
+  - ruby/app/foo/**/*

data/lib/libcodeowners/file_path_finder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module Libcodeowners
+  module FilePathFinder
+    module_function
+
+    extend T::Sig
+    extend T::Helpers
+
+    # Returns a string version of the relative path to a Rails constant,
+    # or nil if it can't find anything
+    sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(String)) }
+    def path_from_klass(klass)
+      if klass
+        path = Object.const_source_location(klass.to_s)&.first
+        (path && Pathname.new(path).relative_path_from(Pathname.pwd).to_s) || nil
+      else
+        nil
+      end
+    rescue NameError
+      nil
+    end
+
+    sig { params(backtrace: T.nilable(T::Array[String])).returns(T::Enumerable[String]) }
+    def from_backtrace(backtrace)
+      return [] unless backtrace
+
+      # The pattern for a backtrace hasn't changed in forever and is considered
+      # stable: https://github.com/ruby/ruby/blob/trunk/vm_backtrace.c#L303-L317
+      #
+      # This pattern matches a line like the following:
+      #
+      #   ./app/controllers/some_controller.rb:43:in `block (3 levels) in create'
+      #
+      backtrace_line = if RUBY_VERSION >= '3.4.0'
+                         %r{\A(#{Pathname.pwd}/|\./)?
+                             (?<file>.+)       # Matches 'app/controllers/some_controller.rb'
+                             :
+                             (?<line>\d+)      # Matches '43'
+                             :in\s
+                             '(?<function>.*)' # Matches "`block (3 levels) in create'"
+                           \z}x
+                       else
+                         %r{\A(#{Pathname.pwd}/|\./)?
+                             (?<file>.+)       # Matches 'app/controllers/some_controller.rb'
+                             :
+                             (?<line>\d+)      # Matches '43'
+                             :in\s
+                             `(?<function>.*)' # Matches "`block (3 levels) in create'"
+                           \z}x
+                       end
+
+      backtrace.lazy.filter_map do |line|
+        match = line.match(backtrace_line)
+        next unless match
+
+        T.must(match[:file])
+      end
+    end
+  end
+end

data/lib/libcodeowners/file_path_team_cache.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module Libcodeowners
+  module FilePathTeamCache
+    module_function
+
+    extend T::Sig
+    extend T::Helpers
+
+    sig { params(file_path: String).returns(T.nilable(CodeTeams::Team)) }
+    def get(file_path)
+      cache[file_path]
+    end
+
+    sig { params(file_path: String, team: T.nilable(CodeTeams::Team)).void }
+    def set(file_path, team)
+      cache[file_path] = team
+    end
+
+    sig { params(file_path: String).returns(T::Boolean) }
+    def cached?(file_path)
+      cache.key?(file_path)
+    end
+
+    sig { void }
+    def bust_cache!
+      @cache = nil
+    end
+
+    sig { returns(T::Hash[String, T.nilable(CodeTeams::Team)]) }
+    def cache
+      @cache ||= T.let(@cache,
+      T.nilable(T::Hash[String, T.nilable(CodeTeams::Team)]))
+      @cache ||= {}
+    end
+  end
+end

data/lib/libcodeowners/team_finder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module Libcodeowners
+  module TeamFinder
+    module_function
+
+    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Kernel }
+
+    sig { params(file_path: String).returns(T.nilable(CodeTeams::Team)) }
+    def for_file(file_path)
+      return nil if file_path.start_with?('./')
+      return FilePathTeamCache.get(file_path) if FilePathTeamCache.cached?(file_path)
+
+      result = T.let(RustCodeOwners.for_file(file_path), T.nilable(T::Hash[Symbol, String]))
+      return if result.nil?
+
+      if result[:team_name].nil?
+        FilePathTeamCache.set(file_path, nil)
+      else
+        FilePathTeamCache.set(file_path, T.let(find_team!(T.must(result[:team_name])), T.nilable(CodeTeams::Team)))
+      end
+
+      FilePathTeamCache.get(file_path)
+    end
+
+    sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(::CodeTeams::Team)) }
+    def for_class(klass)
+      file_path = FilePathFinder.path_from_klass(klass)
+      return nil if file_path.nil?
+
+      for_file(file_path)
+    end
+
+    sig { params(package: Packs::Pack).returns(T.nilable(::CodeTeams::Team)) }
+    def for_package(package)
+      owner_name = package.raw_hash['owner'] || package.metadata['owner']
+      return nil if owner_name.nil?
+
+      find_team!(owner_name)
+    end
+
+    sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable(::CodeTeams::Team)) }
+    def for_backtrace(backtrace, excluded_teams: [])
+      first_owned_file_for_backtrace(backtrace, excluded_teams: excluded_teams)&.first
+    end
+
+    sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable([::CodeTeams::Team, String])) }
+    def first_owned_file_for_backtrace(backtrace, excluded_teams: [])
+      FilePathFinder.from_backtrace(backtrace).each do |file|
+        team = for_file(file)
+        if team && !excluded_teams.include?(team)
+          return [team, file]
+        end
+      end
+
+      nil
+    end
+
+    sig { params(team_name: String).returns(CodeTeams::Team) }
+    def find_team!(team_name)
+      CodeTeams.find(team_name) ||
+        raise(StandardError, "Could not find team with name: `#{team_name}`. Make sure the team is one of `#{CodeTeams.all.map(&:name).sort}`")
+    end
+
+    private_class_method(:find_team!)
+  end
+end

data/lib/libcodeowners/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Libcodeowners
+  VERSION = '0.0.1'
+end

data/lib/libcodeowners.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+require 'code_teams'
+require 'packs-specification'
+require 'sorbet-runtime'
+require_relative 'libcodeowners/file_path_team_cache'
+require_relative 'libcodeowners/team_finder'
+require_relative 'libcodeowners/version'
+require_relative 'libcodeowners/libcodeowners'
+require_relative 'libcodeowners/file_path_finder'
+module Libcodeowners
+  module_function
+
+  extend T::Sig
+  extend T::Helpers
+  requires_ancestor { Kernel }
+
+  sig { params(file_path: String).returns(T.nilable(CodeTeams::Team)) }
+  def for_file(file_path)
+    TeamFinder.for_file(file_path)
+  end
+
+  sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(::CodeTeams::Team)) }
+  def for_class(klass)
+    TeamFinder.for_class(klass)
+  end
+
+  sig { params(package: Packs::Pack).returns(T.nilable(::CodeTeams::Team)) }
+  def for_package(package)
+    TeamFinder.for_package(package)
+  end
+
+  # Given a backtrace from either `Exception#backtrace` or `caller`, find the
+  # first line that corresponds to a file with assigned ownership
+  sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable(::CodeTeams::Team)) }
+  def for_backtrace(backtrace, excluded_teams: [])
+    TeamFinder.for_backtrace(backtrace, excluded_teams: excluded_teams)
+  end
+
+  # Given a backtrace from either `Exception#backtrace` or `caller`, find the
+  # first owned file in it, useful for figuring out which file is being blamed.
+  sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable([::CodeTeams::Team, String])) }
+  def first_owned_file_for_backtrace(backtrace, excluded_teams: [])
+    TeamFinder.first_owned_file_for_backtrace(backtrace, excluded_teams: excluded_teams)
+  end
+
+  sig { void }
+  def bust_cache!
+    FilePathTeamCache.bust_cache!
+  end
+end

data/sig/libcodeowners.rbs

@@ -0,0 +1,4 @@
+module Libcodeowners
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--ignore=/spec
+--ignore=/tmp
+--ignore=/vendor/bundle
+--enable-experimental-requires-ancestor

data/sorbet/rbi/gems/code_teams@1.0.0.rbi

@@ -0,0 +1,120 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `code_teams` gem.
+# Please instead update this file by running `bin/tapioca gem code_teams`.
+
+module CodeTeams
+  class << self
+    sig { returns(T::Array[::CodeTeams::Team]) }
+    def all; end
+
+    sig { void }
+    def bust_caches!; end
+
+    sig { params(name: ::String).returns(T.nilable(::CodeTeams::Team)) }
+    def find(name); end
+
+    sig { params(dir: ::String).returns(T::Array[::CodeTeams::Team]) }
+    def for_directory(dir); end
+
+    sig { params(string: ::String).returns(::String) }
+    def tag_value_for(string); end
+
+    sig { params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
+    def validation_errors(teams); end
+  end
+end
+
+class CodeTeams::IncorrectPublicApiUsageError < ::StandardError; end
+
+class CodeTeams::Plugin
+  abstract!
+
+  sig { params(team: ::CodeTeams::Team).void }
+  def initialize(team); end
+
+  class << self
+    sig { returns(T::Array[T.class_of(CodeTeams::Plugin)]) }
+    def all_plugins; end
+
+    sig { params(team: ::CodeTeams::Team).returns(T.attached_class) }
+    def for(team); end
+
+    sig { params(base: T.untyped).void }
+    def inherited(base); end
+
+    sig { params(team: ::CodeTeams::Team, key: ::String).returns(::String) }
+    def missing_key_error_message(team, key); end
+
+    sig { params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
+    def validation_errors(teams); end
+
+    private
+
+    sig { params(team: ::CodeTeams::Team).returns(T.attached_class) }
+    def register_team(team); end
+
+    sig { returns(T::Hash[T.nilable(::String), T::Hash[::Class, ::CodeTeams::Plugin]]) }
+    def registry; end
+  end
+end
+
+module CodeTeams::Plugins; end
+
+class CodeTeams::Plugins::Identity < ::CodeTeams::Plugin
+  sig { returns(::CodeTeams::Plugins::Identity::IdentityStruct) }
+  def identity; end
+
+  class << self
+    sig { override.params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
+    def validation_errors(teams); end
+  end
+end
+
+class CodeTeams::Plugins::Identity::IdentityStruct < ::Struct
+  def name; end
+  def name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class CodeTeams::Team
+  sig { params(config_yml: T.nilable(::String), raw_hash: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(config_yml:, raw_hash:); end
+
+  sig { params(other: ::Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T.nilable(::String)) }
+  def config_yml; end
+
+  def eql?(*args, &blk); end
+
+  sig { returns(::Integer) }
+  def hash; end
+
+  sig { returns(::String) }
+  def name; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def raw_hash; end
+
+  sig { returns(::String) }
+  def to_tag; end
+
+  class << self
+    sig { params(raw_hash: T::Hash[T.untyped, T.untyped]).returns(::CodeTeams::Team) }
+    def from_hash(raw_hash); end
+
+    sig { params(config_yml: ::String).returns(::CodeTeams::Team) }
+    def from_yml(config_yml); end
+  end
+end
+
+CodeTeams::UNKNOWN_TEAM_STRING = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/packs@0.0.2.rbi

@@ -0,0 +1,80 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `packs` gem.
+# Please instead update this file by running `bin/tapioca gem packs`.
+
+module Packs
+  class << self
+    sig { returns(T::Array[::Packs::Pack]) }
+    def all; end
+
+    sig { void }
+    def bust_cache!; end
+
+    sig { returns(::Packs::Configuration) }
+    def config; end
+
+    sig { params(blk: T.proc.params(arg0: ::Packs::Configuration).void).void }
+    def configure(&blk); end
+
+    sig { params(name: ::String).returns(T.nilable(::Packs::Pack)) }
+    def find(name); end
+
+    sig { params(file_path: T.any(::Pathname, ::String)).returns(T.nilable(::Packs::Pack)) }
+    def for_file(file_path); end
+
+    private
+
+    sig { returns(T::Array[::Pathname]) }
+    def package_glob_patterns; end
+
+    sig { returns(T::Hash[::String, ::Packs::Pack]) }
+    def packs_by_name; end
+  end
+end
+
+class Packs::Configuration
+  sig { void }
+  def initialize; end
+
+  sig { returns(T::Array[::Pathname]) }
+  def roots; end
+
+  sig { params(roots: T::Array[::String]).void }
+  def roots=(roots); end
+end
+
+Packs::PACKAGE_FILE = T.let(T.unsafe(nil), String)
+
+class Packs::Pack < ::T::Struct
+  const :name, ::String
+  const :path, ::Pathname
+  const :raw_hash, T::Hash[T.untyped, T.untyped]
+  const :relative_path, ::Pathname
+
+  sig { returns(::String) }
+  def last_name; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def metadata; end
+
+  sig { returns(::Pathname) }
+  def yml; end
+
+  class << self
+    sig { params(package_yml_absolute_path: ::Pathname).returns(::Packs::Pack) }
+    def from(package_yml_absolute_path); end
+
+    def inherited(s); end
+  end
+end
+
+module Packs::Private
+  class << self
+    sig { returns(::Pathname) }
+    def root; end
+  end
+end
+
+Packs::ROOTS = T.let(T.unsafe(nil), Array)