fast_code_owners 0.0.4-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd2a151dee09ed1520cfdeac28e2ffbe2c3b9e4b115c2066f558992578396794
+  data.tar.gz: 4866ce308fb8dfed9ebeb57adfd774f9c37c287afb2615c100b573971e429010
+SHA512:
+  metadata.gz: 9c64e5ebcd91a8155585803f1aec42b069604f93d6219ea46c6bd862237e8c49500b68ac1f92fef5452c5cd1f146dd1dcdd38953b7950d9240a7d18952ce332b
+  data.tar.gz: e651373f0793129ab8a37c54f827d5b1cf0a71f0f913ef59697fdd324b3a3caac2fe18c98ee31facae74af02f5631268166e0069ad25ae446cea5aca5b128902

data/README.md

@@ -0,0 +1,41 @@
+# fast_code_owners
+
+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.
+
+**fast_code_owners** provides Ruby APIs that delegate to codeowners-rs. Much of this code was lifted from [code_ownership](https://github.com/rubyatscale/code_ownership).
+
+## Dependencies
+
+- [Rust](https://www.rust-lang.org/tools/install) must be installed and in the PATH
+
+## Installation
+
+```bash
+gem install fast_code_owners
+```
+
+## Usage
+
+```ruby
+require 'fast_code_owners'
+
+# Find the owning team for the provided file path
+team = FastCodeOwners.for_file('path/to/file.rb')
+
+# Find the owning team for the provided class
+team = FastCodeOwners.for_class(MyClass)
+
+# Find the owning team for the provided packwerk/pks package.yml
+team = FastCodeOwners.for_package('packs/foo/package.yml')
+
+# Find the owning team for the provided error backtrace
+teams = FastCodeOwners.for_backtrace(error.backtrace)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubyatscale/fast_code_owners.

data/ext/fast_code_owners/tests/fixtures/valid_project/config/code_ownership.yml

@@ -0,0 +1,10 @@
+owned_globs:
+  - "**/*.{rb,tsx}"
+ruby_package_paths:
+  - ruby/packages/**/*
+javascript_package_paths:
+  - javascript/packages/**
+team_file_glob:
+  - config/teams/**/*.yml
+vendored_gems_path: gems
+unowned_globs:

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

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

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

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

data/lib/fast_code_owners/file_path_finder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module FastCodeOwners
+  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
+      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/fast_code_owners/file_path_team_cache.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module FastCodeOwners
+  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/fast_code_owners/team_finder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module FastCodeOwners
+  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/fast_code_owners/version.rb

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

data/lib/fast_code_owners.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+require 'code_teams'
+require 'packs-specification'
+require 'sorbet-runtime'
+require_relative 'fast_code_owners/file_path_team_cache'
+require_relative 'fast_code_owners/team_finder'
+require_relative 'fast_code_owners/version'
+require_relative 'fast_code_owners/fast_code_owners'
+require_relative 'fast_code_owners/file_path_finder'
+
+module FastCodeOwners
+  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

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: fast_code_owners
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: aarch64-linux
+authors:
+- Perry Hertler
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: code_teams
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: packs-specification
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A ruby interface that determines file ownership for git repositories
+email:
+- perry.hertler@gusto.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- ext/fast_code_owners/tests/fixtures/valid_project/config/code_ownership.yml
+- ext/fast_code_owners/tests/fixtures/valid_project/config/teams/bar.yml
+- ext/fast_code_owners/tests/fixtures/valid_project/config/teams/foo.yml
+- ext/fast_code_owners/tests/fixtures/valid_project/ruby/app/bar/bar_none.rb
+- ext/fast_code_owners/tests/fixtures/valid_project/ruby/app/foo/foo_none.rb
+- lib/fast_code_owners.rb
+- lib/fast_code_owners/3.2/fast_code_owners.so
+- lib/fast_code_owners/3.4/fast_code_owners.so
+- lib/fast_code_owners/file_path_finder.rb
+- lib/fast_code_owners/file_path_team_cache.rb
+- lib/fast_code_owners/team_finder.rb
+- lib/fast_code_owners/version.rb
+homepage: https://github.com/rubyatscale/fast_code_owners
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/rubyatscale/fast_code_owners
+  source_code_uri: https://github.com/rubyatscale/fast_code_owners
+  changelog_uri: https://github.com/rubyatscale/fast_code_owners/releases
+  cargo_crate_name: fast_code_owners
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.5.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Lightning fast codeowners-rs ruby wrapper
+test_files: []