LiClipse 11: newer PyDev and on to new Eclipse base (4.30)

 LiClipse 11 is now out and includes the newer version of PyDev, which has a whole new debugging mode using sys.monitoring (which translates to a much faster debugging experience overall -- see: https://pydev.blogspot.com/2024/02/pydev-debugger-and-sysmonitoring-pep.html for more details).

Also, it is now based on Eclipse 4.30 -- this time it was actually quite tricky as there are some internal changes to Eclipse itself which had to be changed in a bunch of places (the @Inject is now from jakarta instead of javax and the orbit aggregation site changed).

One pretty important note I haven't commented before is that now LiClipse is signed on Mac OS too (not just Windows). 

Unfortunately Eclipse suffers a bit from that because after signing it's expected that nothing inside the .app will change. This means that quite some work was done so that .pyc files are not created inside the app anymore and nothing changes there -- unfortunately at this points additional plugins on top of LiClipse can not be installed when using Mac OS (I'm still researching on alternative approaches here).

On a separate note, it's been quite a while since I haven't posted about LiClipse itself... I guess this boils down to the fact that most of the work ends up happening on PyDev or LiClipseText directly -- but rest assured that work is indeed happening here 😉!

LiClipse 7.1.0 released (improved Dark theme, LiClipseText and PyDev updates)

I'm happy to announce that LiClipse 7.1.0 is now available for download.

LiClipse is now based on Eclipse 4.17 (2020-09), one really nice features is that this now enables dark-scrollbars for trees on Windows.

I think an image may be worth a thousand words here, so below is a screenshot showing how the LiClipse Dark theme looks like (on Windows) with the changes!

