Handy text manipulation tricks in Sublime Text 2 | Hacker News Reader

Handy text manipulation tricks in Sublime Text 2

whiletruecode.com

145 pointsjoshearl97 comments

Any article that talks about tricks in Sublime Text 2 without mentioning Multiple Cursors is... lacking (no offense to the OP).

For anyone that doesn't know it, Multiple Cursors is the ONE BRILLIANT FEATURE that Sublime Text has. Don't get me wrong, tt's great in many other ways too, but Multiple Cursors is, IMO, a feature that should become part of every friggin' text editor in existence, it's that important. And it only exists in Sublime Text.

It gives you multiple cursors at seperate places in your document. Each one acts completely independently, moving around with your commands. Everything works as expected, including copy-pasting (it will match the copy-pastes up to your cursors).

Most text editors have a column-select mode, except that Multiple Cursors are the same thing on steroids:

1. The selections don't have to be contiguous. So if you have a bunch of:

<div>

  <p> Text And more Text</p>

  <p> Something </p>

</div>

You can put the cursor only on the <p>s.

2. Since each cursor acts independently, you can do operations that you simply can't do in column mode. For example, place the cursor on each <p>, select to the end of that </p>, and delete the text. This is even if the contents of the </p> are completely different.

3. Multi Cursor gives the same power as macros, but: They're visual! You see all the changes you're making in realtime. Any long-time vim user has probably recorded a macro, tried playing it back, and discovered that it didn't work. Well, with Multi Cursors, you see the cursor and changes in real-time. Make a wrong command? Undo it instantly.

Want an example of another actual use case? I used to have a plugin for Sublime Text that let me split a selection into multiple selections, based on a character. So, let's say I had this code:

foo(int a, char b, char c)

I could select the paramater list, run my shortcut to split by ",", then I'd get a different selection on each paramater. Then, I could simply multi-select three lines below it inside the actual function, paste, and I've got this code:

foo(int a, char b, char c)

  int a

  char b

  char c

A dead-simple editing task I do 300 times a day.

Another example? Let's say I have two "if" blocks in the top of a function:

if (somecondition):

  return

if (anothercondition):

  return

Now, let's say for a second that I just realized I don't want to return, I want to do some processing, then return. This happens a few times a day for me. I just multi-select both "if"s, hit enter, and add the code. If it's two functions and I need to use the function names, I can even go back, copy the function name, and paste it as part of the processing!!

Phew. If it seems I'm a fanboy for Multiple Cursors, I totally am. It's a brilliant tool that only exists in Sublime Text. I've unfortunately gone back to Vim, and am too far in Vim's world to manage working in Sublime Text, which is why I miss multiple cursors so much!

But I AM working on a Vim plugin that gives Vim Multiple-Cursors. Been working on it for a while, but I think I'm getting near a more-or-less stable version. Hopefully, it will be released soon.

</way-too-long-rant>

   if (somecondition):
     return
   if (anothercondition):
     return
 
   Now, let's say for a second that I just realized I don't 
   want to return, I want to do some processing, then 
   return. This happens a few times a day for me. I just 
   multi-select both "if"s, hit enter, and add the code.

Not a great example, because this only leads to code duplication.

I guess you are aware Sublime Text 2 has a Vim mode. As someone who's gone "far in Vim's world", how do you think this compares to regular Vim? I'm starting to learn Vim commands in ST2 but I don't know if "proper" Vim is required to get fully into Vim.

One thing I miss in ST2 Vintage mode is that <> brackets aren't recognized with things like ci< and di<.

I'll be brutally honest. I think it's a great effort, and almost moved back to Sublime Text w Vintage mode several times. And each time, I'll run a command that Vintage mode doesn't have yet, and leave.

I'd love it if ST managed to replace vim. I (very unfortunately!) don't see it happening soon. Vim just has so many features and so many plugins.

NOTE: Half of my plugins in Vim are only there to make vim behave like a decent, modern editor. In fact, half of my plugins in Vim are there to make it behave more like Sublime Text.

I think it's one of the best vim-emulations I've seen so far. It's not 100% but it has things like text-objects (cit, etc.), named buffers and bookmarks (which most of the other emulations miss).

