Feature Request Add A Silent Option To CMakeRun For Cleaner Output

Hey guys! Today, we're diving into a feature request that aims to streamline the output of the :CMakeRun command in the cmake-tools.nvim plugin. As it stands, the current behavior can be a bit verbose, cluttering the terminal with unnecessary information. Let's break down the issue, explore the desired behavior, and propose a solution that could make our lives as developers a whole lot easier.

Current Behavior: The Verbose Output Problem

Currently, when you fire up the :CMakeRun command, the terminal doesn't just display your program's output. Oh no, it goes the extra mile by showing the entire shell command wrapper used for execution. While this might be helpful for debugging in some very specific scenarios, most of the time, it's just noise. This verbosity makes it harder to immediately spot your program's actual results. Think of it like trying to find a specific grain of sand on a beach – not the most efficient use of your time, right?

To illustrate, here’s an example of what the output looks like right now:

user@hostname:/path-to-project$ cd /path-to-project-out-Debug/ && ./my_program; echo $? > /path-to-nvim/temp/exit_code && \rm -f /path-to-nvim/temp/.lock
Program output

See all that extra stuff before "Program output"? That's the shell command wrapper in action. It’s useful information sometimes, but it often obscures the real star of the show: your program's output. The core issue here is that this extra information can make it challenging to quickly identify whether your program ran successfully and produced the expected results. As developers, we crave efficiency, and having to sift through irrelevant details just slows us down. We need a way to cut through the noise and get straight to the point.

This verbose output can become particularly frustrating when you're running tests or debugging frequently. Each time you execute the command, you're faced with the same wall of text, pushing your actual output further down the terminal. This not only wastes time but can also lead to overlooking important information. Imagine running a suite of tests and having to manually scroll through pages of command wrappers to find the results of each test – tedious, to say the least.

Furthermore, this behavior can be especially problematic in environments with limited screen real estate, such as when working in a split terminal or on a smaller display. The extra lines of output can quickly fill the available space, making it even harder to focus on the program's output. We need a solution that respects our time and our screen space, giving us the information we need without the unnecessary clutter. Let's face it; a cleaner output is a happier output, and a happier output translates to a happier developer. By reducing the noise, we can improve our focus and be more productive.

Desired Behavior: A Silent Mode for Clarity

Now, let's talk about the dream scenario: a world where :CMakeRun behaves like a well-mannered program, only speaking when spoken to (or, in this case, only displaying the essential information). The desired behavior is an option to run the target in a "silent" mode. In this mode, only the stdout and stderr from your program would be visible, nothing more, nothing less. This would create a much cleaner and more focused experience, allowing you to immediately see the results of your program without any distractions.

Imagine the bliss of seeing this in your terminal:

Program Output

Ah, pure, unadulterated program output! No shell command wrappers, no extraneous details, just the information you need, right when you need it. This is the essence of a silent mode – providing clarity and efficiency. With this streamlined output, you can quickly assess the outcome of your program, identify any issues, and move on to the next task. It's all about reducing cognitive load and maximizing productivity.

This silent mode would be especially beneficial when running automated tests. You could easily scan the output for any errors or failures without having to wade through a sea of shell commands. This would save you time and effort, allowing you to focus on the important stuff: fixing bugs and improving your code. Think of it as having a personal assistant who filters out all the noise and only presents you with the critical information – pretty awesome, right?

Moreover, a silent mode would also be a welcome addition for presentations and demos. When showcasing your program to others, you want to keep the focus on the application itself, not the underlying execution details. A clean, concise output helps maintain the audience's attention and ensures that the message gets across without any distractions. It's all about putting your best foot forward and presenting your work in the most professional manner possible. A silent mode for :CMakeRun would be a significant step in that direction.

Proposed Solution: Enhanced Flexibility with Options

So, how do we make this silent mode a reality? The proposed solution involves adding more options to the opts table in the require('cmake-tools').run() function. This would make the function more flexible and allow users to customize the behavior of :CMakeRun to suit their needs. Think of it as adding extra dials and switches to your control panel, giving you more fine-grained control over the execution process.

Here’s an example of how this could be implemented in Lua:

require('cmake-tools').run({
  -- Solves the verbosity issue described above
  silent = true,

  -- A callback for custom logic before launching the target
  before_run = function()
    -- Example: save all files before running
    vim.cmd('wa') 
  end
})

In this example, we've added a silent option that, when set to true, would enable the silent mode, suppressing the shell command wrapper and only displaying the program's output. This simple addition would address the verbosity issue directly and provide a much cleaner experience. But that's not all; we've also included a before_run option, which is a callback function that allows you to execute custom logic before launching the target. This opens up a world of possibilities for automating tasks and customizing your workflow.

For instance, the example shows how you could use the before_run callback to save all files before running the target. This is a common scenario, especially when you're working on a large project with multiple files. By automatically saving all your changes before each run, you can ensure that you're always testing the latest version of your code, reducing the risk of encountering unexpected errors. This is just one example of how the before_run callback can be used to streamline your development process and make your life easier.

This approach not only solves the immediate verbosity issue but also lays the groundwork for future enhancements. By making the run() function more flexible, we can add new options and callbacks to support a wide range of use cases. This would empower users to tailor the behavior of :CMakeRun to their specific needs and preferences, creating a truly personalized development experience. Imagine being able to define custom commands that automatically build, run, and test your code with a single keystroke – that's the kind of power we're talking about here.

Ultimately, this increased flexibility could be exposed to users through new, configurable commands. This means you could define your own commands with specific options and callbacks, allowing you to create shortcuts for your most common tasks. For example, you could create a command that runs your program in silent mode with a specific set of arguments, or a command that automatically runs your tests and displays the results in a separate window. The possibilities are endless, and the potential for increased productivity is significant. By giving users more control over the execution process, we can empower them to work more efficiently and effectively, which is what it's all about, right?

In conclusion, adding a silent option to :CMakeRun is a small change that could have a big impact on the developer experience. By reducing verbosity and providing greater flexibility, we can make it easier to focus on the task at hand and get our work done more efficiently. So, let's hope this feature request gets some traction and makes its way into a future release of cmake-tools.nvim! It's a win-win for everyone involved.