This series reduces reliance on global states. Mainly there are two such global states in editor.c,

* editor_program: defined in environment.c and populated during config
  parsing, but only used by editor.c via git_editor().

* the_repository: used in git_sequence_editor() to read the sequence.editor
  configuration.

In patch 1/2, localize editor_program to editor.c by introducing a helper that allows git_default_core_config() to continue initializing the value during initial config parsing.

In patch 2/2, remove the remaining use of the_repository in editor.c by passing struct repository through git_sequence_editor() and its callers. With this change, editor.c no longer requires 'USE_THE_REPOSITORY_VARIABLE'.

Shreyansh Paliwal (2):
  editor: make editor_program local to editor.c
  editor: remove the_repository usage

 builtin/var.c        |  2 +-
 editor.c             | 18 ++++++++++++------
 editor.h             |  6 ++++--
 environment.c        |  5 ++---
 environment.h        |  1 -
 rebase-interactive.c |  2 +-
 6 files changed, 20 insertions(+), 14 deletions(-)

-- 2.53.0

editor_program is a global variable defined in environment.c, which is set by git_default_core_config(), but is used only by editor.c in the function git_editor().

Remove the global from the environment.c and localize it in editor.c. Introduce a helper for setting the local editor_program variable by the help of git_config_string(). Call this helper in the core.editor part of the git_default_core_config().

This keeps the existing initialization timing and availability of the variable, so invalid core.editor values are still reported early during startup, causing no ux regression.

Signed-off-by: Shreyansh Paliwal <shreyanshpaliwalcmsmn@gmail.com>
---
 editor.c      | 8 ++++++++
 editor.h      | 2 ++
 environment.c | 5 ++---
 environment.h | 1 -
 4 files changed, 12 insertions(+), 4 deletions(-)

git_sequence_editor() reads sequence.editor using the_repository. Pass struct repository through the callers instead of relying on the global state. It is called from,

* builtin/var.c: Mostly the_repository is used in all the functions and
  there is no proper local access to a repository, so pass the_repository.

* editor.c: The caller is inside launch_sequence_editor() function which is
  called from rebase-interactive.c:edit_todo_list(), which does have a
  local repository instance, so pass it down the caller.

With no remaining global states in editor.c remove '#define USE_THE_REPOSITORY_VARIABLE'. This removes another dependency on the_repository and keeps editor code consistent with the ongoing effort to reduce global state.

Signed-off-by: Shreyansh Paliwal <shreyanshpaliwalcmsmn@gmail.com>
---
 builtin/var.c        |  2 +-
 editor.c             | 10 ++++------
 editor.h             |  4 ++--
 rebase-interactive.c |  2 +-
 4 files changed, 8 insertions(+), 10 deletions(-)

Hi Shreyansh,

I am a GSoC applicant like you. I just wanted to leave my two cents here.

On Sun, Mar 01, 2026 at 04:12:58PM +0530, Shreyansh Paliwal wrote:

While moving the global variable from 'environment.c' to 'editor.c' doesn't cause any behavior change, it still relies on global state.

I think passing a 'struct repository' and using the 'repo_config_get*' helpers here might be a more robust approach. I know this means we would catch config errors later (right before the editor start up). However, since it doesn't seem like it would cause a data loss or serious issues, this behavioral change feels like a reasonable trade-off.

Thanks again for the patches!

Best, Burak Kaan Karaçay

Hi Burak,

Thanks for the feedback on this, I appreciate you taking the time to look.

I did consider the approach you suggested. Currently, editor_program is only used within editor.c, and it is I believe a process-wide setting rather than something tied to a specific repository. Because of that, it did not seem necessary to add it to struct repository or repo_settings at this stage.

More importantly, my intention for this was to keep original behavior as-is. As noted in earlier discussions [1][2], maintaining early config validation is important so that invalid core.editor values are caught early. Moving to a repo-based lazy lookup would change that.

That said, I agree that there may be a better way to do this refactor, so I'd be glad to hear more thoughts on this :)

Best, Shreyansh

[1]- https://lore.kernel.org/git/1d43d1d0-bf6b-4806-834e-89f545fab766@gmail.com/ [2]- https://lore.kernel.org/git/xmqqpl63b2tm.fsf@gitster.g/

Hi Burak

On 01/03/2026 13:19, Burak Kaan Karaçay wrote:

That's true, but does it really make sense for this config setting per-repository? Why would I want to use different editors for different repositories in the same process?

Thanks

Phillip

Hi Shreyansh and Burak,

Thanks for the patch.

Reading through discussion, I think both of you highlighted very valid constraints:

Yes, changing an extern to a static variable doesn't truly remove the global state, right?

This one also makes sense to me.

However,

I have reservations about this, and I believe this is the most critical issue. For instance, we can run:

	git config --local core.editor "nvim"

where the configuration is written in the .git/config of the current repository. If core.editor is process-wide, git should not permit the existence of a "local" core.editor at all. Since it can be set for individual repositories, it should be tied to the specific struct repository, right?

A more intuitive case is:

	Repo A: core.editor = vim
	Repo B: core.editor = nvim

For users managing multiple repositories (submodules), it's perfectly reasonable to use different editors in different contexts. At least for me, I use different configurations for Vim and NVim, and I switch between different editors when writing with different languages. (like set textwidth=72 for Git? _(:3 ⌒ﾞ)_)

I recently faced the same dilemma migrating git_commit_encoding and git_log_output_encoding. I personally believe that adding editor_program to repo-settings.c is the best approach.

By doing this:

- We truly eliminate the global state. Each struct repository gets its 
own editor setting.