This release also updates PyDev to 8.1.0, which provides support for Python 3.9 as well as quick-fixes to convert strings to f-strings, among many other things (see: https://pydev.blogspot.com/2020/12/pydev-810-released-python-39-code.html for more details).

Another upgraded dependency is LiClipseText 2.2.0, which now provides grammars to support TypeScript, RobotFramework and JSON by default.

LiClipse 6.0.0 released

LiClipse 6.0.0 is now out.

The main changes is that many dependencies have been updated:

- it's now based on Eclipse 4.13 (2019-09), which is a pretty nice upgrade (in my day-to-day use I find it appears smoother than previous versions, although I know this sounds pretty subjective).

- PyDev was updated to 7.4.0, so, Python 3.8 (which was just released) is now already supported.

Enjoy!

LiClipse 5.2.2 released

This version does an updated of the main dependencies of LiClipse.

It's now based on:

• Eclipse 4.11 (also named 2019-03)
• PyDev (5.2.2) 
• EGit (5.3.0)

As a note, it seems I haven't updated this blog as often as I should (I end up putting more effort into announcing the PyDev updates) but just to note, LiClipse is always updated whenever PyDev is updated.

Enjoy!

LiClipse 4.5.2 released

LiClipse 4.5.2 is now out.

The major updates are related  to the upgrade of dependencies (such as PyDev and EGit).

On the PyDev front, the major change is initial support for getting type information from .pyi files and a critical fix for the creation of the preferences page.

For EGit, https://wiki.eclipse.org/EGit/New_and_Noteworthy/4.11 has more details!

Enjoy!

Macro keyboard recording on Eclipse / LiClipse 4.3.1

I'm currently working on a new engine for record and playback of keyboard macros in Eclipse. It's currently available as a project in the Eclipse incubation (see https://wiki.eclipse.org/E4/Macros for more details and how to install it to Eclipse) and I hope it'll be a part of Eclipse 4.8 -- the current version should be stable already, but it needs some hardening, so, feedback is appreciated ;)

Also, I decided to integrate it into LiClipse too (so, the new 4.3.1 release of LiClipse adds support to record and playback of macros).

The idea is that this will fix a long standing (and popular) feature request in Eclipse -- https://bugs.eclipse.org/bugs/show_bug.cgi?id=8519 -- and a pet peeve on mine too as it's not uncommon for me to copy a file to notepad++ to make a record/playback and then copy it back to Eclipse... this really should be builtin (as a note, the rectangular edition in Eclipse, multiple cursors in LiClipse  and regexps in the find dialog do solve a number of use-cases, but I find that record/playback on some cases is invaluable).

Now, why not just use https://sourceforge.net/projects/practicalmacro/? Well, I've used it some times but unfortunately I didn't find it as stable as I wanted -- it's really hard to come up with a stable record of what's happening in Eclipse -- so, I think an effective solution must really be builtin to Eclipse in order to be effective.

Also, in order to be feasible, there are some limitations in the scope on what it should accomplish: it's not a general Eclipse IDE record/playback, but rather a record/playback in the scope of an editor, so, it should properly record/playback the keystrokes in the editor and the resulting actions from such commands (although the implementation is done in a way which could support more general recording in Eclipse, but this would require changing many other parts of the IDE to be aware of the macro record/playback, so, I'm not sure it'd be feasible).

This means that some particular implementations which don't work through commands will have to be adapted -- so, for instance, record in the find dialog currently doesn't work because it doesn't work through commands and there's no way to listen that a find action was actually triggered from there... right now, the workaround is using the Incremental Find (Ctrl+J) and Find Next (Ctrl+K) commands when on record mode (my idea is taking a look at it after the macro record/playback engine is integrated to core Eclipse as I don't think it's a blocker due to having a proper workaround through actual commands), the focus now is making it solid for record and playback of commands which are related to the text editor.

So, that's it, hope you enjoy macro recording on LiClipse 4.3.1 -- and hopefully on Eclipse itself later on ;)

LiClipse 4.1.1 / LiClipseText 2.0.0

Ok, the new versions of LiClipse (4.1.1) and LiClipseText (2.0.0) are now out.

This version had many changes, the major one being that LiClipseText now reuses the same engine that tm4e uses for parsing code when based on a TextMate grammar (which is is a translation from the same engine used in VSCode), so, hopefully this should iron out most issues when dealing with TextMate grammars.

Also, it can now parse in a thread to prevent the UI from becoming unresponsive (although it'll only really do that if there are too many changes for it to parse).

There were also improvements in the definition being used for JavaScript, so, parsing should be *much* faster (although this was done at the expense of not showing some entries in the outline) -- but as on JavaScript having huge files isn't uncommon, the big performance gain, should be worth it.

Aside from that, the standalone is now based on Eclipse 4.7 (final) and PyDev was also updated for 5.9.2, which brought enhancements such as the new debugging approach using bytecode modification with the new Python 3.6 hooks and isort integration, besides a critical fix to the Lucene integration, which affected users which used a different plugin which also used Lucene but on a different version.

So, if you're a LiClipse user, hurry to http://www.liclipse.com/download.html to get the new version!

LiClipse 4.0 released

LiClipse 4.0 is now available for download!

This is the first release based on Eclipse Oxygen (built on 4.7 RC3). It's still not a final release, but very close to it, so, make sure you take a look at https://www.eclipse.org/eclipse/news/4.7/platform.php for the latest news in the platform (the gem for me is now being able to hide the status bar -- personally, I'm now using Eclipse without the toolbar nor status bar -- really nice for a minimalist theme).

There was a critical fix for users on Mac OS which resulted in LiClipse not working properly after an update. Note that for Mac users which are using LiClipse 3.x, a fresh install is needed (follow the instructions from http://www.liclipse.com/download.html#updating_native).

The other major changes in this release are actually in PyDev, which featured a fix which prevented the code-coverage from working properly and now supports code coverage when testing with pytest. Also, IronPython is supported again in the debugger (it was previously broken because IronPython didn't support sys._current_frames (although an important note is that IronPython 2.7.6 and 2.7.7 don't work with PyDev because of a critical issue in IronPython, so, either keep to IronPython 2.7.5 or use the development version).

There were also fixes in the PyLint integration, updating docstrings, finding __init__ on code-completion when it's resolved to a superclass, etc... See: http://www.pydev.org for more details.

Enjoy!

LiClipse 3.2.1

The new LiClipse release is out.

The major updates were actually to PyDev, which has fixes such as a regression added on 5.3.0 where Ctrl+1 was not properly resolving symbols from dependent projects, code analysis on a particular case with PEP 448 (list unpacking), auto-indents async and await blocks, highlights async and await blocks and fixes an issue in the code completion using from..import..as aliases.

It does have one new feature in which Ctrl+Shift+O (which fixes unresolved tokens by adding the needed imports) uses the improved sorting also used for the code-completion (so that tokens from the project appear before tokens from other projects, which in turn appear before tokens from the standard library). Also, the substring completion is now on by default (it may be turned off in the code-completion preferences).

Still, besides the updates to PyDev, the stock LiClipse themes were improved so that the current selected tab colors (on the active or inactive views) can be configured (selectedTabInitialBackground and selectedTabActiveInitialBackground in the theme preferences) and some colors were changed to have better defaults in a number of themes.

LiClipse 3.1.0 (updating dependencies)

LiClipse 3.1.0 was just released.

The major changes aren't really on LiClipse itself, but on the bundled PyDev (5.2.0) and EGit (4.4.0) plugins.

PyDev changes may be seen at http://pydev.blogspot.com.br/2016/08/pydev-520-released-static-type.html.

EGit changes may be seen at https://wiki.eclipse.org/EGit/New_and_Noteworthy.

Enjoy!

LiClipse 3.0.3 (providing back to Open Source: multiple languages/TextMate bundles in Eclipse).

LiClipse 3.0.3 is now released... The main things on LiClipse itself is that the base platform was upgraded to Eclipse 4.6 RC1 and EGit was upgraded (it had a critical issue in the Git Staging View).

Now, what I really wanted to talk about is that with this release, the LiClipse editor component was open sourced!

The editor component in this case is the component which allows LiClipse to support multiple languages out of the box (either through its own language or through the TextMate grammar).

So, the features which are now available as Open Source (EPL) are:

• Syntax Highlighting (LiClipse, TextMate or SublimeText based).
• Code completion.
• Outline view and Quick Outline.
• Text-based mark occurrences.
• LiClipse Languages view:
• Enables exploring installed languages.
• LiClipse Partitions view:
• Enables inspecting the partitioning of the editor.
• Useful to debug how LiClipseText is parsing a language.
• Use LiClipseText as a base for other editors:
• Languages may be created and experimented with on-the-fly, without restarting Eclipse.

The home page with more details on the project is: http://liclipse.com/text.

So, what does this mean for LiClipse itself and its current users?

First, LiClipse (the commercial counterpart) still exists and provides advanced features not in LiClipseText:

• Bundling of LiClipseText (along with PyDev, EGit, ColorTheme, AnyEdit and StartExplorer) as a standalone with native installers.
• Enhancements to the theming (allowing theming of the IDE along with the editor and a nice dark theme).
• Multiple cursors.
• Linting for JavaScript, XML and HTML editors.
• Code formatting for HTML, XML.
• Vertical Indent Guides.
• Improved text search capabilities (with Lucene index-based searching, support for external folders, open editors and additional filtering on results page).
• HTML preview for the RST, Markdown and HTML editors.
• Debugging of Django Templates in PyDev.
• Launching of files opened with LiClipseText.

My hope is that users that can will still upgrade to it (to get the advanced features and to help in keeping the LiClipseText and PyDev development going on) or will donate to keep its development going forward...

And the main benefit here (both for existing users or new users) is that the LiClipse editor (LiClipseText) being EPL makes it hackable by anyone ;)

LiClipse 3.0.1: Java 8 now required (JSHint and Beautify.js using Nashorn JavaScript engine)

LiClipse 3.0.1 is now available for download.

There are 2 major changes in this release: it's now based on Eclipse 4.6 M7 and requires Java 8 to run.

I find Eclipse 4.6 M7 a big improvement over 4.5 already (for me, the major improvements are that the default dark theme improved and it's speedier, but there are many other improvements -- you can see those starting at https://www.eclipse.org/eclipse/news/4.6/M7 -- and going back up to M1).

The Java 8 requirement also brought a nice improvement for running JSHint: the Nashorn JavaScript engine which is now used to run it (it's much faster than Rhino, so, big JavaScript documents should no longer make LiClipse stall due to the JSHint code-analysis) -- unfortunately it's not currently officially supported (https://github.com/jshint/jshint/issues/2730), so, a modified version was used to run in it in LiClipse.

This release also removed the builtin support for the trees/tables custom scrollbars (I hope to restore that later on... still, currently, it's possible to restore it's behavior by installing the Xiliary plugin from http://fappel.github.io/xiliary/clean-sheet.html and enabling the related setting at at General > Appearance > Color Theme).

Also, EGit (which now handles pre-commit hooks properly) and PyDev (which now keeps the state of the PyUnit view across restarts) were updated.

As a note, users which have a license for LiClipse 2.x need to renew the license to use LiClipse 3.x (users that bought it within the last month are eligible for a free upgrade).

Fully themed scrollbars in Eclipse (Trees, Tables, StyledText) in LiClipse 2.5.2

Ok, LiClipse 2.5.2 is out and it adds support for theming the scrollbars for Trees and Tables by using the Xiliary swt libraries, in addition to the support which was already built in, which allowed StyledTexts to be themed in LiClipse.

Below is a snapshot of LiClipse 2.5.2, in Windows using the LiClipse Dark theme with scrollbars visible for all the elements shown -- enough said ;)

LiClipse 2.5.1 (TextMate bundle fixes and faster Python debugging)

LiClipse 2.5.1 added support to proper commenting (Ctrl+/) on TextMate based languages. Also, syntax highlighting support had some fixes done, which fixed some issues in the Ruby syntax highlighting.

Also, this version updated PyDev to 4.5.1, which brings a much faster debugger to the table and an update to the latest EGit.

See http://liclipse.com for more information on LiClipse and http://pydev.org for PyDev.

LiClipse 2.4.0 (Critical fix for TextMate bundles and PyDev update)

The latest LiClipse (2.4.0) is now available to download.

The major fix was in the integration with TextMate bundles, which was applying some indent rules when the user didn't really add a new line.

Also, this version adds support for RAML (http://raml.org/).

Besides that, the bundled PyDev was upgraded to the latest version, which had some nice improvements such as improved ansi colors in the interactive console, more information when all elements were filtered out in the PyDev Package Explorer, code completion improvements, etc.

See http://liclipse.com for more information on LiClipse and http://pydev.org for PyDev.

Improved TextMate bundles integration and instant searches on Eclipse (LiClipse 2.3.0)

Yeap, LiClipse 2.3.0 is out now.

The main change in this release was a restructuring on how the parsing works...

This deserves some better explanation: in Eclipse, the default parsing structure is done by separating a document in many top-level partitions and later on those partitions are scanned to give syntax highlighting.

The issue here is that in LiClipse when parsing with TextMate rules, a single parse will provide all the information at once (top-level partitions and internal scopes in the partition), so, the code was restructured so that a single parse is done and the information is properly saved to be accessed later on, so, a single parse will provide the partitions, colors, outline, etc.

This means that LiClipse became even more responsive, especially when dealing with TextMate rules and the scope information is available to better support TextMate snippets for code-completion.

Also, the searching structure created on LiClipse 2.2.0 was ironed out (and its really pleasant getting instant searches even on big codebases).

Enjoy!

Improved search capabilities on Eclipse (LiClipse 2.2.0)

LiClipse 2.2.0 (just released) introduces improved search capabilities for Eclipse.

This is done by leveraging Lucene for indexing the files searched -- it's interesting to note that the index is built (and checked for consistency) on-the-fly when a text search is requested, which means that the indexing won't add any overhead on the build process (although that means that the first time some scope is searched it may take a bit more time to build the indexes -- but still comparable to a regular text search on Eclipse -- and subsequent calls are nearly instant).

The image below shows the search dialog (activated through Ctrl + H), where it's possible to select what/where to search. The path(s) and project(s) are updated when a search is requested based on the current selection.

The search results page also offers additional flexibility, which allows grouping the matches in different ways -- they can be flattened, grouped by project, folder or files -- and filtering the results based on the paths (multiple terms may be comma-separated and "!" can be used in the beginning of the term to exclude matches).

Also, this release adds support out of the box for Linux Shell files, Windows bat files, PERL and Swift (through TextMate bundles), so, 27 languages are available out of the box now (View supported languages).

Eclipse and TextMate bundles support (LiClipse 2.1 released)

LiClipse 2.1 now marks a significant milestone as it enables users to have syntax highlighting for almost any language available (that is, any language which has a related TextMate bundle can now be used in LiClipse/Eclipse).

The major portion of this update is related to syntax highlighting support and snippets (if the snippet matches the top-level grammar scope... future releases should improve on that so that it recognizes the more 'elaborate' scope selectors from TextMate).

Installing a bundle should be pretty simple (mostly put a zipped file with a '.tmbundle' extension in a tracked folder... http://www.liclipse.com/textmate_bundles.html has more details).

New languages supported out of the box now include PHP, Ruby and Markdown (through TextMate bundles).

Also, the LiClipse standalone is now based on 4.5 (actually 4.5rc2a), so, it's text search is much faster and its dark theme has nice improvements too (in both flavors: Eclipse 4 theme / LiClipse theme).

Enjoy ;)

LiClipse 2.0 released (Nim, Go and Jinja2 supported!)

LiClipse just turned 2.0 -- along with PyDev 4.0 :)

The main highlights for this release are: Nim, Go and Jinja2 are now supported.

Multi-page editors (such as the plugins manifest editor) now also have multiple cursors and vertical indent guides support.

The JavaScript editor had improvements in the syntax highlighting and its code-formatting settings can now be tweaked (http://www.liclipse.com/customize_javascript.html has more details).

Different jshint.js and beautify.js files may be specified in preferences > LiClipse > JavaScript.

From this release onwards, besides providing standalone binaries and a downloadable update site, LiClipse provides an actual online update site: http://update.liclipse.com/latest -- note that I still recommend users to use the standalone as it's easier to get started and it also provides updates to the underlying eclipse SDK, but the update site is now available if you have a working Eclipse version which you don't want to change.

This was also the first time where I transferred some technology from LiClipse to Eclipse (to make improvements so that the trees in the dark theme in Eclipse on Windows actually have arrows you can work with: https://bugs.eclipse.org/bugs/show_bug.cgi?id=434201 -- and hopefully I'll still be able to make time to integrate another one to improve the selections on trees/tables for the next Eclipse release: https://bugs.eclipse.org/bugs/show_bug.cgi?id=434309).

A note for existing users: a renew license currently has a 50% discount over the price of a full license http://www.liclipse.com/buy.html -- thank you for helping in keeping LiClipse going strong!

LiClipse 1.4.0: Themed scrollbars for StyledText!

LiClipse 1.4.0 has just been released.

The major feature in this release is that scrollbars for StyledText editors are now themed by default, as the image below shows:

Besides this, the default encoding for the files/workspace is now UTF-8 (regardless of the OS being used).

PyDev, which was also updated to the latest version, now features an interactive console prompt along with the console view where the scrollbar theming makes things much smoother: