Focus a dir when opening lf

[yushisora]

When passing a path to lf, lf will focus it if it is a file or start in there if it is a dir. But I wonder if there is a method to focus that dir instead of starting in there?

[CatsDeservePets]

To be honest, I did not find an easy way to do this.
Theoretically, this is pretty straight forward. You just need to execute the "select" command with the directory in question as the parameter. However, due to how lf currently functions, executing lf -command "select <path>" doesn't work, as the commands get executed before the UI is initialised.

One way to make this possible is to introduce a new command for executing a command after lf has been initialised, not before. This is something Vim does as well:

 +command, -c command
			 Execute command after reading the first file.  Up to
			 10 instances allowed.  "+foo" and -c "foo" are
			 equivalent.

 --cmd command
			 Like -c, but execute command before processing any
			 vimrc.  Up to 10 instances of these can be used
			 independently from instances of -c.

@joelim-work What are your thoughts on this? Personally, I think this would be rather useful and could solve lots of problems/limitations of the current -command flag. The implementation is pretty straight forward:

diff --git a/app.go b/app.go
index 937a87e..b696138 100644
--- a/app.go
+++ b/app.go
@@ -318,6 +318,18 @@ func (app *app) loop() {
 		}()
 	}
 
+	for _, cmd := range gPostCommands {
+		p := newParser(strings.NewReader(cmd))
+
+		for p.parse() {
+			p.expr.eval(app, nil)
+		}
+
+		if p.err != nil {
+			app.ui.echoerrf("%s", p.err)
+		}
+	}
+
 	for {
 		select {
 		case <-app.quitChan:
diff --git a/main.go b/main.go
index 00901e2..0de986a 100644
--- a/main.go
+++ b/main.go
@@ -41,6 +41,7 @@ var (
 	gSelect         string
 	gConfigPath     string
 	gCommands       arrayFlag
+	gPostCommands   arrayFlag
 	gVersion        string
 )
 
@@ -305,6 +306,10 @@ func main() {
 		"command",
 		"`command` to execute on client initialization")
 
+	flag.Var(&gPostCommands,
+		"c",
+		"`command` to execute after client initialization")
+
 	flag.StringVar(&gLogPath,
 		"log",
 		"",

[joelim-work]

If you pass in a directory (e.g. lf /path/to/dir) then it will cd to it, not select it:

lf/app.go

Lines 313 to 316 in 8727838

	} else if lstat.IsDir() {
	app.ui.exprChan <- &callExpr{"cd", []string{gSelect}, 1}
	} else {
	app.ui.exprChan <- &callExpr{"select", []string{gSelect}, 1}

This behavior is consistent with other file managers such as ranger/joshuto/yazi, CMIIW.

Now I understand that this doesn't cover the requirement of selecting a directory. I think this should be handled by something like lf -command 'select /path/to/dir', however it currently doesn't work - there was an issue #939 about this but it was closed.

It seems like the issue has to do with the order of initialization, and there is a race condition between initialization commands (e.g. from the config file or the -command flag) and loading the directory tree. This was somewhat addressed in 089e6dc, which applies lf <path> after the directory tree is loaded, but unfortunately does not work with lf -command 'select <path>' since that is applied before the directory tree is loaded.

Rather than introduce a new flag for post-commands, I think it would be better if #939 was reopened and addressed properly. Otherwise the result is that users will be confused as to why lf -c 'select <path>' works but lf -command 'select <path>' doesn't. Even if there is no guarantee about the order of initialization commands vs. the loading of the directory tree, maybe it is possible to implement things in such a way that they have the same result:

• If select is processed first, then lf will change to that directory and load it.
• If the directory tree is loaded first, then lf will process the select command afterwards, changing to that directory and loading it.

As a side note, I recently caused a bug #2302 because I forgot a nav.init check, and I think this kind of state flag isn't a good solution since it is easy to forget. Instead any attempt to fetch a directory that hasn't been loaded yet should return a dummy entry while creating a goroutine to load it in the background. However that will involve significant changes to the code and possibly introduce a period of instability, but I still think it is worth it though.

[joelim-work]

OK I ended up with #2313. Incidentally lf <path> and lf -command 'select <path>' both work now.