- We maintain early validation. The config can still be parsed early 
(e.g., during prepare_repo_settings()?)

Thanks again for the patch.

Regards,

Yuchen

On Sun, Mar 01, 2026 at 04:22:38PM +0000, Phillip Wood wrote:

In practical sense, yes, it's true. Users generally don't use different editors for different repositories. For repository dependent settings .editorconfig mostly cover all scenarios.

However, as far as I know git doesn't have a system-wide only configuration settings. These changes mostly serve to libification process of git. If we leave 'core.editor' setting as a global variable and user tries to interact with multiple repositories that have different editor configurations using our libified git, it can mix up the configs of two repositories.

If we really want to keep these variables independent from repositories, we should probably prohibit 'core.editor' setting in local repository configs. Otherwise, leaving it global seems like a weird behavioral choice.

Thanks, Burak Kaan Karaçay

Burak Kaan Karaçay <bkkaracay@gmail.com> writes:

I do agree with the point you're making, true isolation for libification would indeed require that this variable is not a global variable.

But, while libification is the destination, steps in that direction should be welcome, and I think one step is to simply localize the global variables.

Also bloating up `struct repository` without much thought might not be a good decision either.

Shreyansh Paliwal <shreyanshpaliwalcmsmn@gmail.com> writes:

Well explained, the patch looks good to me.

This series reduces reliance on global states. Mainly there are two such global states in editor.c,

* editor_program: defined in environment.c and populated during config
  parsing, but only used by editor.c via git_editor().

* the_repository: used in git_sequence_editor() to read the sequence.editor
  configuration.

In patch 1/2, localize editor_program to editor.c by introducing a helper that allows git_default_core_config() to continue initializing the value during initial config parsing.

In patch 2/2, remove the remaining use of the_repository in editor.c by passing struct repository through git_sequence_editor() and its callers. With this change, editor.c no longer requires 'USE_THE_REPOSITORY_VARIABLE' and 'environment.h' include.

Shreyansh Paliwal (2):
  editor: make editor_program local to editor.c
  editor: remove the_repository usage

 builtin/var.c        |  2 +-
 editor.c             | 19 ++++++++++++-------
 editor.h             |  6 ++++--
 environment.c        |  5 ++---
 environment.h        |  1 -
 rebase-interactive.c |  2 +-
 6 files changed, 20 insertions(+), 15 deletions(-)

---
Changes in v2:
 - removed 'environment.h' dependency from editor.c as well.

Range-diff against v1:
-:  ---------- > 1:  6f8b82fed5 editor: make editor_program local to editor.c
1:  f9ef18b77a ! 2:  5b858c7e98 editor: remove the_repository usage
    @@ Commit message
           local repository instance, so pass it down the caller.

         With no remaining global states in editor.c remove '#define
    -    USE_THE_REPOSITORY_VARIABLE'. This removes another dependency on
    -    the_repository and keeps editor code consistent with the ongoing effort to
    -    reduce global state.
    +    USE_THE_REPOSITORY_VARIABLE' and drop the dependency on 'environment.h'.
    +    This removes another dependency on the_repository and keeps editor code
    +    consistent with the ongoing effort to reduce global state.

         Signed-off-by: Shreyansh Paliwal <shreyanshpaliwalcmsmn@gmail.com>

    @@ editor.c
      #include "git-compat-util.h"
      #include "abspath.h"
      #include "advice.h"
    + #include "config.h"
    + #include "editor.h"
    +-#include "environment.h"
    + #include "gettext.h"
    + #include "pager.h"
    + #include "path.h"
     @@ editor.c: const char *git_editor(void)
      	return editor;
      }
--
2.53.0

editor_program is a global variable defined in environment.c, which is set by git_default_core_config(), but is used only by editor.c only in the function git_editor().

Remove the global from the environment.c and localize it in editor.c. Introduce a helper for setting the local editor_program variable by the help of git_config_string(). Call this helper in the core.editor part of the git_default_core_config().

This keeps the existing initialization timing and availability of the variable, so invalid core.editor values are still reported early during startup, causing no ux regression.

Signed-off-by: Shreyansh Paliwal <shreyanshpaliwalcmsmn@gmail.com>
---
 editor.c      | 8 ++++++++
 editor.h      | 2 ++
 environment.c | 5 ++---
 environment.h | 1 -
 4 files changed, 12 insertions(+), 4 deletions(-)

git_sequence_editor() reads sequence.editor using the_repository. Pass struct repository through the callers instead of relying on the global state. It is called from,

- builtin/var.c: Mostly the_repository is used in all the functions and
  there is no proper local access to a repository, so pass the_repository.

- editor.c: The caller is inside launch_sequence_editor() function which is
  called from rebase-interactive.c:edit_todo_list(), which does have a
  local repository instance, so pass it down the caller.

With no remaining global states in editor.c remove '#define USE_THE_REPOSITORY_VARIABLE' and drop the dependency on 'environment.h'. This removes another dependency on the_repository and keeps editor code consistent with the ongoing effort to reduce global state.

Signed-off-by: Shreyansh Paliwal <shreyanshpaliwalcmsmn@gmail.com>
---
 builtin/var.c        |  2 +-
 editor.c             | 11 ++++-------
 editor.h             |  4 ++--
 rebase-interactive.c |  2 +-
 4 files changed, 8 insertions(+), 11 deletions(-)

Hi,

Sorry for the late follow-up, I was tied up with my college exams. I just wanted to check if there is any specific feedback or concern that is holding this series back. Do let me know :)

Best, Shreyansh