CircleCI

La configurazione per i progetti Ruby on Rails non è complicata e il sistema documentazione descrive accuratamente ogni elemento di config.yml. Tuttavia, vorrei concentrarmi sugli strumenti di circleci che vengono usati per aiutarci a mantenere la configurazione di codice pulire e garantire una buona pratica.

RUBOCOP

È probabile che RuboCope non abbia bisogno di presentazioni, tuttavia, per coloro che non lo conoscono, si tratta di un analizzatore e formattatore statico di codice Ruby. Se si usa già rubocop nella propria progettoè sufficiente aggiungere CircleCI al file di configurazione:

 esecuzione:
    nome: Rubocop
    comando: bundle exec rubocop

ESLINT

ESLint è uno strumento per l'identificazione e la segnalazione di modelli trovati in ECMAScript o in JavaScript per rendere il codice più coerente ed evitare errori.

corsa:
    nome: Eslint
    comando: npm run eslint

RSPEC

In RSpec, i test non sono solo script che verificano il codice dell'applicazione, ma anche spiegazioni dettagliate di come l'applicazione dovrebbe comportarsi, espresse in inglese semplice:

esecuzione:
    nome: RSpec
    comando: |
      mkdir /tmp/test-results
      TEST_FILES="$(circleci tests glob "spec/_spec.rb" |
        circleci tests split --split-by=timings)"
      bundle exec rspec
        --formato progresso
        --formato RspecJunitFormatter
        --out /tmp/test-results/rspec.xml
        --formato progresso
        $TEST_FILES

- memorizza_risultati_test:
    percorso: /tmp/test-risultati

Nel caso di RSpec, si salva il risultato del test in un catalogo /tmp/test-results creato in precedenza nel file rspec.xml e poi si utilizza l'opzione negoziotestrisultati per memorizzare un determinato catalogo. Ora la scheda Approfondimenti ci darà accesso a informazioni come il tempo di compilazione mediano, il tempo dell'ultima compilazione o il tasso di successo. Per saperne di più sulla scheda Approfondimenti qui. Se si vuole memorizzare il file rspec.xml come "artefatto", occorre aggiungere l'opzione memorizzare_artifatti nel nostro file di configurazione.

 store_artifacts:
    percorso: /tmp/test-results

FRENATORE

Brakeman è uno strumento di analisi statica che controlla le applicazioni Ruby on Rails alla ricerca di vulnerabilità di sicurezza. Per impostazione predefinita, Brakeman restituisce un codice di uscita diverso da zero se vengono rilevati avvisi di sicurezza o errori di scansione. Pertanto, ci siamo concentrati solo sugli errori critici e gli avvisi sono stati disattivati.

corsa:
    nome: Brakeman
    comando: bundle exec brakeman --no-exit-on-warn

Se vogliamo anche memorizzare il risultato della scansione nello stesso modo di RSpec, la nostra configurazione sarà simile a questa e avremo accesso al nostro file nella scheda Artifacts.

 corsa:
    nome: Brakeman
    comando: |
      mkdir /tmp/brakeman
      bundle exec brakeman --no-exit-on-warn -o /tmp/brakeman/output.json

- store_artifacts:
    percorso: /tmp/brakeman

RUBINETTO

RubyCritic è una gemma che utilizza gemme per l'analisi statica, come Reek, Flay e Flog, per fornire un rapporto sulla qualità del codice. Il rapporto contiene una valutazione A / B / C / D / F, ogni file del nostro progetto che vogliamo sia analizzato e i punti precisi che necessitano di miglioramenti, e la documentazione con ogni avviso (es: Troppi metodi). Questo strumento funge da consulente nel progetto. Sulla base del rapporto ricevuto, la decisione finale sulla necessità di correggere il codice dipende dallo sviluppatore. Nella nostra configurazione di circleci, viene assegnato un lavoro separato che è responsabile della preparazione del report e dell'invio di un commento speciale con il risultato su github.

La configurazione di base di rubycritic non è diversa dalle precedenti.

 esecuzione:
    nome: Rubycritic
    comando: bundle exec rubycritic ./app -p /tmp/rubycritic -f json -f html --no-browser

- store_artifacts:
    percorso: /tmp/rubycritic

Come standard, eseguiamo il bundle con le informazioni su quale directory vogliamo scansionare ./app, in quale posto vogliamo salvare il risultato -p /tmp/rubycritic (rubycritic crea automaticamente una directory in cui memorizzare il nostro report), in quale formato -f json e l'opzione -no- browser. Utilizziamo anche la gemma cerchio-copertura_reporterche, dopo la scansione, inserisce un commento su github nella nostra richiesta di pull con un link al report e una valutazione percentuale dei file scansionati.

Affinché la gemma di cui sopra funzioni correttamente insieme a circleci, dobbiamo aggiungerla al nostro progetto e generare due chiavi (una è circleci, la seconda è github).

Installazione standard:

• Profilo delle gemme
  gemma 'circleci-coverage_reporter'
• Profilo del rastrello
  require 'circleci/coverage_reporter/rake_task' if ENV['CIRCLECI']