I do V(motion):norm cityour new content<CR>, which does the same as your point 2, very often.

But, as you said, multiple cursors is a lot like visual feedback for macros. I miss such a "live" feel sometimes.

You got me interested: I'm looking forward for your Vim plugin.

Completely agree on the awesomeness of multiple cursors and ST2 in general. The official documentation has some more tips: http://www.sublimetext.com/docs/2/multiple_selection_with_th...

Fortunately, other editors are already adopting similar features. Just today I was fiddling around with Ace, a web-based code editor, and noticed that they support multiple cursors too! Just select multiple words while pressing the Ctrl (or Cmd) key.

Live demo: http://ace.ajax.org/build/kitchen-sink.html

The nicest thing is that I only found this by accident because I'm so used to using multiple cursors in ST2. It's a great feeling to be surprised that something works just the way you sub-conciously expected :)

Fortunately, other editors are already adopting similar features.

Yup, work's being done to add this to Emacs as well although it is not quite there yet:

- http://emacsrocks.com/e08.html

- https://github.com/emacsmirror/multiple-cursors

This is awesome. The world is finally waking up! :)

Are you saying Emacs is finally getting a decent editor? ;)

I agree multiple cursors are awesome and largely can replace macros with real-time visible changes.

But there is one use-case of macros that cannot be replaced with multiple cursors -- one where the places being affected by the macro are themselves computed by the macro.

Can you please give an example of that? You've got my curiosity piqued :)

Btw, another place this can't be used is across multiple files, at least the way ST does it.

Sample

    def qux(bar, baz, qux)
        pass

    def quuux(grim, gram, grom)
        pass

    def quuuuuux(hip, hop, zoom)
        pass

Delete second argument (of 3+ arg functions):

    /def<CR> # search
    qd       # record as 'd'
    2f,dF,n  # find second arg
    q        # done recording
   
    @d       # again (or n to skip)

