alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
3cd7fb6321
esp-idf/.gitlab/CODEOWNERS

229 lines
13 KiB
Plaintext
Raw Normal View History

codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
# For the syntax of this file, see:
#
# https://docs.gitlab.com/ee/user/project/code_owners.html#the-syntax-of-code-owners-files
#
# If more than one rule matches a given file, the latest rule is used.
# The file should be generally kept sorted, except when it is necessary
# to use a different order due to the fact above. In that case, use
# '# sort-order-reset' comment line to reset the sort order.
#
# Recipes for a few common cases:
#
# 1. Specific directory with all its contents:
#
# /components/app_trace/
#
# Note the trailing slash!
#
# 2. File with certain extension in any subdirectory of a certain directory:
#
# /examples/**/*.py
#
# This includes an *.py files in /examples/ directory as well.
#
# 3. Contents of a directory with a certain name, anywhere in the tree:
#
# test_*_host/
#
# Will match everything under components/efuse/test_efuse_host/,
# components/heap/test_multi_heap_host/, components/lwip/test_afl_host/, etc.
#
# 4. Same as above, except limited to a specific place in the tree:
#
# /components/esp32*/
#
# Matches everything under /components/esp32, /components/esp32s2, etc.
# Doesn't match /tools/some-test/components/esp32s5.
#
# 5. Specific file:
#
# /tools/tools.json
#
# 6. File with a certain name anywhere in the tree
#
# .gitignore
#
add code owners list
2020-07-24 12:51:34 -04:00
* @esp-idf-codeowners/other
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/.* @esp-idf-codeowners/tools
gitlab: add Github workflows to ci approvals group
2022-01-07 08:20:46 -05:00
/.github/workflows/ @esp-idf-codeowners/ci
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/.gitlab-ci.yml @esp-idf-codeowners/ci
ci: Fix example Python matching, update ordering check For matches like **/*.py we need to place the wildcard last, so that it can override previous directory matches (otherwise the directory matches override the wildcard). Relax the check_codeowners.py order check to allow this.
2021-07-11 21:27:22 -04:00
/.gitlab/ci/ @esp-idf-codeowners/ci
CI: Add pre-commit for esp-idf project. add tools/ci/python_packages/idf_ci.py for some util functions used in ci and needs multi-os solution
2020-10-21 07:30:49 -04:00
/.pre-commit-config.yaml @esp-idf-codeowners/ci
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/.readthedocs.yml @esp-idf-codeowners/docs
docs(vale): Add configuration for Vale documentation linter This adds Espressif configuration (style) for Vale documentation linter. If you add or update docs, consider running Vale with this configuration on your contributions.
2023-09-25 05:35:36 -04:00
/.vale.ini @esp-idf-codeowners/docs
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/CMakeLists.txt @esp-idf-codeowners/build-config
doc: add documentation for compatibility between IDF version and chip revision
2023-05-29 13:30:35 -04:00
/COMPATIBILITY*.md @esp-idf-codeowners/peripherals
docs: make CONTRIBUTING.md readable on Github Move the contents of CONTRIBUTING.rst into contributing/index.rst, create CONTRIBUTING.md with a link to the programming guide. Closes https://github.com/espressif/esp-idf/issues/6807
2022-05-03 17:55:40 -04:00
/CONTRIBUTING.md @esp-idf-codeowners/docs
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/Kconfig @esp-idf-codeowners/build-config
codeowner: add readme rules
2022-03-01 20:16:53 -05:00
/README*.md @esp-idf-codeowners/docs
docs: udpate CN translation for readme and build-system
2022-04-12 00:12:54 -04:00
/SUPPORT_POLICY*.md @esp-idf-codeowners/docs
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/add_path.sh @esp-idf-codeowners/tools
CODEOWNER: add pytest related root dir files
2022-01-20 01:12:44 -05:00
/conftest.py @esp-idf-codeowners/ci
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/export.* @esp-idf-codeowners/tools
/install.* @esp-idf-codeowners/tools
CODEOWNER: add pytest related root dir files
2022-01-20 01:12:44 -05:00
/pytest.ini @esp-idf-codeowners/ci
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/sdkconfig.rename @esp-idf-codeowners/build-config
ci: enable clang-tidy check for more components Use internal project clang-tidy-runner Move sonarqube related configs to sonar-project.properties
2021-08-18 21:26:20 -04:00
/sonar-project.properties @esp-idf-codeowners/ci
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
# sort-order-reset
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/components/app_trace/ @esp-idf-codeowners/debugging
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/app_update/ @esp-idf-codeowners/system @esp-idf-codeowners/app-utilities
/components/bootloader*/ @esp-idf-codeowners/system @esp-idf-codeowners/security
code_owners: add peripherals to the owner of bootloader_flash
2022-01-03 22:23:31 -05:00
/components/bootloader_support/bootloader_flash/ @esp-idf-codeowners/peripherals
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/bt/ @esp-idf-codeowners/bluetooth
[mocks]: moved mocks dir to tools/
2021-08-09 23:50:15 -04:00
/components/cmock/ @esp-idf-codeowners/system
codeowners: add some subgroups for app-utils area
2022-06-24 00:43:59 -04:00
/components/console/ @esp-idf-codeowners/system @esp-idf-codeowners/app-utilities/console
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/cxx/ @esp-idf-codeowners/system
/components/driver/ @esp-idf-codeowners/peripherals
/components/efuse/ @esp-idf-codeowners/system
esp_adc: new esp_adc component and adc drivers
2022-07-15 00:52:44 -04:00
/components/esp_adc/ @esp-idf-codeowners/peripherals
app_update: Moved app metadata to new component `esp_app_format`
2022-08-02 04:54:29 -04:00
/components/esp_app_format/ @esp-idf-codeowners/system @esp-idf-codeowners/app-utilities
esp_bootloader_format: Adds bootloader description structure to read bootloader version from app Closes https://github.com/espressif/esp-idf/issues/8800 Closes https://github.com/espressif/esp-idf/issues/9132
2022-12-13 12:16:56 -05:00
/components/esp_bootloader_format/ @esp-idf-codeowners/system @esp-idf-codeowners/app-utilities
feature: separate coex lib from wifi lib, support esp32c6 internal coex update wifi, coex, phy libs
2023-02-15 22:28:51 -05:00
/components/esp_coex/ @esp-idf-codeowners/wifi @esp-idf-codeowners/bluetooth @esp-idf-codeowners/ieee802154
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esp_common/ @esp-idf-codeowners/system
refactor(pcnt): make pcnt driver as component
2023-10-15 23:41:02 -04:00
/components/esp_driver_*/ @esp-idf-codeowners/peripherals
change(codeowner): add storage to esp_driver_sdmmc
2023-11-14 04:33:08 -05:00
/components/esp_driver_sdmmc/ @esp-idf-codeowners/peripherals @esp-idf-codeowners/storage
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esp_eth/ @esp-idf-codeowners/network
/components/esp_event/ @esp-idf-codeowners/system
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/components/esp_gdbstub/ @esp-idf-codeowners/debugging
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esp_hid/ @esp-idf-codeowners/bluetooth
/components/esp_http_client/ @esp-idf-codeowners/app-utilities
/components/esp_http_server/ @esp-idf-codeowners/app-utilities
/components/esp_https_ota/ @esp-idf-codeowners/app-utilities
/components/esp_https_server/ @esp-idf-codeowners/app-utilities
codeowner: add peripherals to codeowners of esp_hw_support
2022-03-15 10:17:07 -04:00
/components/esp_hw_support/ @esp-idf-codeowners/system @esp-idf-codeowners/peripherals
lcd: add esp_lcd component * Support intel 8080 LCD panel IO on ESP32-S3 * Support RGB LCD panel on ESP32-S3 * Support SPI && I2C LCD panel IO on all esp chips
2021-05-11 23:26:07 -04:00
/components/esp_lcd/ @esp-idf-codeowners/peripherals
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esp_local_ctrl/ @esp-idf-codeowners/app-utilities
esp_mm: new virtual memory mapping apis via mmu
2022-11-02 07:11:45 -04:00
/components/esp_mm/ @esp-idf-codeowners/peripherals
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esp_netif/ @esp-idf-codeowners/network
esp-netif: Support non-lwip mode, add test It is required to define a mandatory dependency on lwip, so we introduced esp_netif_stack component and made it require lwip, instead of directly depending on lwip. This enables building w-out lwip and support other TCP/IP stacks.
2022-09-26 07:22:20 -04:00
/components/esp_netif_stack/ @esp-idf-codeowners/network
Storage: Partition APIs moved to the new component 'esp_partition' All the partition handling API functions and data-types were moved from the 'spi_flash' component to the new one named 'esp_partition'. See Storage 5.x migration guide for more details
2022-10-14 08:15:32 -04:00
/components/esp_partition/ @esp-idf-codeowners/storage
esp_phy: decouple esp_phy component from esp_wifi and bt * add esp-phy-lib submodule * move libphy.a and phy_init.c from esp_wifi to esp_phy * move librtc.a from esp_wifi to esp_phy * move libbtbb.a from bt to esp_phy * corresponding updates to build system
2021-05-24 07:39:39 -04:00
/components/esp_phy/ @esp-idf-codeowners/bluetooth @esp-idf-codeowners/wifi @esp-idf-codeowners/ieee802154
codeowners: Make system group as esp_pm codeowners
2022-12-14 11:10:16 -05:00
/components/esp_pm/ @esp-idf-codeowners/power-management @esp-idf-codeowners/bluetooth @esp-idf-codeowners/wifi @esp-idf-codeowners/system
esp_psram: new psram component
2022-05-10 22:32:56 -04:00
/components/esp_psram/ @esp-idf-codeowners/peripherals @esp-idf-codeowners/system
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esp_ringbuf/ @esp-idf-codeowners/system
add wifi bt group to rom and pm components
2021-07-06 02:09:22 -04:00
/components/esp_rom/ @esp-idf-codeowners/system @esp-idf-codeowners/bluetooth @esp-idf-codeowners/wifi
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esp_system/ @esp-idf-codeowners/system
/components/esp_timer/ @esp-idf-codeowners/system
/components/esp-tls/ @esp-idf-codeowners/app-utilities
/components/esp_wifi/ @esp-idf-codeowners/wifi
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/components/espcoredump/ @esp-idf-codeowners/debugging
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/esptool_py/ @esp-idf-codeowners/tools
/components/fatfs/ @esp-idf-codeowners/storage
support for generating FATFS on a host
2021-09-21 18:32:54 -04:00
/components/fatfs/**/*.py @esp-idf-codeowners/tools
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/freertos/ @esp-idf-codeowners/system
gitlab: add hal component to CODEOWNERS
2020-09-25 06:47:48 -04:00
/components/hal/ @esp-idf-codeowners/peripherals
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/heap/ @esp-idf-codeowners/system
Add entry for http_parser in CODEOWNERS and sonar exclusion list
2021-12-31 03:22:56 -05:00
/components/http_parser/ @esp-idf-codeowners/app-utilities
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/idf_test/ @esp-idf-codeowners/ci
ieee802154: add IEEE 802.15.4 component
2021-07-09 00:04:15 -04:00
/components/ieee802154/ @esp-idf-codeowners/ieee802154
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/json/ @esp-idf-codeowners/app-utilities
gitlab: add linux component to CODEOWNERS
2022-01-24 13:02:51 -05:00
/components/linux/ @esp-idf-codeowners/system
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/log/ @esp-idf-codeowners/system
/components/lwip/ @esp-idf-codeowners/lwip
codeowners: add some subgroups for app-utils area
2022-06-24 00:43:59 -04:00
/components/mbedtls/ @esp-idf-codeowners/app-utilities/mbedtls @esp-idf-codeowners/security
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/mqtt/ @esp-idf-codeowners/network
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/components/newlib/ @esp-idf-codeowners/system @esp-idf-codeowners/toolchain
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/nvs_flash/ @esp-idf-codeowners/storage
nvs_flash: Added helper component `nvs_sec_provider` - For processing NVS encryption-related security configuration
2023-04-05 08:34:18 -04:00
/components/nvs_sec_provider/ @esp-idf-codeowners/storage @esp-idf-codeowners/security
OpenThread: add OpenThread and porting * Adds the OpenThread submodule. * Adds porting on ESP32. * Adds the OpenThread cli example.
2021-04-02 02:49:49 -04:00
/components/openthread/ @esp-idf-codeowners/ieee802154
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/partition_table/ @esp-idf-codeowners/system
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/components/perfmon/ @esp-idf-codeowners/debugging
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/protobuf-c/ @esp-idf-codeowners/app-utilities
codeowners: add some subgroups for app-utils area
2022-06-24 00:43:59 -04:00
/components/protocomm/ @esp-idf-codeowners/app-utilities/provisioning
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/pthread/ @esp-idf-codeowners/system
gitlab: set code owners for riscv component
2021-12-22 10:58:12 -05:00
/components/riscv/ @esp-idf-codeowners/system
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/sdmmc/ @esp-idf-codeowners/storage
ci: add system group as codeowners to soc/
2021-07-13 21:52:44 -04:00
/components/soc/ @esp-idf-codeowners/peripherals @esp-idf-codeowners/system
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/spi_flash/ @esp-idf-codeowners/peripherals
/components/spiffs/ @esp-idf-codeowners/storage
/components/tcp_transport/ @esp-idf-codeowners/network
codeowner: add peripherals to touch_element codeowners
2021-07-20 13:25:56 -04:00
/components/touch_element/ @esp-idf-codeowners/peripherals
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/ulp/ @esp-idf-codeowners/system
/components/unity/ @esp-idf-codeowners/ci
gitlab: add codeowner for usb component.
2021-07-08 22:40:24 -04:00
/components/usb/ @esp-idf-codeowners/peripherals/usb
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/vfs/ @esp-idf-codeowners/storage
/components/wear_levelling/ @esp-idf-codeowners/storage
codeowners: add some subgroups for app-utils area
2022-06-24 00:43:59 -04:00
/components/wifi_provisioning/ @esp-idf-codeowners/app-utilities/provisioning
ci: Update `wpa_supplicant` codeowners
2022-10-12 00:35:34 -04:00
/components/wpa_supplicant/ @esp-idf-codeowners/wifi @esp-idf-codeowners/app-utilities/mbedtls
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/components/xtensa/ @esp-idf-codeowners/system
added spaces to lines 156-167 as the asterisk at 161 was apparently causing an issue
2023-11-01 05:11:55 -04:00
/docs/ @esp-idf-codeowners/docs
/docs/en/api-guides/jtag-debugging/ @esp-idf-codeowners/debugging
/docs/**/api-reference/bluetooth/ @esp-idf-codeowners/bluetooth
/docs/**/api-reference/network/ @esp-idf-codeowners/network @esp-idf-codeowners/wifi
/docs/**/api-reference/peripherals/ @esp-idf-codeowners/peripherals
/docs/**/api-reference/peripherals/usb* @esp-idf-codeowners/peripherals @esp-idf-codeowners/peripherals/usb
/docs/**/api-reference/protocols/ @esp-idf-codeowners/network @esp-idf-codeowners/app-utilities
/docs/**/api-reference/provisioning/ @esp-idf-codeowners/app-utilities/provisioning
/docs/**/api-reference/storage/ @esp-idf-codeowners/storage
/docs/**/api-reference/system/ @esp-idf-codeowners/system
/docs/**/security/ @esp-idf-codeowners/security
/docs/**/migration-guides/ @esp-idf-codeowners/docs @esp-idf-codeowners/all-maintainers
add code owners list
2020-07-24 12:51:34 -04:00
codeowner: add readme rules
2022-03-01 20:16:53 -05:00
/examples/README.md @esp-idf-codeowners/docs @esp-idf-codeowners/ci
/examples/**/*.py @esp-idf-codeowners/ci @esp-idf-codeowners/tools
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/examples/bluetooth/ @esp-idf-codeowners/bluetooth
/examples/build_system/ @esp-idf-codeowners/build-config
codeowner: update codeowner for common components
2023-04-04 05:39:44 -04:00
/examples/common_components/ @esp-idf-codeowners/system @esp-idf-codeowners/wifi @esp-idf-codeowners/lwip @esp-idf-codeowners/network
CI: add codeowner for custom bootloader examples
2022-06-13 02:03:03 -04:00
/examples/custom_bootloader/ @esp-idf-codeowners/system
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/examples/cxx/ @esp-idf-codeowners/system
/examples/ethernet/ @esp-idf-codeowners/network
/examples/get-started/ @esp-idf-codeowners/system
/examples/mesh/ @esp-idf-codeowners/wifi
codeowner: Add owners for examples in network category New example folder `network` has been introduced in 4ac24549ad9 to hold examples related to generic networking, not specifically to ethernet nor wifi. This change however didn't assign code owners, so only IDF maintainers could approve MRs. Assigning code ownership to groups: * network * wifi
2021-09-27 05:17:30 -04:00
/examples/network/ @esp-idf-codeowners/network @esp-idf-codeowners/wifi
OpenThread: add OpenThread and porting * Adds the OpenThread submodule. * Adds porting on ESP32. * Adds the OpenThread cli example.
2021-04-02 02:49:49 -04:00
/examples/openthread/ @esp-idf-codeowners/ieee802154
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/examples/peripherals/ @esp-idf-codeowners/peripherals
usb: Codeowners for /examples/peripherals/usb/
2022-03-17 10:26:57 -04:00
/examples/peripherals/usb/ @esp-idf-codeowners/peripherals @esp-idf-codeowners/peripherals/usb
example: support legacy PHY commands in cert_test
2023-04-23 01:08:39 -04:00
/examples/phy/ @esp-idf-codeowners/bluetooth @esp-idf-codeowners/wifi @esp-idf-codeowners/ieee802154
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/examples/protocols/ @esp-idf-codeowners/network @esp-idf-codeowners/app-utilities
codeowners: add some subgroups for app-utils area
2022-06-24 00:43:59 -04:00
/examples/provisioning/ @esp-idf-codeowners/app-utilities/provisioning
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/examples/security/ @esp-idf-codeowners/security
/examples/storage/ @esp-idf-codeowners/storage
/examples/system/ @esp-idf-codeowners/system
codeowners: add some subgroups for app-utils area
2022-06-24 00:43:59 -04:00
/examples/system/ota/ @esp-idf-codeowners/app-utilities
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/examples/wifi/ @esp-idf-codeowners/wifi
Zigbee: Add light example * provide light example for acting as zigbee coordinator, router and end-device * remove unused componenent for example usage * remove unused variable * clean up unused header include for example * update the license header * update copyright * Add readme for instruction adding esp-zboss-lib component * esp-idf:update copy_right_check ignore file * CI: fix the ci check error from pipeline * sdkconfig: default set change for better user use * use Button (BOOT) as switch input * update the statemachine for debouncing * esp-zboss-lib: support lib 0.0.2 * fix warning issue from example
2021-10-20 06:45:55 -04:00
/examples/zigbee/ @esp-idf-codeowners/ieee802154
add code owners list
2020-07-24 12:51:34 -04:00
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/tools/ @esp-idf-codeowners/tools
/tools/ble/ @esp-idf-codeowners/app-utilities
/tools/catch/ @esp-idf-codeowners/ci
/tools/ci/ @esp-idf-codeowners/ci
/tools/cmake/ @esp-idf-codeowners/build-config
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/tools/cmake/toolchain-*.cmake @esp-idf-codeowners/toolchain
/tools/esp_app_trace/ @esp-idf-codeowners/debugging
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/tools/esp_prov/ @esp-idf-codeowners/app-utilities
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/tools/gdb_panic_server.py @esp-idf-codeowners/debugging
codeowners: fix directory patterns The previous version used an incorrect /dir1/dir2 pattern to match the content of dir2. The correct pattern should be /dir1/dir2/ (with the trailing slash). This commit fixes these patterns. Regarding codeowners.py: 'git ls-files' can not be used to correctly implement the logic of CODEOWNERS file patterns, since it doesn't distinguish between /path/* and /path/. The former pattern in CODEOWNERS file should only match the files inside /path/, while the latter also matches files in nested directories. Because of this, the logic for evaluating patterns is re-implemented, by converting CODEOWNERS patterns into regular expressions. Gitlab CODEOWNERS parsing code was used as a reference, in addition to the approach for converting glob patterns into regular expressions proposed in https://stackoverflow.com/a/29354254.
2020-09-12 07:30:09 -04:00
/tools/kconfig*/ @esp-idf-codeowners/build-config
/tools/ldgen/ @esp-idf-codeowners/build-config
/tools/mass_mfg/ @esp-idf-codeowners/app-utilities
[mocks]: moved mocks dir to tools/
2021-08-09 23:50:15 -04:00
/tools/mocks/ @esp-idf-codeowners/system
codeowner: add readme rules
2022-03-01 20:16:53 -05:00
/tools/test_apps/README.md @esp-idf-codeowners/docs @esp-idf-codeowners/ci
add code owners list
2020-07-24 12:51:34 -04:00
ci: Add codeowners for test_apps categories
2021-07-08 20:03:37 -04:00
## Note: owners here should be the same as the owners for the same example subdir, above
/tools/test_apps/build_system/ @esp-idf-codeowners/build-config
ci: set codeowners of linux_compatible dir to system
2023-07-07 04:51:41 -04:00
/tools/test_apps/linux_compatible/ @esp-idf-codeowners/system
ci: Add codeowners for test_apps categories
2021-07-08 20:03:37 -04:00
/tools/test_apps/protocols/ @esp-idf-codeowners/network @esp-idf-codeowners/app-utilities
/tools/test_apps/security/ @esp-idf-codeowners/security
/tools/test_apps/system/ @esp-idf-codeowners/system
ci: Fix example Python matching, update ordering check For matches like **/*.py we need to place the wildcard last, so that it can override previous directory matches (otherwise the directory matches override the wildcard). Relax the check_codeowners.py order check to allow this.
2021-07-11 21:27:22 -04:00
/tools/test_apps/**/*.py @esp-idf-codeowners/ci @esp-idf-codeowners/tools
build system: add the initial set of pytest-based build system tests
2022-08-08 20:11:57 -04:00
/tools/test_build_system/ @esp-idf-codeowners/tools @esp-idf-codeowners/build-config
change(gitlab): add toolchains and debugging code owner groups
2023-09-06 13:35:20 -04:00
/tools/tools.json @esp-idf-codeowners/tools @esp-idf-codeowners/toolchain @esp-idf-codeowners/debugging
gitlab: update codeowner for unit-test-app
2021-07-16 02:59:45 -04:00
/tools/unit-test-app/ @esp-idf-codeowners/system @esp-idf-codeowners/tools
ci: make ignore lists optional for approval
2021-09-24 00:06:10 -04:00
# sort-order-reset
CI: Set proper code owners for component test apps
2022-01-27 10:15:33 -05:00
/components/**/test_apps/**/*.py @esp-idf-codeowners/ci @esp-idf-codeowners/tools
ci: set tools ignore files codeowner to tools group
2021-10-18 03:19:32 -04:00
# ignore lists
tools: make copyright check configurable
2021-11-18 12:21:52 -05:00
/tools/ci/check_copyright_config.yaml @esp-idf-codeowners/all-maintainers
CI: Make the maintainers to be the owners of the copyright header ignore list
2021-11-01 09:08:07 -04:00
/tools/ci/check_copyright_ignore.txt @esp-idf-codeowners/all-maintainers
ci: set tools ignore files codeowner to tools group
2021-10-18 03:19:32 -04:00
/tools/ci/mypy_ignore_list.txt @esp-idf-codeowners/tools
Reference in New Issue Copy Permalink