• .config.yml

 esecuzione:
    nome: Esegui Rubycritic
    comando: bundle exec rubycritic ./app -p /tmp/rubycritic -f json -f html --no-browser

 store_artifacts:
    percorso: /tmp/rubycritic

 eseguire:
    nome: Rubycritic notification
    comando: bundle exec rake circleci:report_coverage

Ora dobbiamo generare due chiavi:

TOKEN_REPORTER_CIRCOLO_DI_COPERTURA

Sezione 'Impostazioni' del nostro progetto. Dopo aver scelto 'Create Token', cambiare l'ambito in 'all' e inserire l'etichetta del token. Il token per l'API sarà generato dopo aver fatto clic su

TOKEN_REPORTER_DI_COPERTURA_VCS

Ambito per la chiave del repo

Dopo aver generato le chiavi, dobbiamo aggiungerle alle nostre variabili d'ambiente in Impostazioni:

Configurazione di esempio:

lavori:
  build:
    docker:
      - immagine: circleci/ruby:2.5.1-node-browsers
      ambiente:
        BUNDLER_VERSION: 2.0.1
        BUNDLE_PATH: /bundle
        GOBLONI_DI_BUNDLE: 4
        RAILS_ENV: test
    - immagine: circleci/postgres:10.1-alpine
      ambiente:
        UTENTE POSTGRES: postgres
        POSTGRES_DB: example_test
        POSTGRES_PASSWORD: esempio
    - immagine: circleci/redis:4.0.8-alpine
    directory_di_lavoro: ~/insight
    ambiente:
        TZ: Europa/Varsavia
    passi:
      - controllo
      - eseguire:
          nome: installare bundler versione 2.0.1
          comando: gem install bundler -v 2.0.1
      - restore_cache:
          chiavi:
            - v1-ruby-dependencies-(( checksum "Gemfile.lock" ))
            - v1-ruby-dipendenze-
      - eseguire:
          nome: Installazione del pacchetto
          comando: bundle check || bundle install
      - save_cache:
          key: v1-ruby-dependencies-(( checksum "Gemfile.lock" ))
          percorsi:
            - vendor/bundle
      - restore_cache:
          chiavi:
            - v1-npm-dependencies-(( checksum "package.json" ))
            - v1-npm-dipendenze-
      - run:
          nome: Npm Install
          comando: npm install
      - save_cache:
          chiave: v1-npm-dependencies-(( checksum "package.json" ))
          percorsi:
            - ~/insights/node_modules
      - eseguire:
        nome: Impostazione database
        comando: |
          bundle exec rake db:create
          bundle exec rake db:schema:load
      - esecuzione:
          nome: Rubocop
          comando: bundle exec rubocop
      - eseguire:
          nome: Eslint
          comando: npm run eslint
      - eseguire:
          nome: RSpec
          comando: |
            mkdir /tmp/test-results
            TEST_FILES="$(circleci tests glob "spec/_spec.rb" |
              circleci tests split --split-by=timings)"
            bundle exec rspec
              --formato progresso
              --formato RspecJunitFormatter
              --out /tmp/test-results/rspec.xml
              --formato progresso
              $TEST_FILES
      - esecuzione:
          nome: Brakeman
          comando: bundle exec brakeman --no-exit-on-warn
      - store_test_results:
          percorso: /tmp/test-risultati
  rubycritic:
    docker:
      - immagine: circleci/ruby:2.5.1-node-browsers
        ambiente:
          BUNDLER_VERSION: 2.0.1
          BUNDLE_PATH: /bundle
          GOBLONI_DI_BUNDLE: 4
          RAILS_ENV: test
          CIRCLE_ARTIFACTS: /tmp
    directory_di_lavoro: ~/insight
    passi:
      - checkout
      - eseguire:
          nome: installare bundler versione 2.0.1
          comando: gem install bundler -v 2.0.1
      - restore_cache:
          chiavi:
            - v1-rubycritic-dependencies-(( checksum "Gemfile.lock" ))
            - v1-rubycritic-dependencies-
      - eseguire:
          nome: Installazione bundle
          comando: bundle check || bundle install
      - save_cache:
          key: v1-rubycritic-dependencies-(( checksum "Gemfile.lock" ))
          percorsi:
            - vendor/bundle
      - run:
          nome: Esegui Rubycritic
          comando: bundle exec rubycritic ./app -p /tmp/rubycritic -f json -f html --no-browser
      - store_artifacts:
          percorso: /tmp/rubycritic
      - eseguire:
          nome: Rubycritic notification
          comando: bundle exec rake circleci:report_coverage

flussi di lavoro:
  versione: 2
  build_e_rubycritic:
    lavori:
      - costruire
      - rubycritic:
          richiede:
            - build

Fonti:

• Elenco delle immagini docker disponibili per CircleCi

  • Immagini Docker

• CerchioCi

  • Configurazione CircleCi

    • Esempio di configurazione
    • Raccogliere i dati del test
    • Utilizzo delle intuizioni
    • Memorizzazione degli artefatti di compilazione

• Gemme o strumenti usati

  • RuboCop

    • ESlint
    • RSpec
    • Freniere
    • RubyCtritic
    • Rapporto di copertura del cerchio

Per saperne di più:

• Le buone pratiche di Codest per la creazione di software: la documentazione di progetto
• Come scrivere un codice di qualità?
• Principio di apertura-chiusura. Devo mai usarlo?