To get WordPress to insert the title attribute automatically to a tag we had to modify the wp-includes/js/quicktags.js file by adding a few lines of code to the edInsertTag function at two places:

341
342
343

357
358
359

You can download the fully modified version from here (this file contains my former modifications).

A little side note: I found that the built-in rich text editor is almost absolutely useless, so I turned it off, and I suggest it to every WordPress user.

Escaping the inserted code

When you want to put some source code to the post, you usually simply enclose it in code or pre tags. The problem is, that the source code may contain characters which have special meaning in the HTML language, so they should be escaped. These characters are: <, >, &, &qout; and they should be converted to: <, >, &, &qout;. I would like to have some kind of automation for this task, which could be run when we insert the text to the post.

When you insert a code (and use a syntax highlighter) you should specify the language of that code. For example if you use the WP-Syntax plugin you should enclose your code in pre tags and use the lang attribute to specify the language. In addition you can mark if you want line numbers to appear. Enclosing the copy-pasted text is another repetitive and tedious task so it is another good candidate for automation

It would be great if we could do this two task in one step, so I thought I extend the toolbar above the textarea to provide this functionality by adding a new sourcecode button to it:

The sourcecode button works similar as the others button on the toolbar, if no text is selected on the first click it inserts the open tag, on the second click it inserts the close tag. If text is selected it encloses the text in pre tags when you activate it. The button can be accessed via Ctrl-F keyboard shortcut too. Before it ads the open tag to the editor it prompts for the syntax highlighting parameters and generates the proper open tag to them. When text is selected the special characters will be replaced to HTML entities in it. This way adding source code to your post will be very straightforward:

1. Select the text in te editor:

2. Select the inserted text and press Ctrl-F:

3. Type the syntax highlighting information:

4. The resulted text is:

Extending the toolbar is quite easy, only the wp-includes/js/quicktags.js file should be slightly modified (you can download the fully modified version from here, all the modifications are commented). To add a new button to the toolbar you should add the following code:

127
128
129
130
131
132
133

After then we should modify the edInsertTag function, and we are ready:

297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413

Controlling the indentation

The WP-Syntax plugin uses GeSHi with default settings, which means that GeSHi wraps code blocks in pre tags. In this mode GeSHi doesn’t replace TAB characters with spaces, so we can’t control the appearance of the indentation. But if we instruct GeSHi to use div tags instead of pre, it will replace leading TAB characters to spaces, and you can set the number of spaces. If we want to use 4 spaces we should modify the plugin accordingly to the following:

79
80
81
82

After this modification you should probably modify your CSS. I use now the following code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

I think these modifications would be interesting in the official WordPress version too, I found them useful, now I can insert source code to the post in a very convenient way.

Code Assist

While in PHP you can not specify the type of the function’s return variable, if you use a factory to instantiate a class, the editor has no information about the type of the variable, so the code assist won’t work. Fortunately you can help the editor to find out the type of the variable by specifying it as meta data. You have two options to achieve this:

• Function’s DocBlock comment:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  /** * @return Foo */ function getFooInstance() {     return new Foo(); } class Foo {     function baz() {     } } $foo = getFooInstance(); $foo-> // baz will apear in the selection list

• Class type hint:

  1 2 3

  $foo = getFooInstance(); /* @var $foo Foo */ $foo-> // baz will apear in the selection list

NEON supports code assist at include statements too.

Code Formatter

At last NEON has a great code formatter functionality. You can fully customize (even on project basis) how your code should be appear. You can set it up suitably to your own coding standards, and then any time you press Ctrl+Shift+F, NEON will render the code according to it. It could be very handy, if you have to edit or copy-paste third party code.

Debugging

NEON has great debugging capabilities with a full featured debugger. You have all the possibilities like in PDT, but NEON could install a toolbar to your browser, with which you can start easily debugging your application. If you are familiar with Zend Studio you know this could be very useful, for example before posting a form you can set “debug next page”. Unfortunately NEON currently not supports XDebug only Zend Debugger.

More wizards

NEON supports more wizards for creating new PHP elements: class, interface, unit test, unit test case, and has built-in support creating Zend Framework related elements (controller, view, model etc.).

Refactoring

Refactoring a PHP application was earlier a tedious task, in PHPEclipse or PDT you could only rename local variables. NEON has some new refactoring possibilities. You can rename, move your PHP files, and all the references for them will be automatically updated. It can help you organizing include files, for example it can collect possibly unused include statement and you can easily remove theme, or it can offer missing include statements.

You can also rename all PHP elements: classes, interfaces, functions, methods, and the references for theme will be updated too. You have the possibility to preview these updates. With these functions refactoring will be more easier, maybe more PHP developers will pay attention to this very important area.

Profiling

With NEON you can profile your application very easily. After profiling you can see overall information, detailed information about the running time of different files, execution statistics, execution flow.

NEON can provide code coverage information too, which can be very useful, when you try to find out how to organize your files (if some parts of your code need almost every time, it could be a good idea to put them in to one file, this way you can save some includes).

Unit testing

NEON supports generating unit test skeletons. You should choose the file with the class you want to test, and NEON generates a unit test for the given class. In the generated test class there will be an empty test method for all the public methods of the tested class, you should only fill theme.

NEON can run your tests and generates a visual report from theme, and additionally provide detailed code coverage information which could be very-very useful. NEON supports the PHPUnit developed by Sebastian Bergmann

Code analyzer

NEON can analyze your code and can find problematic parts (for example unreachable code). It can help developers to use good coding practices by giving theme suggestions about their code. This could be very useful even if you are an experienced developer: you can see immediately if you misspelled a variable name, or you left a global keyword (okey I know, you never use this latter ).

Settings

NEON provide more settings than PDT, you can set up for example the coding standards related to your project, and a lot more other things related to the lot of features.

I think Eclipse is in default a very good developer tool, so it was a good decision from Zend to build the next generation PHP IDE on top of it (consider that Eclipse has a great plug in architecture). NEON is already a very powerful tool, Zend did a great job about it, and I believe there are a lot of potential in it too.