Example intentionally simplified/convoluted. I'm doing stuff like this on the spot routinely, and there's no way multiple cursors could do this because I apply verbs to text objects that ST has (unless I'm missing something) no way of knowing about in a visual paradigm without resorting to guessing what I mean.

What would be killer is mixing both, i.e visually selecting where to apply a vim macro.

If you put the "/def<CR>" part in the macro too, then you can re-execute it multiple times.

I think it's actually useful, not simplified/convoluted..

Actually, this is a perfect example of using Multiple Cursors to get the job done more easily.

I'd select all three "def"s simultaneously, then move by word three/four times using ctrl+right, or plain old "w" if using ST's vim mode. When I'm on the second param, I'll delete forward to the next ",". I could also just ctrl+right my way until the next word, which would be the same.

Just to recap the keys I'd press:

/def (select first def) ctrl+d * 2 (select using multi-cursors the next two defs ctrl+right * 4 (to get to the second param) ctrl+shift+right (to select the entire second param) delete

And if I mess up at any point, I instantly see it. If I did something that only works for the first case but not the others, I see it immediately.

Note: Using vintage mode, Sublime Text has vim shortcuts. Without it, Multiple Cursors still rock, but are missing a LOT of their power (exactly because of situations like this).

In fact, in Sublime Text 1, for which vim mode didn't exist, I actually implemented a plugin to emulate the "f" and "t" movements because they were so good.

How do you make multiple cursors that are at the exact locations you need?

That's something that a macro is useful for. His macro is less useful because for some reason he did his search outside of the macro. Maybe the search is not for "def", but for "def prefix", so ctrl+d is not applicable to form the multiple cursors.

It could be nice if you could record your movements to form the "next" cursor and immediately see all future generated cursors given that movement (similarly to the "recursive draw" web app). Then you could perhaps truncate the infinite list of cursors at some finite point somehow, and then operate your multiple cursor operations.

"How do you make multiple cursors that are at the exact locations you need?"

There are a few simple tricks.

In this case, I hit "ctrl-d", which does the following:

1. If nothing is selected, it will select the word the cursor is on.

2. If something is selected, it will select the next match of this word, using another cursor.

In other words, I'll put my cursor on "def", hit ctrl-d, and "def" will be selected. Hit ctrl-d again, and the next "def" will be selected. Etc. Technically, in Sublime Text, every search makes a multiple cursor. I could hit alt-f3 (IIRC) to select all matches of "def", and they'd all be multi-selected.

But like I said, in this case it's really easy.

There are more advanced tricks - what if the word "def" appears inside the text? Well, you can select not only the def, but also the whitespace before the def, and it will selected the next "def" which is at that exact indentation. And like I mentioned in another comment, I even wrote a plugin to make multi-selections more easily, by splitting on a certain character. So that a list like this: (int a, int b, char c) can easily be split into 3 selections, around the comma.

Sounds great, hopefully someone ported this to emacs :-)

Now that's the kind of thing I wish I would see in a "ST tricks" blog post.

> When I'm on the second param, I'll delete forward to the next ","

you can't do that, else you'll delete not enough ('gra') or too much ('baz,')

> ctrl+shift+right

It fails the moment one of the second arguments has a space or a dash. e.g default value:

    def qux(bar, baz = {}, qux)

or in some languages (CSS, HTML, LISP)

    <div class="foo bar-baz quux" data-behavior>

The interesting reason is why it fails: you say you want to delete 'to the next ","' but do word movement with w or ctrl+arrows. Indeed this is solved by Vintage mode, but I unfortunately found it too inconsistent with vim, and lacking a few critical features (e.g vim-surround and indent-object) for me.

Also, multiple cursors rock anyway, but if I want to apply them to a number of elements responding to a criteria and decide on a case by case basis if I want to apply then it does not work. Also it does not work when there's no code locality (i.e affected code is not visible in the same view, or spread around multiple files). The major difference with macros is that they're repeatable, while multiple cursors do the same thing at once, and once.

Also, when one vim user uses f/t too often, one should look into an object describing what he wants to really do (here [0]).

[0] http://www.vim.org/scripts/script.php?script_id=2699

I hope Sublime Text has or introduces at some point the same extendable concept of text objects as in vim.

Don't get me wrong, I'm not saying anything of this is bad per se, just that there's room for improvement.

jEdit has had this feature for a long time. It's one thing I miss, having moved to Vim.

One note on your point about changing return behaviour: That's the ONE case a goto is IMO warranted. If I have to choose between a dummy function, code duplication and a goto, I choose goto.

I'd go dummy function all the way.

No code duplication. No goto

well to each his own. In case of the cleanup phase before return I find it to be much cleaner with goto, since usually it's sub 10 lines and you'd have to program a function that gets pointers or objects passed that then get freed/destroyed, which I find ugly as hell. I look at such an outer procedure as an 'owner' of these objects and therefore I want to see the allocations and deallocations in plain text right there.

I agree, but I didn't want to get bogged down in a "GOTO bad or not" discussion, which is why I left this detail out.

Having switched to Vim, multiple cursors are the only reason I ever use Sublime Text anymore. They are insanely, amazingly awesome and powerful. I can't wait to see your efforts at porting the idea to Vim.

Vim equivalents if you're feeling jealous (matching the order in the article):

  J    Join line.

  ddp  Swap line with the one below.
  ddkP Swap line with the one above.

  dd   Delete current line
  yyp  Duplicate line

  gq}  Rewrap a paragraph.

  Vu   Lowercase a line
  VU   Uppercase a line

Sort the selection by the Unix `sort` command (eg. sort -rn for reverse numeric order):

  V <select your lines>
  :!sort

It goes a bit pear-shaped for these ones, though:

  Title-Case:
  :s/\<\(\w\)\(\w*\)\>/\u\1\L\2/g

  Twiddle/Flip Case:
  function! TwiddleCase(str)
    if a:str ==# toupper(a:str)
      let result = tolower(a:str)
    elseif a:str ==# tolower(a:str)
      let result = substitute(a:str,'\(\<\w\+\>\)', '\u\1', 'g')
    else
      let result = toupper(a:str)
    endif
    return result
  endfunction
  vnoremap ~ ygv"=TwiddleCase(@")<CR>Pgv

I'm a bit stumped on toggling comments, though. Any ideas?

> I'm a bit stumped on toggling comments, though. Any ideas?

http://www.vim.org/scripts/script.php?script_id=1218

