Software projects tend to become very complex and difficult to maintain. With the help of refactoring, the code can be made relatively easy to understand. However, in a real-world project, it seems impossible to have a very high code quality everywhere.

For the hotspots of a program, the locations with a high complexity and change rate, the refactoring efforts will most likely have the highest return on investment. This blog post explores a way how they can be identified in a Java project.

Apache Wicket was chosen as an example project. For its analysis, the open-source tools SonarCube, Code Charta, and Code Maat, and Python scripting are being used. The complexity is measured with SonarCube's Cognitive complexity metric and the change rate by the number of commits for a particular file.

Environment

The steps below are done in a DigitalOcean droplet, except of the final visualization.

• Ubuntu 18.04
• Pre-installed Docker

Preparation

Download of required repositories

The following repositories will be required along they way:

mkdir ~/src && cd ~/src git clone https://github.com/apache/wicket.git git clone https://github.com/adamtornhill/code-maat.git git clone https://github.com/experimental-software/code-analytics.git 

Tool setup

A SonarCube server can be started with this docker run instruction:

docker run --env ES_JAVA_OPTS="-Xms750m -Xmx750m" -d -p 9000:9000 -p 9092:9092 sonarqube 

We will also need a couple of system tools later:

apt update && apt install maven npm leiningen unzip -y 

Code Charta needs to be installed via the Node Package Manager:

npm install codecharta-analysis -g npm install codecharta-visualization -g 

For Code Mate there is no binary distribution, we need to compile it by ourselves:

cd ~/src/code-maat lein uberjar mkdir ~/bin cp target/code-maat-1.1-SNAPSHOT-standalone.jar ~/bin/code-maat.jar 

By installing the sonar-scanner CLI tool, we can import a Java project without changing it's configuration:

cd ~/bin curl https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-3.3.0.1492-linux.zip \ > sonar-scanner-cli-3.3.0.1492-linux.zip unzip sonar-scanner-cli-3.3.0.1492-linux.zip PATH="$PATH:~/bin/sonar-scanner-3.3.0.1492-linux/bin" 

Analysis

Now we can actually start the code analysis. The first step is to import the Java project into SonarCube:

cd ~/src/wicket mvn install sonar-scanner -Dsonar.projectKey=wicket \ -Dsonar.source=. -Dsonar.java.binaries=. \ -Dsonar.exclusions='**/*.js,**/*.xml' curl http://localhost:9000/api/ce/task?id=AWrweUgHuDEJjgfjbZpz \ | jq '.task.status' 

Next, we extract the data from SonarCube into a JSON file which is the basis of the final code visualization:

ccsh sonarimport http://localhost:9000 wicket > /tmp/sonar.json 

The counting of the number of commits for each file will be done with Code Maat which takes the git log as input:

cd ~/src/wicket git log --since="1 year" --all --numstat --date=short \ --pretty=format:'--%h--%ad--%aN' --no-renames \ > /tmp/gitlog.txt java -jar ~/bin/code-maat.jar --log /tmp/gitlog.txt \ --version-control git2 --analysis revisions \ > /tmp/codemaat-revisions.txt 

Then we can enrich the sonar.json file with the information extracted by Code Maat with a little helper script:

cd ~/src/code-analytics python enrich_codecharta_data.py --sonar-json /tmp/sonar.json \ --codemaat-csv /tmp/codemaat-revisions.txt 

Finally, we can start the Code Charta visualization, load the sonar.json in its GUI and select the metrics we want to visualize.

codecharta-visualization 

Result