Table of Contents
1. What the numbers are telling you
Chapter 1. An introduction to SonarQube
1.2. Running your first analysis
1.2.1. Installation considerations
1.2.2. Analyzing with SonarQube Runner
1.2.3. Analyzing multilanguage projects
1.3.1. Potential bugs and coding rules
1.3.3. Comments and duplications
1.4. The languages SonarQube covers
1.5.1. Hierarchy: packages and classes in a metric drilldown
Chapter 2. Issues and coding standards
2.2. What issues mean, and why they’re potential problems
2.2.3. Indications of (potential) programmer error
2.2.4. Things that may lead to future programmer error
2.2.6. Style inconsistencies (future productivity obstacles)
2.3. Where do issues come from?
Chapter 3. Ensuring that your code is doing things right
3.1. Knowing how much of your code is doing things right
3.2. Explaining metrics on a file level
3.3. Configuring your favorite code-coverage tool
3.4.1. Displaying integration testing coverage on the dashboard
3.4.2. Getting IT information in the source code Coverage tab
Chapter 4. Working with duplicate code
4.1. The hidden cost of duplicate code
4.2.1. Finding your first duplication
4.2.2. Finding duplications on a larger scale
4.2.3. SonarQube’s duplication metrics
4.2.4. Drilling in: from the duplications widget to the Duplications tab
4.3. Realizing the impact of code duplication
4.3.1. The DRY principle: minimizing and eliminating duplications
4.4. Finding duplications across multiple projects
4.5. Cleaning up your duplications
4.5.1. Introduction to refactoring patterns
Chapter 5. Optimizing source code documentation
5.2. Even commenting has its own metrics
5.3. Identifying undocumented code
5.4. Simplifying your documentation strategy
Chapter 6. Keeping your source code files elegant
6.2. Lack of Cohesion of Methods: files that do too much
6.2.1. Getting reports about the LCOM metric
6.3. RFC and couplings: classes with too many friends
Chapter 7. Improving your application design
7.1.1. Looking at dashboard widgets
7.2. Discovering dependencies and eliminating cycles
7.2.1. Navigating the Dependency Structure Matrix
7.2.4. Library management for Mavenites
Chapter 8. Planning a strategy and expanding your insight
8.1.4. Boy Scout approach: leave the class better than you found it
Chapter 9. Continuous Inspection with SonarQube
9.1. Introducing Continuous Inspection
9.2. Triggering your analysis with CI
9.3. Monitoring quality evolution
9.3.1. Exploring differential views in the project dashboard
9.3.2. Differential views in the issues drilldown
9.3.3. Differential views in the source code viewer
Chapter 10. Letting SonarQube drive code reviews
10.1. Reviewing code in SonarQube
10.1.1. Issues: a starting point
10.1.2. Confirm, comment, and assign: the simplest workflow options
10.1.3. False positives: sometimes SonarQube gets it wrong
10.1.4. Changing severity: not every issue is that bad
10.1.5. Altering the code to make SonarQube turn a blind eye
10.2. Creating manual issues: when the rules aren’t enough
10.3.1. Life cycle of an issue
10.4. Planning your work with SonarQube’s action plans
10.5. Structuring a code review
11.2. Setting up Eclipse integration
11.3. Working your assigned issues
11.4. Running a local analysis
3. Administering and extending
Chapter 12. Security: users, groups, and roles
12.1. Creating users and groups
12.1.2. Personalization: what users can manage for themselves
Chapter 13. Rule profile administration
13.1. Making your own profile: copy and modify
13.1.1. Copy or start from scratch?
13.1.2. Your first profile edits and their quality implications
13.1.3. Adding rules: how to find them and why you’d want to
13.3.1. Customizing individual rules: editing rule parameters
13.3.2. Cookie-cutter rules: the ones you can duplicate
13.4. Alerts: knowing when your metrics have crossed the line
13.5. How to track profile changes
13.5.1. Changelog: who did what, when
13.6. Administrative miscellany
13.6.1. Project assignment: which project uses which profile
Chapter 14. Making SonarQube fit your needs
14.2. One size doesn’t fit all: managing global dashboards
14.2.1. Creating your first global dashboard
14.3. Getting notified by SonarQube
14.4. Adjusting global settings
Chapter 15. Managing your projects
15.1. Working with project dashboards
15.2. Adopting Continuous Inspection more quickly
15.2.1. Assigning quality profiles
15.2.2. Defining your own metrics
15.3. Exploring the rest of the project configuration
Chapter 16. Writing your own plugin
16.1. Understanding SonarQube’s architecture
16.2. Implementing the Redmine plugin
16.2.1. Creating the plugin Maven project
16.2.2. Defining the plugin’s available configuration
16.2.3. Describing the metrics: what you’ll calculate and store
16.2.4. Implementing your analyzer with a sensor
16.2.5. Creating your first widget
Appendix A. Installation and setup
A.1. Preparing for installation
B.1. Analyzing with SonarQube Runner