Simpler alternative: tComment http://www.vim.org/scripts/script.php?script_id=1173

>> J Join line.

>> ddp Swap line with the one below. >> ddkP Swap line with the one above.

>> dd Delete current line >> yyp Duplicate line

>> gq} Rewrap a paragraph.

These shortcuts work in Sublime too, with Vintage mode enabled.

For swapping lines I recommend following shortcuts:

    " Move a line of text using ALT+[jk] or Comamnd+[jk] on mac
    nmap <M-j> mz:m+<cr>`z
    nmap <M-k> mz:m-2<cr>`z
    vmap <M-j> :m'>+<cr>`<my`>mzgv`yo`z
    vmap <M-k> :m'<-2<cr>`>my`<mzgv`yo`z

    if has("mac") || has("macunix")
      nmap <D-j> <M-j>
      nmap <D-k> <M-k>
      vmap <D-j> <M-j>
      vmap <D-k> <M-k>
    endif

>I'm a bit stumped on toggling comments, though. Any ideas?

    " comentify/uncommentify a line or a visual block"
     function! Komment()
     if getline(".") =~ '^[ \t]*#'
             let hls=@/
             s/^\([ \t]*\)#\(.*\)$/\1\2
             let @/=hls
         else
             let hls=@/
             s/^\([ \t]*\)\(.*\)$/\1#\2
             let @/=hls
         endif
     endfunction
     :vnoremap // :call Komment()<CR>
     :nnoremap // :call Komment()<CR>

    If you want to use c style comment : 
    function! Komment()
         if getline(".") =~ '^[ \t]*\/\*'
             let hls=@/
             s/^\(\s*\)\/\*\(.*\)\*\/\(\s*\)$/\1\2\3/
             let @/=hls
         else
             let hls=@/
             s/[ \t]*$//
             s/^\(\s*\)\(.*\)\(\s*\)$/\1\/\* \2 \*\//
             let @/=hls
         endif
     endfunction
     :vnoremap <silent> // :call Komment()<CR>
     :nnoremap  <silent> // :call Komment()<CR>

edited formatting

gqap uses a paragraph as a text object so you don't have to be at the start of the paragraph for it to work, just somewhere inside it.

Unless I'm misunderstanding the purpose of your 'TwiddleCase' function, you can simply highlight the text that you want to flip and hit ~ to invert the case.

I think macvim has this because I've been doing it for as long as i remember, or maybe it's in Janus though.

This is all plain vim, so this'll work in MacVim, GVim and Janus (just MacVim and a bundle of plugins).

sorry i meant command / to toggle comments

Makes me curious how you manage to remember all these commands.

Is there some sort of trick you use?

Vim commands are like a language - you don't route learn combinations, only the individual "words", and you string them together dynamically, like you would do with English words in a sentence.

What are the list of those individual "words". And what is the syntax for combining them?

This is the best explanation I've found so far: http://stackoverflow.com/a/1220118/3528

It was a very good read. But not what I was expecting. If vim is indeed speaking a language this is what I would expect a vim tutorial to have.

    1. Basic commands.
    2. Syntax to chain basic commands.
    3. Ability to form other commands from basic commands.
    4. Way to write macros.

Instead most vim tutorials I have read present with a list of several commands to memorize and then a cheat sheet to navigate you through a jungle. Often they are letters, and not meaningful words. So they are difficult to put into ones brain. Couple that with vim's modes. And you are set with a perfect recipe for disaster in case of a new bie.

If vim is indeed speaking a language than manuals and tutorials teaching it, must explain how to speak that language.

This is 2012 and the need to memorize commands, and read cheat sheets to edit text doesn't belong to our times.

What I seem to get is vim aims to provide sed, grep, tr, cut etc kind of tools inside a text editor in form of some interplay of letters and words. How I haven't figured out till today's date.

Every time I've tried to learn vim, I've quit trying to memorize 'yy P...' kind of commands. That happens as I first can't memorize random arrangement of characters. Secondly if its not random, I've not understood how to arrange and use those letters to make meaningful commands.

Based on this comment I think it's possible that vim isn't for you and you would probably be better suited to something like Sublime or TextMate.

