Changes between Counterclockwise 0.25.2 and 0.26.0

0.26.0 released on May xx, 2014

Enhancements

New Clojure Wizard

The wizard now accepts lein new template arguments. Simply put them after the template name.

Bug fixes

  • New Clojure namespace wizard now works with fully qualified namespaces, pre-fills the input text with the currently selected package name and creates missing packages on the fly. Fix Issue #468

  • New Clojure namespace wizard now accepts file starting with numbers. Fix Issue #466

  • Correct indenting of new threading macros, as→ cond→ some→. Fix Issue #554

  • F3 Navigate to Definition was not working for single segment namespaces. Fix Issue #572 (Thanks isto.nikula for the patch!)

  • Upgraded missing dependency on ccw.server 0.1.1 which is where the fix for Code Completion not succeeding sometimes is located!

  • REPL View: Better handling of cursor movement in output area of REPL. Fix Issue #529

  • You can use arrow keys, copy keys in the REPL output area

  • You can use Tab key to switch to the REPL input area

  • REPL View accepts the Drawbridge protocol, thus allowing http(s)://<server>:<port>/repl or http(s)://<user>:<password>@<server>:<port>/repl URLs. Fix Issue #501

  • Outline View: There were unexpected exceptions thrown depending on the content of the Editor. These were due to java.lang.Comparator contract violations. Fix Issue #639

  • Editor: In strict/paredit mode, forward/backward delete do not prevent to remove # in front of () or {} or "". Also, fixed a bug where forward delete allowed to remove ( or { or " if there was a leading #. Fix Issue #523

  • Also changed a behavior: the cursor is not stuck, either something is deleted, either the cursors moves forward or backward

Changes between Counterclockwise 0.25.1 and 0.25.2

0.25.2 released on May 17, 2014

Bug fixes

  • Upgraded dependency on ccw.server 0.1.1 which is where the fix for Code Completion not succeeding sometimes is located!

Changes between Counterclockwise 0.25.0 and 0.25.1

0.25.1 released on May 17, 2014

Explicitly running leiningen headless

When Preference Clojure > General > Launch Leiningen projects with Leiningen is unchecked, then Run as for the project will use the Eclipse Project Settings, not the Leiningen project settings. And Leiningen will not be used to launch the project.
But still, users have reported that there is a need for a command for explicitly launching the project via Leiningen.

Thus the "Headless Leiningen REPL" command has been resurrected. You can find it in the Leiningen contextual menu, or invoke it via the Alt+L H Keyboard Shortcut.

Bug fixes

  • Error on load file in REPL, due to spaces in path introduced in 0.25.0. Thank you alzadude for the Pull Request!

  • Project wizard issue if you (only) unselect the default location checkbox. Fix Issue #637

  • Code Completion would not succeed sometimes and NullPointerExceptions would be logged instead. Fix Issue #631

Changes between Counterclockwise 0.24.2 and 0.25.0

0.25.0 released on April 25, 2014

Counterclockwise now uses Clojure 1.6.0 internally instead of 1.6.0-alpha3 before.

Launch startup time

The launch startup time of leiningen projects has been slightly improved by using more appropriate JVM flags (inspired by the ones used by the leiningen shell script).

Bug fixes

AOT Compilation very slow, and / or freezing the UI

There was kind of an incompatibility between CCW and Leiningen. In short, CCW uses the :injections project key to inject nrepl server code, and this code is also injected by leiningen when AOT compiling in subprocesses. The server code was creating futures, thus preventing the AOT compilation process to shutdown in due time.

The problem of UI freeze has also been globally addressed by improving the launcher code.

Console View stealing focus from REPL View

With the new Leiningen Launcher, the Console View was systematically stealing focus from the REPL View, because it was (deterministically) outputting the REPL server port after the REPL View was started and focused on.

This improper behavior was a consequence of the use of an acknowledgement socket between the nrepl server and the nrepl client. Leiningen gets the nrepl port after the acknowledgement has been done by the nrepl server library. So it cannot be changed to output the nrepl port before nrepl sends it back via the acknowledgement socket.

