IntelliJ IDEA: estilo e formatação de código

Ferramentas modernas facilitam o processo de desenvolvimento. Em particular, é mais fácil monitorar o estilo do seu código, tentando minimizar sua formatação “não autorizada”. Nesta revisão, proponho que você se familiarize com as ferramentas que o IDE IntelliJ Idea oferece ao desenvolvedor para tornar o código agradável de ler e fácil de entender.

Introdução

Uma linguagem de programação é muito semelhante à linguagem que as pessoas falam. A única diferença é que se trata de uma linguagem especial que inicialmente se utiliza para comunicar com um computador para lhe explicar o que queremos dele. Mas não pode haver comunicação individual com um computador. Mesmo quando você começou a aprender uma linguagem de programação, você leu um livro ou algum recurso educacional como JavaRush. E nesta fonte você viu um código que um computador entenderá. Mas você também deve entendê-lo à medida que adquire conhecimento da linguagem Java. Como em qualquer linguagem, a programação possui algumas regras para formação de código. Por exemplo, escrever com uma cerca na sociedade educada é considerado falta de educação, e em Java chamar um método com letra maiúscula é uma violação grosseira do estilo do código. As regras para formatação do código Java são formuladas no documento Java Code Convention . Além disso, o estilo do código pode regular detalhes menores, como recuo. E quando ferramentas de controle de versão são usadas, imagine todo o pesadelo quando todos salvam um arquivo recuado como uma tabulação ou recuado como um espaço. Como será para quem precisa verificar a edição em apenas um método, mas todo o arquivo será alterado devido à correção de espaços nas tabulações ou vice-versa. Naturalmente, como acontece com a linguagem comum, o estilo pode variar dependendo de onde é usado. Por exemplo, na Internet você pode encontrar o Google Java Style Guide ou o Twitter Java Style Guide . Para este artigo de revisão, precisaremos de uma cobaia. Vamos usar o serviço do sistema de construção de projetos Gradle. Isso nos permitirá criar um novo projeto usando um modelo para um início rápido. Gradle tem um ótimo plugin: Build Init Plugin . Vamos para o novo diretório e executar o comando lá: gradle init --type java-application Depois disso, inicie o IntelliJ Idea. Se você vir uma janela com um projeto já aberto (você verá o editor de código, a árvore da estrutura do projeto), feche este projeto usando File -< Close Project. Agora na janela de boas-vindas iremos executar "Import Project"e importar nosso novo projeto. Ao importar, defina o sinalizador "Use autoimport". Vamos descobrir se é possível simplificar de alguma forma a vida com a ajuda de modernas ferramentas de desenvolvimento.

Formatando código na ideia

Após importar o projeto, pressione a combinação de teclas Ctrl+Ne vá para a aula AppTest. Esta classe é a classe de teste padrão. Se parece com isso:

import org.junit.Test;
import static org.junit.Assert.*;

public class AppTest {
    @Test public void testAppHasAGreeting() {
        App classUnderTest = new App();
        assertNotNull("app should have a greeting", classUnderTest.getGreeting());
    }
}

O que imediatamente chama sua atenção aqui? Uma anotação com uma declaração de método em uma linha, que parece feia, concordo. Como consertar isto? O IntelliJ Idea possui uma seção de menu "Code"para várias manipulações de código. Uma dessas manipulações é "Reformat Code"uma combinação de teclas Ctrl + L. Após a aplicação, a anotação ficará em uma linha e o método em si estará em outra. Vale a pena notar imediatamente que esta operação é executada em uma seção selecionada do código . E caso não exista, a operação de formatação será realizada em todo o conteúdo. Vamos agora adicionar um novo método de teste:

@Test
public void testSummOfOddNumbers() {
	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
	Integer result = data.stream().filter(number -> number % 2 == 0).reduce((n1, n2) -> n1 + n2).get();
	assertThat(result, is(12));
}

E duas importações:

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

Como você pode ver, a operação no Stream é colocada em uma linha. Mas e se quisermos ter certeza de que os métodos cujas chamadas são encadeadas sejam sempre divididos em pontos em novas linhas? Por um lado, podemos fazer isso manualmente. Mas lembre-se que queremos que tudo funcione para nós. Afinal, de vez em quando esqueceremos, e o formato do código ficará diferente em todos os lugares, e isso não é bom. Acontece que você precisa editar a regra pela qual o Idea realiza a formatação. Selecione o item Ideia no menu File -> Settings(ou clique em Ctrl + Alt + S). No campo de pesquisa da janela de configurações, escreva “Estilo de código”. Na seção Estilo de código é possível especificar configurações não apenas para Java. Mas agora estamos interessados ​​em Java. Como você pode ver, as configurações estão divididas em várias guias. O mais útil é que o resultado da alteração será mostrado em um exemplo no lado direito da janela: Como você pode ver na captura de tela, podemos especificar a configuração para "Chained method calls" como "wrap Always", ou seja, sempre dividido para chamadas de métodos mesclados. Agora vamos clicar novamente em formatação no teste e ver se realmente funciona! Mas às vezes acontece que é necessário formatar algum código fora das regras gerais de formatação. Vamos configurar a formatação da seguinte forma: Para permitir que a formatação seja desabilitada, o suporte para desabilitar marcadores de formatação deve ser habilitado na seção Estilo de código: Agora podemos alterar o código do nosso teste para que sua formatação permaneça na forma em que o escrevemos:

@Test
public void testSummOfOddNumbers() {
	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
	// @formatter:off
	Integer result = data.stream().filter(number -> number % 2 == 0)
                             .reduce((n1, n2) -> n1 + n2)
                             .get();
	assertThat(result, is(12));
	// @formatter:on
}

