This is not terribly helpful, since there are only three lines from the actual source code. Everything else refers to Groovy’s internals. From now on, though, reading Groovy stack traces will be much easier:

1. Easier Navigation

• You can navigate to “Dependency usages” from “dependencyManagement” of your parent pom.xml:
  and back:
  
• You can navigate through projects tree

2. Smarter Paths
‘Path reference’ notion were added to the editor to enhance the code completion, usages search and rename refactoring of project paths.

3. More intelligent plugins configuration
IntelliJ IDEA analyses plugin parameter types and adds smart value editors for plugin configuration tags.

You feedback is as always highly appreciated.

IntelliJ IDEA actually runs live template inside to complete the code generation

Let us know what you think about.

Grab the latest EAP of IntelliJ IDEA 9.0.2 to try it today.

If you are a plugin writer, you can provide your specific context parameters through the special com.intellij.javaee.model.xml.converters.ContextParamsProvider extention point.

To use it, you have to install Zen Coding plugin for Web IDE/IntelliJ IDEA: go to Zen Coding Project Download Page, download an archive that contains a set of live templates, and extract it to “<Your Home Directory>\.IntelliJIdea90\config\templates” folder (”~/Library/Preferences/IntelliJIDEA90/templates” for Mac OS X).

• Zen Coding plugin involves more than 200 different HTML and CSS live templates. To see all of them, just open Settings (Ctrl+Alt+S), Live Templates, Zen Coding group.

• Native Zen Coding support allows you to generate HTML structures using complex templates. For example, try to type “form.form-comment#comment>fieldset” in an HTML file and then press TAB. In this case, “form” and “fieldset“ are live templates but you can use simple tag names instead.

• You can generate not only HTML but also XML structures. Basic features perfectly work for XML.

• “TAG.CLASS” and “TAG#ID” templates allow you to specify class and id of HTML elements, but you can specify a value of any XML/HTML attribute, i.e. you can write “person[name=Jack]“.

• You can use your own live templates as parts of complex templates. For example, suppose you have a template “entry” with the following template text: To generate a list of entries, you just need to type “entry-list>entry[number=$]*5″ and press TAB. By default, the “number” attribute will be generated before “type”. If you want to customize the position where it’s generated, add ATTRS variable to your template – for example: ATTRS variable must have empty string as a default value and should be skipped:

• Of course, you can disable Zen Coding support if you don’t need it (see Settings (Ctrl+Alt+S), XML Zen Coding).

To learn more about Zen Coding features, you can watch screencasts on Zen Coding project home page.

Note that Zen Coding native support is a part of IDEA Community Edition, and its source code is freely available.

• Database Console now has its own toolwindow
• New console-like UI that keeps input and output in one place and retains the highlighting for execution history
• Keyboard shortcuts for all Console actions are now configurable
• Per-result Page Up, Page Down and Refresh actions
• Complete support for In-Memory Databases (try running some DDL in Console then click Refresh Tables and all the tables will be loaded in the Data Sources tree)
• Improved support for heavy JDBC drivers that use native libraries to run
• The notion of Database Connection allows IntelliJ IDEA to do some cool stuff such as Quick Table Contents Lookup integrated with Quick Documentation Lookup (Ctrl+Q)

The Hibernate Console has also been improved accordingly (separate toolwindow, console-like UI and per-result paging actions).

Try all this in the latest EAP and let us know what you think.

UPD: In the next EAP SQL scripts can be run directly from Project View or Editor via Run SQL Script (Ctrl+Shift+F10).

You can try this right now in the latest EAP.

To enable this feature go to Settings (Ctrl+Alt+S), Compiler node and then Flex Compiler page:

Let’s have a closer look at this feature.

Flex Compiler Shell (fcsh) is good for small projects, and may be useful in large projects as well, when you need to compile only some of the modules (facets). Fcsh process is kept in memory between compilations, so it is able to quickly recompile only changed piece of code (that is called incremental compilation), but in case of large projects fcsh runs out of memory, then IntelliJ IDEA restarts it automatically, but incremental compilation data is lost.

Mxmlc/compc processes are not kept in memory between compilations, but simultaneous running of independent compilations gives a good performance gain. IntelliJ IDEA automatically finds independent compilations based on module-on-module dependencies, configured in Project Structure (Ctrl+Alt+Shifl+S), Modules node, Dependencies tab.

Whatever tool you’re using, IntelliJ IDEA keeps track of modules where nothing was changed since previous compilation and skips compilation of up-to-date swf/swc files.

In conclusion, here are different ways of compilation in IntelliJ IDEA (applicable for Flex as well as for other programming languages):

• Make Project (Ctrl+F9): compile all modules incrementally (if possible), do not compile up-to-date modules
• Rebuild Project on the Build menu: force full non-incremental compilation of all modules
• Make Module (in popup menu of module root in Project View): compile selected module and all modules it depends on incrementally (if possible), do not compile up-to-date modules
• Compile Module (Ctrl+Shift+F9) (in popup menu of module root in Project View): force non-incremental compilation of selected module only, it’s dependencies are not compiled

To start using this feature, invoke Show History action for any file, then select revision you’d like to investigate, and then click UML icon (or press Control+Shift+D).

This opens the following diff dialog:

As you can see, 3 changes are made in layout.properties, Rounded interface and RoundedButton class. By default, green color marks what was added, blue is for changed, and gray, guess what — deleted. Well, what else can we see here? RoundedButton class doesn’t extend JComponent and does not implement ButtonModel interface anymore, but instead it extends AbstractButton class and implements MouseListener and KeyListener interfaces. Also, author has changed method paint and removed method isPressed. Interface Rounded was added from scratch and some properties were modified, added and removed in layout.properties file. Double click on a node shows standard diff dialog.

You will be able to enjoy this UML-like Diff Tool in next EAPs and also in the nearest IntelliJ IDEA 9 update.