How can I convert words to camelCase in a macro?

Question

I have a list of words, like this:

these are
some
words that I want
to convert to
camel case

I need a way to turn, for example, camel case into camelCase within a macro (or a way to turn every line of a visual line selection into camel case).

I could use something like wgUlhx as many times as necessary, but the problem is that this doesn't work for words of varying lengths (so, for example, wgUlhxwgUlhx would work for convert this please but not for convert these pretty please).

The desired output for the above lines would be

theseAre
some
wordsThatIWant
toConvertTo
camelCase

Is there any way to automate this?

Answer 1

A One Liner

I found a simple regular expression replacement (assuming 'magic' is set):

:s/ \([a-zA-Z]\)/\u\1/g

This match any single letter after a space, saving the letter. Then, it replaces it with the saved letter made upper case (\u = upper case, \1 = first saved match), for every match in the line.

Apply over the entire file by putting a % between : and s.

The downside to this solution is that it is linewise (which works for your examples), but would fall short if you only wanted to camel case a few words out of many within a line.

A fuller solution

map <leader>g~ :set opfunc=MyCamelCase<CR>g@
function! MyCamelCase(type, ...)
  let searchsave=@/
    silent s/\%>'\[ \([a-zA-Z]\)\%<']/\u\1/g
  let @/=searchsave
 endfunction

This creates a new operator that can operate on a motion. If you have <leader> as \, then given the following text (with | as the cursor):

This is some |example text to work with.

Typing \g~3w gives

This is some exampleTextTo work with.

That is, we camel cased over 3 words.

Description of that substitution:

s/ starts the substitution.
\%>'\[ is a bit painful. The \%>'m says to match to the right of a mark. We want mark [, but that also has to be escaped in this pattern. So, this starts the match after the motion given to the operator.
\([a-zA-Z\) is the same as from the one-liner above.
\%<'] this is the other end, matching before the end of the motion.
/\u\1/g is the replacement from the one-liner above.

Answer 2

For an alternative I use the vim-abolish plugin that offers a coercion feature:

Want to turn fooBar into foo_bar? Press crs (coerce to snake_case). MixedCase (crm), camelCase (crc), snake_case (crs), and UPPER_CASE (cru) are all just 3 keystrokes away. These commands support repeat.vim.

Answer 3

You can create a recursive macro that does this for a single line with the following keystrokes:

qqqqqf xgUl@qq

(Note that the space between the f and the x is a tap of the spacebar, not a pause)

In detail:

1. Clear out the q register. This is necessary because we are creating a recursive macro. (See step 5.): qqq

2. Start recording a macro in register q: qq

3. You can't use the w motion here, because you want the macro to abort when it gets to the end of the line, rather than leaping to the next line. Instead, jump to the next space character on the line by pressing the f key followed by the spacebar: f<space>

4. Delete the space and upper-case the following letter: xgUl

5. Recurse. Because we cleared the q register in step 1, there's nothing in it yet, so this will do nothing: @q

6. Save the macro: q

You can then apply this macro to multiple lines by using a range:

Apply the macro to every line in the file:

:%normal @q

Apply the macro to lines 2–5 inclusive:

:2,5normal @q

Make a visual selection, and then type :normal @q. This will pre-populate the command line when you press the : key, resulting in a command which applies the macro to every line in the selection:

:'<,'>normal @a

Answer 4

See http://vim.wikia.com/wiki/Changing_case_with_regular_expressions It explains the \U, \L, \u, \l modifiers quite clearly and succinctly!

Its essence is the following:

There are times that you might like to go through a file and change the case of characters that match some arbitrary criteria. If you understand regular expressions well, you can actually do this fairly easily.

It's as simple as placing \U or \L in front of backreferences which you want to change the case of, and \E at the end. Vim will make the text in the backreference uppercase or lowercase (respectively). Use \u and \l (without the \E at the end) to just change the case of the very first character in the backreference.

(A "backreference" is a part of a regular expression that refers to a previous part of a regular expression. The most common backreferences are &, \1, \2, \3, ... , \9).

Some examples that demonstrate the power of this technique:

Lowercase the entire file

:%s/.*/\L&/g

(& is a handy backreference that refers to the complete text of the match.)

Uppercase all words that are preceded by a < (i.e. opening HTML tag names):

:%s/<\(\w*\)/<\U\1/g

Note also the gu and gU commands.

For example, ggguG will lowercase the entire file. (gg = go to top, gu = lowercase, G = go to EOF).

By using the \0 general backref instead of the name ones (\1, \2 etc) you can save some typing for on replace stanza of the regex.

This regex upper cases an explicit set of words to uppercase in a file:

:%s/\(select\)\|\(order)\|\(by\)\|\(from\)\|\(where\)/\U\0/g

Not rocket science, but otherwise you'd have to do this:

:%s/\(select\)\|\(order)\|\(by\)\|\(from\)\|\(where\)/\U\1\U\2\U\3\U\4\U\5/g