Is it just me or does the macro feature of sublime text really stink?
It does not even capture things like find next or add caret to selectionâŚ
Pretty much every worthwhile macro task involves and find of some sortâŚ
Is it just me or does the macro feature of sublime text really stink?
It does not even capture things like find next or add caret to selectionâŚ
Pretty much every worthwhile macro task involves and find of some sortâŚ
I realize that the macro donât record commands! So unless you are just recording actual simple text manipulation, macro doesnât work. I find this to be a massive short coming of sublime.
Compared to what you can do with Vim macros, sublime is macros are basically useless.
You can always write a pluginâŚ
Itâs in python, itâs easy, and you can do much more stuff than in a macro
Matt
You can even write your own macro implementation
Yes, but recording a macro (if it work as expected) would be by far simpler than creating a plugin. Iâd have to learn Python, the Sublime API, how to install and debug a plugin, âŚ
Can I intercept all keyboard events (and forward them to their original bindings)? Or do all commands already implement a command âobjectâ (for undo/redo) that I can access from a plugin (but then: why arenât they already recorded by the current implementation)?
You can create an EventListener
object and implement the on_text_command
and on_window_command
endpoints to capture commands as theyâre happening (along with their arguments). Despite the name, on_window_command
captures ApplicationCommand
commands as well.
A simple implementation could record the commands and their arguments to replay what the user did, in theory.
In the case of Undo/Redo, thatâs a function of the edit
object passed to the run
method of TextCommand
instances. The only way to modify a buffer is via a call that takes an edit
object. Under the hood Sublime uses that to track changes.
Currently only TextCommand
commands can be recorded in a macro, which is why some things donât get recorded during Macro recording (or why you canât manually create a macro file with those kinds of commands in it).
Only @jps knows why the current macro support only supports TextCommand
commends though.
So we are all in agreeance thenâŚSublime macro system sucks?
About writing my ownâŚI donât know anything about the api, but I am willing to be, the fact that there is no popular plugin solution probably alludes to the fact that there are some deeper rooted limitations at play here.
But sure I can write my own plugins for almost every editor out thereâŚ
Iâve been using Textpad and then Notepad++ for years and switched to Sublime on the recommendation of a friend.
I was totally dumbfounded when I found out that there is no support for find/replace in macroâs.
Seriously, whatâs the point of not supporting something as rudimentary as find/replace in a macro?
Looking back, I see that this has been an issue for ever.
Is there an add-on that I can use to record macros that support find and replace in the mean-time? This is a Big Deal, to me as I use macrosâs do some some pretty complex work. Iâm just glad I didnât uninstall Notepad++
Sublime has an alternative âmacroâ system that supports all built-in features, arbitrarily complex logic, and literally anything your computer can do. The Python API is so powerful and easy to use that I donât see the point of actual macros. Frankly, I see them as a dubious vestige of TextMate compatibility rather than a valuable feature in their own right, and I wouldnât expect any significant new development of this obsolete functionality.
If youâve never written a Sublime plugin, you owe it to yourself to do it at least once. Itâs super-easy. I have written a useful complete plugin in less than fifteen minutes start-to-finish in front of an audience. Custom Sublime plugins will change your life.
Not sure which kind of complex work you need to do, but RegReplace is something which might be used to create complex find/replace templates based on regex. Those templates might be called from macros the same way as all available built-in or plugin commands can be.
I didnât ever feel happy with macros in Notpad++ and I donât in ST. But @ThomSmith stated the big advantage of ST over Notepad++ already. With some little effort in learning pyhton, you can create much more comprehensive âmacrosâ to help you with your dayly life as you would ever be with Notepad++ (except digging into its C-API and create a C-plugin).
By the way, I didnât post this (was saved as a draft), strange things supported by macros, like saving bookmarks, should be implemented only after find and replace has been implemented, in my opinion. Iâd rather be able to record find and replace using macros rather than save bookmarks! Then again, maybe implementing bookmarks into macros was a simple task, which is why it was done, who knows. I wish Jon would comment on this.
well it was never made possible for the find/replace string to be set from a plugin/macro:
I posted in the previous thread on this subject about a year ago, and have mentioned it in other posts too. A number of people are chiming in with the position that extensions are more powerful than macros, which obviates the need for macros to record things like Find/Replace. I sit firmly on the side of the argument that macros should record everything that makes sense, with a few documented exceptions that should also make sense.
While I agree that extensions are more powerful and can always do the work of a macro - though I feel that Sublimeâs API needs some work to really unleash that power - theyâre no substitute for macros. The reason is simple: Being programmers, we would rather avoid having to write more programs to achieve sophisticated editing operations wherever possible. For many of us, Python and Sublimeâs API are not our primary programming environment so the process can become overly time consuming. The editor is there to save us time and make complex editing operations a breeze. Extensions are useful where we might want to do something complex, repeatedly over time and with necessary logic that might change based on a variety of conditions or variables. Such functionality will often be useful to others. Macros should allow us to record a sequence of operations by doing them, optionally allow refinement by editing the macroâs code, then allow macro playback to be triggered with a keystroke.
The power of a programmerâs editor becomes evident to most when they discover the ability to build complex editing operations out of simple building blocks. Originally a Brief user whose editor of evolved through Emacs, Vim and Crisp for many years (I still use the latter), the ability to record and repeat a series of operations, including and beyond text entry and cursor movements, and play them back with a keystroke or say ârepeat playback 20 times or until EOFâ, is a workflow that can surmount complex editing tasks over large files in record speed. While Sublimeâs multi-cursors and multi-selections can get you to the same place in some cases, it often canât. So Iâm left falling back to Crisp as others fall back to Notepad++ etc. to do such things - and thatâs a real shame.
Many ask why this is the case. I donât have insight into Jonâs design choices but I am a programmer, and the reason seems fairly obvious. Jon engineered macros to sequence simple keystroke-based operations like text entry, deletion and cursor movement into atomic language specific operations. Any text editor will need a wealth of these, and a dumb âsequencerâ which avoids functional code seems a logical, quick to implement approach. Beyond actual keystrokes, TextCommands are the lowest level operations falling into this category so Jon implemented the facility this way. Adding other types of function adds complexity because they might potentially affect the state of entire buffers, require input etc⌠So if Iâm right the reason is simplicity, justified perhaps by the thinking that multi-cursors/selections would be an alternative workflow to the same ends.
With the time thatâs passed itâs become clear that, while useful, multi-cursors/selections are not a panacea for the challenges of complex editing tasks. We need macros that can record and playback everything, which can then be used in extensions or as part of eg. ârepeat X times or until EOFâ.
Addressing Sublimeâs key limitations should probably be high on the priority pile moving forward. For me, more powerful macros that record everything, and extensions that can do more by virtue of a richer API should be right at the top of the list.
This seems to me to be the heart of the issue. I respect this position, having once been in it myself. But after using Sublime Text for several years, I feel that it is impossible to take full advantage of it without being willing and able to write new commands. I realize that it can take a while to become accustomed to making a new command a first resort, but for me, the time spent has been well worth it.
I half-agree with your conclusion â I have my own wish list of new API-accessible features. But personally, I would be a little disappointed if a new feature on that list were not implemented because the devs spent their time taking an existing feature thatâs already exposed by the API and adding another redundant way to use it.
@qgates Addressing Sublimeâs key limitations should probably be high on the priority pile moving forward. For me, more powerful macros that record everything, and extensions that can do more by virtue of a richer API should be right at the top of the list.
I agree with you, but in my opinion, what should be the top of the are the bug fixing:
I am not saying Sublime Text does all that. Recently Sublime Text seems not to:
I use Sublime Text because it has really powerful text features, and it is damn fast. Initially using Eclise & company, but they are too slow, after some years, they got really disgusting. So I started using Notepad++, which is pretty fast. But lacked the fuzzy auto completion and project management. Then I started try everything out there. But the only thing really fast and powerful as Notepad++, was Sublime Text. But even better, it runs on Linux and Windows
@ThomSmith I feel that it is impossible to take full advantage of it without being willing and able to write new commands.
I think, from very far from the other editors, is that Sublime Text allow you to create your own commands. So, yes the full advantage is to write your own commands, therefore it can be wherever you would like it to be. Be your own editor, with your own fingerprint.
@qgates The editor is there to save us time and make complex editing operations a breeze. Extensions are useful where we might want to do something complex, repeatedly over time and with necessary logic that might change based on a variety of conditions or variables. Such functionality will often be useful to others. Macros should allow us to record a sequence of operations by doing them, optionally allow refinement by editing the macroâs code, then allow macro playback to be triggered with a keystroke.
Well, I barely new macros existed on Sublime Text. Iâve using a long time ago this other macro recorder:
May be that third part app can help you. To do mass editions I have been using some packages as:
And regular expressions with find replace like (\s*)(word1)(\s*)(word2)
-> \1\4\3\2
.
@qgates For many of us, Python and Sublimeâs API are not our primary programming environment so the process can become overly time consuming.
Indeed, is pretty time consuming writing new commands. But there are a lot of new commands already written out there. You could inspire and reuse. For now I have been writing some general commands which I can reuse over and over again.
I just ran into this issue today while working with a very large file that was consistently formatted and perfect for macro use. I wasnât as surprised to find that the search functionality wasnât supported, but I was very superposed to find that find_under
and find_under_prev
werenât supported.
I really canât think of a scenario where the current macros would be helpful.
Before Sublime I used Notepad++ and found myself using macros all the time. After switching to Sublime my macro needs almost disappeared because of multiple cursors and find_under
. But there have been a few times that they were exactly what I needed.
I can say that booting a windows VM, installing notepad++ for the first time in 6 years, and re-learning itâs macro functionality was undoubtedly faster than figuring out plugins.