Sim, se você notar: quando você pressiona Tab, o Idea interpreta como espaços para você (comportamento padrão). Mas você pode mudar isso lá no Code Style: Como você pode ver, há uma grande variedade de configurações. Você pode ler mais sobre as configurações de estilo de código aqui: " Idea Help: Code Style ". Há outro recurso de formatação importante - importar formatação. Ele é executado separadamente e é chamado "Optimize Imports"e está localizado no item de menu Code -> Optimize Imports(Ctrl + Alt + O). A otimização de importação remove importações desnecessárias e também as coloca na ordem correta de acordo com as configurações na guia Importações das configurações de Estilo de código para Java. Além disso, se você deseja que a formatação aconteça automaticamente, a boa notícia é que você pode fazer isso usando o plugin Save Actions .

Distribuindo configurações para uma equipe

Ótimo, vimos acima que podemos personalizar o estilo de formatação de acordo com nós. Mas como esse estilo pode ser usado em equipe? Muito simples. Existem várias opções. O mais fácil é salvar o diagrama. Abra as configurações do Idea em Arquivo -> Configurações (ou pressione Ctrl + Alt + S). Na seção Estilo de Código podemos ver a inscrição Esquema. Este é o nosso esquema de formatação. Por padrão, um esquema é especificado com o nome Default e próximo a ele a anotação IDE: isso significa que esta configuração é apenas para nosso IDE e não afeta ninguém. Para fazer um esquema “customizado”, clique no botão à direita para fazer um “duplicado” e dê um nome a ele, por exemplo: JavaRush Depois disso poderemos importar ou exportar as configurações: Outra opção é importar as configurações de importação do Idea: A terceira opção é o Repositório de configurações. Para obter mais informações sobre como usar o Repositório de configurações, consulte a documentação "Ajuda do IntelliJ Idea: Repositório de configurações ". No tópico de distribuição de um único estilo na equipe, também não posso deixar de observar o bom suporte para estilos do Eclipse IDE. Para fazer isso, você precisará instalar um plugin separado: abra as configurações do Idea em Arquivo -> Configurações (Ctrl + Alt + S) e vá para a seção Plugins. Para procurar novos plugins, clique no botão "Browse Repositories", após o qual encontraremos o plugin Eclipse Code Formatter na janela de pesquisa. Agora, após a instalação, você precisa reiniciar o Idea - este é um procedimento padrão. Depois disso, no mesmo local, nas configurações do Idea, encontraremos uma nova seção: “Eclipse Code Formatter”. Um exemplo de arquivo formatado para Eclipse pode ser encontrado aqui . Vai parecer algo assim:

Requisitos de aperto

Além das ferramentas Idea, você também pode usar plug-ins de sistema de construção para restringir os requisitos. Não há como verificar se uma pessoa usou formatação. Se houver 5 pessoas na equipe, ainda é possível. Se a empresa tiver 100 pessoas, não é realista. Sim, mesmo cinco serão difíceis de controlar. E por que perder tempo com isso? É muito mais fácil proibir a cobrança de um projeto se certas regras forem violadas. Na verdade, este é um tópico totalmente separado chamado "Inspecionar código". Para os fins deste artigo, quero apenas mostrar como funciona. Um dos plugins mais comuns para Gradle (já que ele coleta nosso projeto, se você se lembra) é pmd . Para habilitá-lo, basta ir ao script de construção do nosso projeto gradle (o arquivo build.gradle na raiz do nosso projeto) e especificar pmd nele ao lado do restante dos plugins:

plugins {
    // Apply the java plugin to add support for Java
    id 'java'
    // Check source code
    id 'pmd'
    // Apply the application plugin to add support for building an application
    id 'application'
}

Agora podemos definir configurações mais detalhadas lá:

pmd {
    ignoreFailures = false
    pmdTest.enabled = true
    ruleSets = [
            'java-basic',
            'java-braces',
            'java-clone',
            'java-codesize',
            'java-comments',
            'java-controversial',
            'java-coupling',
            'java-design',
            'java-empty',
            'java-finalizers',
            'java-imports',
            'java-optimizations',
            'java-strictexception',
            'java-strings',
            'java-typeresolution',
            'java-unnecessary',
            'java-unusedcode'
    ]
}

Mesmo no nosso projeto, tudo não está mais bem. Vamos executar o gradle build e obter um erro. O legal é que um relatório é gerado durante a montagem. E se houver erros, receberemos uma mensagem como:

BUILD FAILED in 35s
6 actionable tasks: 6 executed
7 PMD rule violations were found. See the report at: file:///C:/_study/codestyle/build/reports/pmd/main.html

Se formos ao relatório, veremos algo como: Além disso, na coluna Problema há um link para uma descrição do problema no site do plugin pmd. Por exemplo, para o erro "headerCommentRequirement Required", o link vai aqui: pmd - CommentRequired . Este erro nos indica que nossa classe não possui um JavaDoc. A presença de JavaDoc sobre classes pode ser configurada usando templates: E especifique o conteúdo do cabeçalho do arquivo: Depois disso, podemos transformar o comentário acima da classe App em um JavaDoc e ver com um novo Build que o erro desapareceu.

Resultado final

O estilo do código é importante para um projeto produtivo. Um código bonito escrito de acordo com regras gerais é a garantia de que seus colegas o entenderão com mais facilidade e rapidez, e não dirão algumas coisas afetuosas sobre você. Dadas as modernas ferramentas de desenvolvimento, cumprir as regras não é tão difícil. Espero que esta revisão tenha mostrado que este é realmente o caso. Bem, como sempre, um pouco de material sobre o tema:

• Vídeo da JetBrainsTV: " Inspecionar código (IntelliJ IDEA) "
• Revisão de " Análise de código com plug-ins Gradle "
• Curso " Automatizar a Qualidade do Código "

#Viacheslav