= Gerrit Code Review - Eclipse Setup

This document is about configuring Gerrit Code Review into an
Eclipse workspace for development and debugging with GWT.

Java 6 or later SDK is also required to run GWT's compiler and
runtime debugging environment.


[[Formatting]]
== Code Formatter Settings

Import `tools/GoogleFormat.xml` using Window -> Preferences ->
Java -> Code Style -> Formatter -> Import...

This will define the 'Google Format' profile, which the project
settings prefer when formatting source code.


== Site Initialization

Build once on the command line with
link:dev-buck.html#build[Buck] and then follow
link:dev-readme.html#init[Site Initialization] in the
Developer Setup guide to configure a local site for testing.


== Testing

=== Running the Daemon

Duplicate the existing launch configuration:

* Run -> Debug Configurations ...
* Java Application -> `gerrit_daemon`
* Right click, Duplicate

* Modify the name to be unique.

* Switch to Arguments tab.
* Edit the `-d` program argument flag to match the path used during
  'init'.  The template launch configuration resolves to ../gerrit_testsite
  since that is what the documentation recommends.

* Switch to Common tab.
* Change Save as to be Local file.
* Close the Debug Configurations dialog and save the changes when prompted.


=== Running GWT Debug Mode

The gerrit_gwt_debug launch configuration uses GWT's
link:http://www.gwtproject.org/articles/superdevmode.html[Super Dev Mode].

Due to a problem where the codeserver does not correctly identify the connected
user agent (already fixed upstream but not yet released), the used user agent
must be explicitly set in `GerritGwtUI.gwt.xml` for SDM to work:

[source,xml]
----
  <set-property name="user.agent" value="gecko1_8" />
----

or

[source,xml]
----
  <set-property name="user.agent" value="safari" />
----

* Select in Eclipse Run -> Debug Configurations `gerrit_gwt_debug.launch`
* Only once: add bookmarks for `Dev Mode On/Off` from codeserver URL:
`http://localhost:9876/` to your bookmark bar
* Make sure to activate source maps feature in your browser
* Load Gerrit page `http://localhost:8080`
* Open developer tools, source tab
* Click on `Dev Mode On` bookmark
* Select `gerrit_ui` module to compile (the `Compile` button can also be used
as a bookmarklet).
* Navigate on the left to: sourcemaps/gerrit_ui folder (`Ctrl+O` key shortcut
can be used)
* Select a file, for example com.google.gerrit.client.change.ChangeScreen2
and put a breakpoint
* Navigate in application in change screen and confirm hitting the breakpoint
* Select `Dev Mode Off` when the debugging session is finished

After changing the client side code:
* click `Dev Mode On` then `Compile` to reflect your changes in debug session
* Hitting `F5` in the browser will just load the last compile output, without
recompiling

GERRIT
------
Part of link:index.html[Gerrit Code Review]

SEARCHBOX
---------