Why would that be, vim seems to be difficult to use because a good manual that actually teaches how to use vim isn't available yet.

In fact it was surprising to me when I learned vim commands are actually a form of some terse language. Because I was only of an assumption that most vim commands are random string of characters you need to memorize. And when you memorize and practice enough you become productive.

I would be definitely well suited for vim, because I like terse language paradigms in unix like sed, awk, perl. I think if I had known about these aspects of vim a while back. I would have tried to write a few essays myself to understand using vim effectively.

I feel tempted to give vim a try now.

> Why would that be, vim seems to be difficult to use because a good manual that actually teaches how to use vim isn't available yet.

What manuals have you tried? Have you tried `vimtutor`(if vim is installed, just run vimtutor from the sell).

> In fact it was surprising to me when I learned vim commands are actually a form of some terse language. Because I was only of an assumption that most vim commands are random string of characters you need to memorize. And when you memorize and practice enough you become productive.

You need to know a lot of words before you can form intelligible sentences. There is no not-knowing `h,j,k,l,esc,d,x,p,b,w,i,I...`. So yes, you do need to memorize basic operations before you can chain them. Most of the things in this cheatsheet are important to know http://tnerual.eriogerg.free.fr/vimqrc.pdf

And once you have learnt the basic, there is no manual to tell you how to combine them, because there is no syntax to do it - you just run them in sequence. It has already been pointed out in the SO thread, and various other threads here.

> I feel tempted to give vim a try now.

Your temptation will last all of 1 day. If you give up, vim isn't for you. It takes a minimum of 15 days to a month to s top missing whatever editor you are using right now, then another month to actually start liking it.

I am emacs user. The problem isn't patience with vim. The problem really is deciphering the `h,j,k,l,esc,d,x,p,b,w,i,I...` sequence.

So as long I can't make sense of what random stream of characters mean, any amount of practice to put them into finger memory is going to be a exercise in frustration.

> The problem really is deciphering the `h,j,k,l,esc,d,x,p,b,w,i,I...` sequence. > So as long I can't make sense of what random stream of characters mean, any amount of practice to put them into finger memory is going to be a exercise in frustration.

That wasn't a sequence - that was basic movements and operations you need to compose sequences.

h,j,k,l is as intuitive as it gets http://wireless.ictp.trieste.it/school_2003/docs/linux/linux...

Rest of the basic movements are mostly mnemonics

w - move forward a word

b - move back a word

e - move to the end

d - delete followed by movement

You use these to formulate sequences.

d2w - delete 2 words

d2b - delete 2 words backwards

d2w2j - delete 2 words and move 2 lines up

d2w2jp - delete 2 words, move 2 lines up and paste(what was deleted)

d2w2j^p - delete 2 words, move 2 lines up, go to beginning of line(^) and paste(the deleted words)