The solution which has been retained is to stop using acknowledgement sockets for getting the repl port back.
From now on, CCW relies on Leiningen outputting the nrepl port on its stdout (using the nRepl URL format).

To remain compatible with this behavior (and simplify the code internally), the regular Clojure launcher has been enhanced to also output the nrepl URL to stdout.

The console stack trace hyperlinks where wrong if the namespace was separate in several files loaded from the main namespace file. Fix Issue 634 - Clicking links in stacktraces bring you to the file of the namespace, not the file with the code causing the crash

Bad interaction between Counterclockwise and Maven m2e plugin

Counterclockwise Automatic detection of Clojure projects and Maven m2e Update Maven projects on startup preferences do not play well when both set to true. Counterclockwise code has been carefully audited and updated to prevent IResource locks, but the problem remains anyway. It is strongly suggested to not use m2e Update Maven projects on startup. Fixes Issue #633

Changes between Counterclockwise 0.24.1 and 0.24.2

0.24.2 released on April 11, 2014

Bug fixes

Namespace code being loaded twice at startup

When CCW launches a REPL for a Leiningen project, it uses lein repl :headless. This leiningen task will, by default, try to load the namespace declared via the `[:main]`path in project.clj map (if no other namespace has been explicitly defined by the user via the `[:repl-options :init-ns] path). This magical side-effect is undesirable as default behavior, and can cause the namespace code to be loaded twice if the REPL is invoked via its source code editor. This can be problematic for certain codebases.

CCW fixes this by dissocing the :main key in the project.clj map used to start the nrepl :headless server.

Enhancements

Preference for controlling run/debug default launch mode

Since version 0.24.0, commands indirectly loading a REPL automatically (e.g. invoking load file in Clojure REPL when there is no active REPL) invoke the launcher in Debug mode (allowing to put breakpoints in the code for instance).

This behavior can be changed globally via a new preference: Clojure > General > Launch REPLs in Debug mode (thus checked by default)

Preference for allowing Leiningen projects to be launched as regular java projects

Preference Clojure > General > Launch Leiningen projects with Leiningen (uncheck to launch them via default java launcher) has been added.

By default, Leiningen projects will be launched by invoking leiningen repl :headless. By unchecking this preference, Leiningen projects will be launched as would regular java projects detected as Clojure project (the behavior before 0.24.0).

Motivation: some users have reported real blocking issues which cannot be addressed in this release:

  • Eclipse crashes under some circumstances (will be addressed soon)

  • Leiningen launcher way longer to start than default java launcher, and for projects requiring repeated restarts, this is a no-no. This second point may be addressed by leveraging the trampoline behavior of Leiningen.

When both of these issues are addressed, removing this Preference from the GUI may be considered.

Changes between Counterclockwise 0.24.0 and 0.24.1

0.24.1 released on March 30, 2014

Bug Fix: The System environment was not correctly passed to the launched project process, causing all sorts of trouble (X Window session not found, java.io.tmpdir not set correctly, etc.)

Changes between Counterclockwise 0.23.0 and 0.24.0

0.24.0 released on March 20, 2014

REPL launcher revisited

The command "Headless Leiningen REPL" introduced in a recent release works well, so it has been set as the default behaviour for starting a new REPL for Leiningen projects.

This means that for Leiningen projects, Ctrl+Alt S (resp. Cmd+Alt S for OSX), or Run/Debug as Clojure Application will truly use Leiningen under the hood to start a headless REPL for the project.

Also now by default, keyboard shortcut Ctrl+Alt S starts the project in debug mode and automatically connects Eclipse to the projects JVM debugger.

Generic Leiningen Launcher

  • Ensure all JVMs created by Leiningen are killed when the main process is killed via the Console "Terminate" button.

  • "Headless Leiningen REPL" command Alt+L H has been removed now that it is the default behaviour for starting Leiningen projects

Counterclockwise/Standalone

  • For Linux/Windows, the zip now contains a root folder named Counterclockwise-<version>

  • For OS X, the zip now contains a root folder named Counterclockwise-<version>.app ; it is thus recognized as an OS X Application folder

Changes between Counterclockwise 0.22.0 and 0.23.0

0.23.0 released on January 23, 2014

Fixes the compatibility problems with Eclipse Indigo!

Counterclockwise/Standalone

  • It is now possible to use the usual Software Update Site to upgrade a Counterclockwise/Standalone install with new versions of Counterclockwise.

  • The version is now displayed in the Counterclockwise About Dialog.

  • The Products zips filenames now contain the version

Documentation

Installation section

  • now mentions the Counterclockwise version number (in the text, and the corresponding links)

Changes between Counterclockwise 0.21.0 and 0.22.0

0.22.0 released on January 10, 2014

Leiningen Upgrade

The embedded Leiningen has been upgraded from version 2.1.2 to a patched 2.3.4.

Automatic opening of REPL Views

The patch applied to Leiningen 2.3.4 relates to the lein repl task: in addition to displaying a human readable info about the nREPL server’s port & host, it appends a nREPL URL.

Before:

nREPL server started on port 61149 on host 127.0.0.1

After:

nREPL server started on port 61149 on host 127.0.0.1 - nrepl://127.0.0.1:61149

This nREPL URL is automatically converted to an hyperlink in the Console View.
And even more: the first time a nREPL link appears in a Console View, Counterclockwise automatically opens a REPL View for it!

Shortcut for starting a Headless Leiningen REPL

Alt+L H is a shortcut for launching a headless leiningen REPL. It is similar to doing Alt+L L + typing your-project $ lein repl :headless.

Shortcut for resetting the Project Classpath

Alt+L R resets the project classpath, using Leiningen to compute the classpath.

Leiningen classpath more permissive

Resolving leiningen classpath is now more permissive

Overlapping source paths are allowed

Overlapping :source-paths, :resource-paths, :test-paths and/or :java-source-paths are accepted. Counterclockwise resolves the conflict by adding the required exclusions to its source classpath entries.

For instance, if you have declared (explicitly or implicitly) both resources and resources/public as resource paths, Counterclockwise will create 2 source path entries:

  • one for resources/public,

  • and one for resources, with an exclusion filter for its public subfolder

Missing source paths are not reported as errors anymore

All paths are marked as optional so that if folders for these paths are missing, no exception is reported by Eclipse.

Changes between Counterclockwise 0.20.0 and 0.21.0

0.21.0 released on January 9, 2014

General purpose Leiningen task invoker

Addition of a new command, Alt+L L for launching a popup allowing to enter an arbitry leiningen command.

It allows you to launch arbitrary leiningen tasks from within Eclipse.

New Clojure Project Wizard

The Wizard has been modified to simplify the understanding of its fields. Especially, the "Use default location" field has been replaced with a "Create project folder in:" field, and its meaning has changed from "ask the user for the project’s folder on the filesystem" to "ask the user for the project’s parent folder on the filesystem (assuming that the project folder will be the project name)". This is wayyy more intuitive.

The "Working Sets" section of the Wizard has been removed. Instead, the newly created project is automatically added to the currently active Working Sets.

Editor responsiveness

Timeouts have been added for all Counterclockwise interactions with the nREPL connection of a REPL View.
Nothing should prevent the user to type in an Editor. Counterclockwise should gracefully downgrade its features instead. This is a step in this direction.

  • Code completion: 1 second timeout. If timeout occurs twice for a given REPL, it won’t be used anymore (only static code completion will take place).

  • Text Hover: 1 second timeout.

  • Hyperlink Detection: 1 second timeout.

  • Namespace Browser: 15 seconds timeout.

  • REPL: 15 seconds timeout at some initialization usage of the nrepl client

"Load File" in Editor

"Load File" action now works for editors opened via File ▸ Open File… (aka arbitrary file on the filesystem, not necessarily living inside a project inside the Eclipse Workspace)

User plugins

It is possible to contribute Counterclockwise User Plugins inside folder ~/.ccw.
This will be a way both: - for users to contribute / experiment more easily to Counterclockwise - for the Counterclockwise team to provide beta features for rapid user feedback

INFO: a User Plugin is dynamic. To remove it, just remove it.

A whole new section of the documentation has been added concerning User plugins. See http://doc.ccw-ide.org/documentation.html#_user_plugins for the full story.

Warning
Works only with Eclipse 4 and CCW/Standalone.

Experimental User Plugin: "Plugin additions"

This plugin adds commands for managing User Plugins (sorry, it’s a little bit meta):

  • Alt+U S - re[S]tart user plugins (will reload all user plugins code)

  • Alt+U N - create a [N]ew user plugin (will prompt you for a plugin name, create the plugin folder/file, a project in the workspace, and open a repl connection to your Eclipse instance)

  • Alt+U I - Import all user plugins present in ~/.ccw as projects in workspace

The plugin is available as a Gist, you can examine its content here https://gist.github.com/laurentpetit/7924786 and then clone its repository https://gist.github.com/7924786.git in ~/.ccw/plugin-additions

git clone https://gist.github.com/7924786.git ~/.ccw/plugin-additions
# Restart your Eclipse

nREPL Version Update

The embedded nREPL client in Counterclockwise, and which is also used to serve as nREPL client when the project does not declare a dependency on nREPL (the majority of the cases) has been upgraded from version 0.2.1 to 0.2.3.

Bug fix

  • Explicitly ask the user for confirmation before launching a second process for the same project

Leiningen based Launcher

The code is there, but not active at the moment (needs more love / hammock)

CCW/Standalone

Changed the URL for downloading the stable standalone versions: http://standalone.ccw-ide.org/

Increased the MaxPermSize value from 128Mb to 256Mb, since there has been reports that 128Mb weren’t enough, e.g. when invoking the New Clojure Project Wizard.

Fix of an issue with the pre-referenced software update sites (was still pointing to Indigo instead of Kepler)

Moar sensible default preferences:

  • Editors

    • line numbers displayed in the margin

    • 80 chars column displayed

    • tabs automatically replaced by spaces when typing

  • Worskpace

    • automatic refresh of the Workspace resources without asking the user

Changes between Counterclockwise 0.12.3 and 0.20.0

0.20.0 released on October 10, 2013

TL;DR

  • 0.20.0 introduces no breaking change

  • New Software Update Site http://updatesite.ccw-ide.org/stable

  • Editor: new awesome autoshift feature, slurp/barf paredit commands support

  • Lots of changes to fix stability concerns and various issues

Build Process totally rewritten

For people wanting to build Counterclockwise from scratch, or to work with Counterclockwise.

The Build Process now uses Maven + Tycho.

  • It is now fully automated, from fetching Eclipse or non Eclipse dependencies, to building an update site for the codebase, to building Standalone Counterclockwise products for the codebase.

In a nutshell:

git clone https://github.com/laurentpetit/ccw
cd ccw
mvn verify
cd ccw.product/target/products # the products for Windows / Linux / OS X
cd ../../../ccw.updatesite/target/repository # the Software Update Site

For more information on installing a full-fledged dev environment, see the Wiki Page How To Build

New Software Update Site

The software update site has been updated to its new location:

For more information on the available Software Update Sites and their retention policies, and more, see the Wiki Page Update Sites

Editor

Reindent Selection

Reindent Selection has been implemented. Trigger it via Ctrl+i on Windows/Linux, Cmd+i on OSX.

Autoshift

While you type, the code on the following lines which depends upon the code on the current line is shifted to the right or to the left. More spaces/less spaces are added/removed automatically.

  • For instance, if you have the following manually indented code (note that the call to the cond macro is indented 4 extra spaces to the right):

    (defn foo [bar baz]
           (cond
             cond1
               expr1
             cond2
               expr2
             :else
               default-expr))
  • You can fix the whole indentation by either placing the cursor anywhere in the (cond line and typing Tab, or in front of (cond and typing Backspace 2 times:

    (defn foo [bar baz]
      (cond
        cond1
          expr1
        cond2
          expr2
        :else
          default-expr))
  • Before the AutoShift feature, you would either have to indent each line manually, or select the whole (cond..) form and type Ctrl+i (OS X: Cmd+i), but you would have lost the specific indentation of the conditions/expressions:

    (defn foo [bar baz]
      (cond
        cond1
        expr1
        cond2
        expr2
        :else
        default-expr))

More intuitive Ctrl+Enter

Hitting Ctrl+Enter when the cursor is located at the top level selects the preceding top level form to be sent to the REPL. Only when the cursor is right in front of a top level form will it be selected instead of the previous one. (Fix Issue #580)

e.g. if the caret is materialized with the symbol |:

(defn foo [] ...)|
(defn bar [] ....)
;; => foo's declaration will be sent to the REPL
(defn baz [] ...)
|(defn qix [] ...)
;; => qix's declaration will be sent to the REPL

Slurp / Barf

Slurp and Barf, 2 important paredit/structural manipulation features, have been added to the Editor. (Fixes Issue #486: Add support for barfage and slurpage)

+ See the Keybindings documentation for Slurp / Barf : https://code.google.com/p/counterclockwise/wiki/EditorKeyBindingsFeatures

  • Fixed wrong keybinding for switching Rainbow Parens: "Cmd+( R" instead of "Cmd+(R" (replace Cmd by Ctrl for Windows/Linux ; space indicates that you first type Cmd(, then type R)

  • Changed "toggle line comments" behaviour: before, if the selection had both commented and uncommented lines, it was an ambiguous case resolved by just doing nothing. Now, it is resolved by counting the number of commented and uncommented lines. If the number of uncommented lines in the selection is equal or greater than the number of commented lines, then those uncommented lines are commented. If the number of commented lines is greater than the number of uncommented lines, those commented lines are uncommented.

    Calling "toggle lines comments" on the following code selection:

    ;(defn foo [....])
    (defn bar [....])
    (defn baz [....])

    will result in:

    ;(defn foo [....])
    ;(defn bar [....])
    ;(defn baz [....])

    But calling "toggle lines comments" on this code selection:

;(defn foo [....])
(defn bar [....])
;(defn baz [....])

+ will result in:

(defn foo [....])
(defn bar [....])
(defn baz [....])
  • Auto indentation of a cond form changed: (Fixes #592)

    ;; from
    (cond test1 expr1
      test2 expr2)
    ;; to
    (cond test1 expr1
          test2 expr2)
  • Experimental Feature: enabling auto-reevaluation of last command typed in the REPL, after a successful evaluation from the Editor

    • when the "repeat last expression" REPL command is active

    • when the user sends a form tom evaluate to the REPL

    • if the form evaluated without error

    • then the last expression evaluated from the REPL input is evaluated again

      A common usecase for this is while you’re defining a function in the Editor and you want to repeat the same test expression again and again until it passes. The workflow then becomes:

      • define the function in the editor, eval via Cmd+Enter

      • switch to the REPL, enter a test expression, send the test expression via Cmd+Enter

      • Click on the "Repeat last evaluation …" button in the REPL

      • switch to the editor, modify the function, eval via Cmd+Enter … when the eval succeeds, the last expression entered in the REPl is reevaluated … repeat …

Repl

  • A bug had slipped in the project classpath management preventing native libraries to load properly, for instance when trying to work with Overtone. Fix Issue #577

  • Reverting the behaviour of the "Evaluate selection" when sending to the REPL : back to using 'in-ns instead of 'ns while transitioning to the selection’s namespace Fixes Issue #533: ns is sent to REPL instead of in-ns

  • Launch repl ack timeout set to 60 sec instead of 30

  • Better IPv6 support: replaced "localhost" occurences by "127.0.0.1"

  • "Quiet command report mode" Preference has been removed. Now considered always ON by default. So always quiet.

Stability

  • There were reports of restart issues after Eclipse crashes. Hopefully this has been improved in this release (Fix Issue #568 CCW Beta 0.13.0.201304190010 prevents Eclipse from loading)

Leiningen

  • Internally switched to Leiningen 2.1.2

  • Better exception reporting in the Problem Markers, e.g. when a dependency cannot be found, etc.

Better plays as an Eclipse plugin

  • CCW plugin does not start unnecessarily when invoking the project’s contextual menu