df)/test$F{p

delete till ) (df)), search forward for test (/test), go to end of line where search is found($), search backward for { (F{), and paste(p)

They aren't random stream of characters if you know basic movements and operations.

As far as emacs goes, I find vim to be superior when it comes to navigation. When I am using emacs, I have a minimal configuration file for a few things I absolutely need:

    ;; General settings.
    (setq transient-mark-mode t)
    (line-number-mode t)
    (column-number-mode t)
    (global-hl-line-mode t)
    (setq-default indent-tabs-mode nil)
    (global-font-lock-mode t)
    (setq-default fill-column 120)
    (setq auto-fill-mode t)

    (define-key global-map "\C-xw" 'what-line)
    (define-key global-map "\C-z" 'undo)
    (define-key global-map "\M-g" 'goto-line)

"M-x goto-line line-number <CR>" is just too much typing for going to a specific line.

What emacs wins at is external tools integration. Vim doesn't support async command integration, and per the developers, never will. Vim developers believe vim is a text editor, and it has no business running shells; a stance I am ok with. But that means there never will be a slime for vim, at least not the way it works for Vim i.e you can't execute chunk of code, and be dropped in a debugger if an exception occurs. And there will never be a debugger which seamlessly integrates with vim. I do miss these things sometimes, but there are decent alternatives - I love my zsh, don't need it in an editor; slime, sans debugger is just configuring vim to send selection to repl etc etc.

Yup, you start with #1 there.

#2 doesn't really exist, so no need to learn it.

#3 is just using the commands in sequence. They aren't new commands.

#4 is advanced and I've never had a need for it yet.

Let's pick some apart:

ddp:

dd - delete line

p - paste line below

This swaps a line because when you delete a line, the line below it moves up and you end up on that line. When you paste an entire line, it pastes to the next line.

ddkP:

dd - delete line

k - move up 1 line

P - paste line above. (Shift usually means 'opposite direction', so it pastes above instead.)

I don't think of these as commands as such. I just think, I want to delete this line, and then I want to place it here. He's providing these as commands to show that Vim can handle the same features as Sublime Text, but he's doing it in a non-Vim way, as far as I'm concerned.

You don't memorize non-basic commands. You just use basic commands until you get what you need, and it happens that the advanced commands for most other editors can be done with just the basic commands of Vim.

He's providing these as commands to show that Vim can handle the same features as Sublime Text, but he's doing it in a non-Vim way, as far as I'm concerned.

I'm all ears. What would be the Vim way?

As I said, learning the basic commands and using them. There's no need to remember a key combo for 'swap lines' because it's just 2 basic commands used in succession. I never even think of it as 'swap lines' because what I want to do is remove a line, then place it somewhere else. And that's what the commands are in Vim to make it happen.

That's how I constructed the above list in the first place, but I get what you mean; you shouldn't be learning these as Street Fighter-like combos.

1. "Basic commands" are what you know after 30 minutes of

    $ vimtutor

2. "Syntax to chain basic commands" is what you get when you think about what you are going to do. Like in any spoken or written language: "copy this line and paste duplicate it 10 times above" would be

    yy  copy this line
    10P paste above, 10 times

You have verbs (yank, paste, delete, join, move down…), direct objects (this word, this line, this html tag, this function, this paragraph…), indirect objects (up to this word, between line y and line x…) and, well… "counts" to do all that multiple times.

Vim's language is a lot more natural and intuitive and efficient than any variant of Cmd+Left - Shift+Ctrl+Right - Right - Cmd+c - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v - Down - Cmd+v

Saying it's too arcane/complex/hard is just lying or being lazy.

3. "Ability to form other commands from basic commands" is achieved by writing small (or big) functions and bind them to your own commands.

4. "Way to write macros" is by not writing macros. You record a sequence of commands/keystrokes and run it later:

    qa   record a macro in register a
    yypj duplicate this line and move to the line below
    q    stop recording
    10@a apply the macro 10 times

No need for a cheat sheet if you are commited and don't rush it.

I use both Emacs and vim on a daily basis. Emacs is my main editor and vim is for quickly dropping in to make a change in a terminal either locally or on a server.

Both are amazing. Both are rock solid. Both are infinitely extensible. Both are free as in beer and as in freedom.

I'm not afraid of paying good money for software. I don't think it is necessary to pay for a closed-source text editor when such good open-source options exist that can do everything the commercial product can do and more.

TextMate (and now Sublime Text) have been popular in the hacker community, particularly with Rails people. The only advantage I can see is eye-candy. They look great on Macs.

I tried TextMate and put it in the trash as soon as I found it had no split windows. Not only that, I couldn't add split windows even if I had the time. If vim or Emacs is missing something, you can add it.

End of rant.

Have you actually tried Sublime? It has split windows. And you can extend is pretty easily using packages. I've read many posts of vi and Emacs hardcore users who actually liked Sublime.

It's also closed source, meaning we can't fix something if we want to. We can't see what's going on back there. When it comes to a tool that I use every day with personal data, I really want it to be open source.

My browser and my text editor definitely need to be open source. Additionally, Emacs is really amazing, and like many others, I've been building this init.el for years (in my case months), meaning Emacs and I are really made for each other right now.

I actually did use the fact that MacVim is open source to fix a bug one day. Well, actually, someone else had already figured it out and provided a patch, but it wasn't in the main line yet and I really, really needed it that day. But I was already on the track to fixing it when I found someone else's patch.

Yes I have. My comment about split windows was about TextMate, which 4 years later still doesn't have them. (Coming in TextMate 2, which will be released sometime after Half Life 3.)

Sublime has the eye candy, that I was talking about. It looks great. The 'birds eye' view is nice, but not particularly useful. There is nothing that it can do that it can do that Emacs/vim can't do or couldn't do with a few minutes of macro-recording/scripting. This is why I am saying it isn't worth the money. The open-source alternatives are superb.

I don't want to need a cheat sheet to use my text editor, I already need them for the programming language, the regexes, mathematical notation, etc. I don't want to spend a few minutes doing macros/scripting, I want to spend my minutes on the problem domain I'm actually working on. I don't like modes (see NO MODES in the Bret Victor talk), and I like positioning my cursor with a mouse.

I haven't paid for Sublime (yet), but I'm still much less annoyed by the occasional nag-boxes than by modes. I don't see a future in emacs/vim, but I am anxiously awaiting an intelligent editor such as LightTable.

Remembering shortcuts for Sublime would be no different to remembering shortcuts for Emacs/vim/whatever. I agree with the 'no modes' sentiment which is why I find Emacs more natural than vim for the bulk of my work.

If you forget the short-cut for a command in Emacs, you can hit M-x, type in the name of the command (with completion to help you) and once you execute the command Emacs will TELL you the shortcut for next time (if there is one assigned). Best feature ever.

A few more handy ones:

Line Manipulation:

  Select Line (press again to select subsequent lines): Command+L / Ctrl+L
  Split multi-line selection into multiple selections, one per line:
    Command+Shift+L / Ctrl+Shift+L
  Delete to BOL: Command+Delete / Ctrl+Shift+Backspace
  Delete to EOL: Control+K / Ctrl+K,Ctrl+K or Ctrl+Shift+Delete
  Delete Line: Control+Shift+K / Ctrl+Shift+K
  Insert Newline After: Command+Return / Ctrl+Enter
  Insert Newline Before: Command+Shift+Return / Ctrl+Shift+Enter

Multiple Selections:

  Add next occurrence of current word to selection: Command+D / Ctrl+D
  Select all occurrences of current word: Control+Command+G / Alt+F3
  Undo through selection changes: Command+U / Ctrl+U

Sublime Text 2 – Useful Shortcuts

https://gist.github.com/1736542

I think this is even handier than the original submission. Upvoted.

Not a complete list, but some Emacs equivalents:

  M-^ delete-indentation (or join-line)
  C-x C-t transpose-lines
  kill-line
  M-0 C-k kill to beginning of line
  djcb-duplicate-line (not built-in)
  M-q fill-paragraph
  C-c c comment-uncomment
  M-c capitalize-word...
  org-move-line-up
  C-u M-| sort

M-^ is one of my favorite commands in emacs. I use both sublime and emacs on a daily basis (Sublime has better support for the languages I use at work), and it's a constant source of frustration that C-j in Sublime text joins the line below with the current line, whereas M-^ joins the line above.

I guess that's what I get for not using one editor for everything :p

I'm doing Google App Engine Python stuff with Sublime Text 2.

Is there any way to get it to somehow guess at function signatures? So if I start writing do_something(... I could see the args that do_something() expects. Assuming it's just a function that is plainly defined somewhere in my project folder would be enough for me.

Another thing is when I am testing the app in localhost and it spits out error messages indicating the line number(s) where I sinned, it would be nice to somehow be able to jump to them.

Have you seen CodeIntel? https://github.com/Kronuz/SublimeCodeIntel

Now that I've gotten used to first class refactoring support in the Jetbrains products any other editor just seems archaic. IntelliJ has all the features mentioned in this article and intelligent code restructuring.

Does it allow you to have multiple projects open at the same time yet? That was what prevented me from using it earlier.

Yes:

http://www.jetbrains.com/idea/webhelp/opening-multiple-proje...

Sorry, I should have been more clear. I meant multiple projects in the same workspace, like what netbeans or eclipse has (or even Sublime).

I really like being able to navigate in all my open projects at the same time. Not having it is a no-go for me.

My favourite feature is definently multiple cursors; Ctrl+D selects the next occurance of your highlighted word, Alt+F3 selects all occurances.

Do you know if there's a way to skip the current or next match when doing this?

That's interesting. Can you edit all selected occurrences at once? I don't think there's an immediate analogue in Vim.

yep. I was amazed to find that Copy/Paste even works...

There is no analogue in Vim. It's the one thing I hate about vim.

:%s/original/new/g

Oh yes. It gives you multiple cursors as discussed upthread, with multiple selections. You could then for example press backspace, leaving all the occurrences gone with the cursors left in their place, ready for you to type something new.

You can also hold Ctrl and click to get another cursor

My favorite: in HTML editing mode you can press Ctrl-Shift-A to select enclosing tag and modify both open and close tag at the same time. Very handy when editing HTML files (although I'm not sure if this is Sublime's built-in or from any third party package I installed.)

I've changed some key bindings to suit my taste, like:

    Cmd-D: Duplicate line
    Cmd-L: Delete line
    Cmd-T: Insert HTML tag
    Cmd-B: Open in browser
    Ctrl+Up/Dn: Toggle lines
    Ctrl+a/e/i/o/u: Accented á é í ó ú

Sublime Text 2 has become my favorite editor, fully customizable and plenty of plugins available.

Can you share with us how you made these bindings? Specifically open in browser? using

    	{ "keys": ["f8"], "command": "openInBrowser" },

Didn't work on my windows machine when I made it.

Here is how I did it for Safari, change accordingly.

Go to Tools/BuildSystem/NewBuildSystem... Type this in:

    {
        "cmd": ["open", "-a", "Safari", "$file"],
        "selector": "html"
    }

Save it in your sublime/packages/user folder as 'Open in Safari.sublime-build'

That's it.

It should show up in your Tools/BuildSystem and should be selected for all html files. So when you hit Cmd+B it uses that build system to just show the file in Safari.

There are other ways like mapping Cmd+B directly to a python snippet like:

    import sublime, sublime_plugin, webbrowser

    class OpenBrowserCommand(sublime_plugin.TextCommand):
       def run(self,edit):
          url = self.view.file_name()
          webbrowser.open_new(url)

but for me the first option was simpler.

Sublime Text makes me feel silly for loving a text editor so much. Now if only it would do text completion across multiple files...

Is there a CTags plugin you can use?

Possibly, but that's a lot fancier and less "just works" than I'm interested in. I just want the same extremely simple "what words have I seen before" autocompletion that you get on a file-by-file basis, but as if I had every open file concatenated into one.

Yup, this - https://github.com/SublimeText/CTags Install from package control.

Me too. I've been a vi/vim users for 20+ years, and I swear by vim for C/C++-based development - but now that I'm mostly doing Lua (MOAI), SublimeText2 has become my absolutely most loved tool. It is really one of those editors that became an instant hit, the moment I discovered Cmd-R, Cmd-T, and of course everyones favourite, Cmd-D. ;)

For some reason, ST2 reminds me of the old PC-Write editor for DOS, in terms of raw features and power - I guess because PC-Write was the last editor I used that had proper column/row selection, multiple-cursors, and so on. I sure do miss that editor (switched to vim full-time as soon as PC-Write was EOL'ed and I moved off DOS to Unix) ..

I often paste into it texts from other sources, and enable syntax highlight quickly using the command palette. For example, if I paste an XML into a new tab, I'd click

CTRL+SHIFT+P - X - Enter

The first part opens the command palette, the second selects XML syntax, and enter applies it.

Sort is F9 on my machine, not F5.

For whatever it’s worth, all of these are copied directly from TextMate. :-)

While I did try to be compatible with TextMate key bindings where possible, I believe only a handful of the key bindings mentioned in the article are actually common between the two.

Most of them are identical. The capitalization and line joining shortcuts are slightly different.

Some of 'em are quite different. For instance, Textmate uses various modifiers on the 'u' key for capitalization.

You can also rebind these to any key combination you like.

Sublime Text 2 is great, and they have a free (unlimited) demo; no excuse to not try it out. Well worth the money for me.

Control + G will let you jump to a line number. Also, Ctrl + F and then a colon (:) will do the same thing. I use it all the time and it it extremely handy.

I delete lines with the cut command.

Reply on news.ycombinator.com