Share
Questo articolo spiega le basi di Rake. È uno strumento di compilazione molto popolare che è scritto in Ruby. Offre molta flessibilità ed è utilizzato per gestire tutti i tipi di attività. Se stai usando Rails, ti consiglio di dare un'occhiata sotto il cofano per scoprire quali compiti sono a tua disposizione e come scrivere il tuo.
Grazie a Rails, Rake è diventato di fatto uno standard come strumento di creazione di Ruby. È molto popolare nella comunità di Ruby. Molto presto, il team dietro a Rails ha deciso di utilizzare Rake come builder per Rails stesso, il che significava che in passato, quando hai scaricato Rails, ti serviva anche una copia di Rake. In questo modo ha esposto Rake a molte persone. Poco dopo, è stato incluso in Ruby (1.9) stesso.
Rake ha di fatto sostituito l'utility Unix Make come strumento di costruzione in Ruby land. Uno strumento di compilazione come Rake è utile per automatizzare attività di vario tipo, un software per la gestione delle attività in pratica. Viene spesso utilizzato per le attività di amministrazione in Rails, che è probabilmente il punto in cui è stato eseguito fino ad ora, ma i casi d'uso sono abbondanti. Alcune persone scrivono i loro ebook in Markdown e hanno impostato attività Rake che convertono i file rilevanti in file HTML intermedi, che a loro volta vengono convertiti in formati di ebook, ad esempio. Salva un sacco di problemi nell'usare Rake per questo.
Ciò che rende Rake davvero potente è che queste attività possono essere correlate l'una all'altra e possono essere costruite l'una sull'altra. Inoltre, poiché è scritto in Ruby, puoi scrivere qualsiasi codice Ruby per le tue attività. Vuoi usare le librerie Ruby nelle tue attività di Rake? Nessun problema! Fatto divertente: è il RubyGem più scaricato, con oltre 100 milioni di download. Quindi sicuramente qualcosa nella tua cintura degli attrezzi che dovresti prestare un po 'più di attenzione.
È stato concepito dal compianto Jim Weirich, un noto ed amato sviluppatore, speaker e collaboratore dell'ecosistema Ruby. È davvero un bellissimo strumento, grazie, Jim! RIPOSA IN PACE!
Diamo un'occhiata ad alcune attività che Rails offre fin da subito. Scommetto che sei un po 'sorpreso di ciò che è disponibile se non hai controllato prima. Nella directory pertinente della tua app o del tuo Rakefile, puoi elencarli digitando quanto segue in una shell:
rake --tasks #or rake -T
rake about # Elenco delle versioni di tutti i framework Rails e delle risorse rake dell'ambiente: clean [keep] # Rimuovi le vecchie risorse di rake compilate: clobber # Rimuovi asset compilati asset rake: environment # Carico asset asset rile di compilazione di risorse: precompilare # Compila tutte le risorse chiamato in config.assets.precompile rake cache_digests: dipendenze # Cerca dipendenze di primo livello per TEMPLATE (come messaggi / show o comm ... rake cache_digests: nested_dependencies # Cerca dipendenze nidificate per TEMPLATE (come messaggi / show o commenti / ... rake db: create # Crea il database da DATABASE_URL o config / database.yml per cu ... rake db: drop # Elimina il database da DATABASE_URL o config / database.yml per il curr ... rake db: fixtures: carica # Carica i fix nel database dell'ambiente corrente rake db: migrate # Migrate il database (opzioni: VERSION = x, VERBOSE = false, SCOPE = blog) rake db: migrate: status # Mostra lo stato delle migrazioni rake db: rollback # Ritorna lo schema al verso precedente on (specificare i passi w / STEP = n) rake db: schema: cache: clear # Cancella un file db / schema_cache.dump rake db: schema: cache: dump # Crea un file db / schema_cache.dump rake db: schema: dump # Crea un file db / schema.rb che sia portabile contro qualsiasi DB supportato da AR rake db: schema: carica # Carica un file schema.rb nel database rake db: seed # Carica i dati seme da db / seeds.rb rake db: setup # Crea il database, carica lo schema e inizializza con i dati seme ... rake db: structure: dump # Scarica la struttura del database in db / structure.sql rake db: structure: load # Ricrea i database dalla struttura. sql file rake db: version # Recupera il numero corrente della versione dello schema rake doc: app # Genera documenti per l'app - disponibile anche doc: rails, doc: guide (optio ... rake log: clear # tronca tutti i file * .log nel log / a zero byte (specifica quali registri con ... rake middleware # Stampa le note di rake stack middleware Rack # Enumera tutte le annotazioni (usa note: optimize,: fixme,: todo per focus) rake not es: custom # Enumera un'annotazione personalizzata, specifica con ANNOTATION = CUSTOM rake rails: template # Applica il modello fornito da LOCATION = (/ percorso / a / modello) o rotaie rake URL: aggiornamento # Configs di aggiornamento e alcuni altri file inizialmente generati ( o usa solo upd ... rake routes # Stampa tutti i percorsi definiti nell'ordine di abbinamento, con rake segreto dei nomi # Genera una chiave segreta crittograficamente protetta (in genere viene usata ... rake spec # Esegui tutte le specifiche nella directory spec (escluso il plugin specs) spec: controller # Esegui gli esempi di codice in spec / controller rake spec: features # Esegui gli esempi di codice in spec / features spec rake: helper # Esegui gli esempi di codice in spec / helpers rake spec: models # Esegui gli esempi di codice in spec / model rake spec: views # Esegui gli esempi di codice in spec / views rake stats # riporta le statistiche del codice (KLOCs, ecc.) dall'applicazione o tempo di rake del motore: zone: tutte # Visualizza tutti i fusi orari, disponibili anche: time: zone: us , time: zones: local ... rake tmp: clear # Cancella sessione, cache, e file socket da tmp / (narrow w / tmp: sessions ... rake tmp: create # Crea directory tmp per sessioni, cache, socket e pids
L'output in un'applicazione Rails è sorprendentemente abbondante, non è vero? Puoi trovare compiti molto più utili del solito rake db: migrate o percorsi di rake che siamo così familiari e che eseguiamo più volte ogni giorno.
A sinistra, vengono visualizzate le varie attività e, a destra, viene visualizzato ciò che è facoltativamente fornito come descrizione per ogni attività di rake. Se vuoi vedere la lista completa, che tra le altre cose include anche attività che mancano di una descrizione, devi aggiungere una bandiera aggiuntiva.
rake -T -A # o rake -T -all
rake about # Elenco delle versioni di tutti i framework Rails e delle risorse rake dell'ambiente: clean [keep] # Rimuovi le vecchie risorse di rake compilate: clobber # Rimuovi asset compilati asset rake: environment # Carico asset asset rile di compilazione di risorse: precompilare # Compila tutte le risorse chiamato in config.assets.precompile rake cache_digests: dipendenze # Cerca dipendenze di primo livello per TEMPLATE (come messaggi / show o commenti / _comment.html) rake cache_digests: nested_dependencies # Cerca dipendenze nidificate per TEMPLATE (come messaggi / show o commenti / _comment .html) rake db: _dump # rake db: abort_if_pending_migrations # rake db: charset # rake db: collation # rake db: create # Crea il database da DATABASE_URL o config / database.yml per l'attuale RAILS_ENV (usa db: create: all per creare tutti i database nella configurazione) rake db: create: all # rake db: drop # Elimina il database da DATABASE_URL o config / database.yml per l'attuale RAILS_ENV (usa db: drop: all per eliminare tutti i database nella configurazione) rake db : drop: all # rake db: fixtures: identifica # rake db: fixtures: carica # Carica fixtures nel rake del database dell'ambiente corrente db: forward # rake db: load_config # rake db: migrate # Migrate il database (opzioni: VERSION = x , VERBOSE = false, SCOPE = blog) rake db: migrate: down # rake db: migrate: redo # rake db: migrate: reset # rake db: migrate: status # Visualizza lo stato delle migrazioni rake db: migrate: up # rake db : purge # rake db: purge: all # rake db: reset # rake db: rollback # Ritorna lo schema alla versione precedente (specifica i passaggi w / STEP = n) rake db: schema: cache: clear # Cancella un db / schema_cache.dump file rake db: schema: cache: dump # Crea un file db / schema_cache.dump rake db: schema: dump # Crea un file db / schema.rb che è portatile contro qualsiasi DB supportato da AR rake db: schema: carica # Carica un file schema.rb nel database rake db: schema: load_if_ruby # rake db: seed # Carica i dati seme da db / seeds.rb rake db: setup # Crea il database, carica lo schema e inizializza con il dati seme (usare db: reset per eliminare anche il database prima) rake db: structure: dump # Dump la struttura del database in db / structure.sql rake db: structure: load # Ricrea i database dal file structure.sql rake db: structure: load_if_sql # rake db: test: clone # rake db: test: clone_schema # rake db: test: clone_structure # rake db: test: deprecato # rake db: test: load # rake db: test: load_schema # rake db: test: load_structure # rake db: test : prepare # rake db: test: purge # rake db: version # Recupera il numero corrente della versione dello schema rake default # rake doc # rake doc / app # rake doc / app / created.rid # rake doc: app # Genera documenti per app - disponibile anche doc: rails, doc: guide (opzioni: TEMPLATE = / rdoc-template.rb, TITLE = "Titolo personalizzato") rake doc: clobber # rake doc: clobber_app # rake doc: clobber_rails # rake doc: guides # rake doc: rails # rake doc: reapp # rake doc: rerails # rake environment # rake html # rake html / created.rid # rake log: clear # tronca tutti i file * .log in log / a zero byte (specifica quali log con i log = test, sviluppo) rake magic # Magic rake task rake middleware # Stampa il tuo rack middleware rake stack no_description # rake notes # Enumera tutte le annotazioni (usa note: optimize,: fixme,: todo per focus) rake notes: custom # Enumera un annotazione personalizzata, specificare con ANNOTATION = CUSTOM note rake: fixme # note rake: ottimizzare # note rake: todo # rake rails: template # Applica il modello fornito da LOCATION = (/ percorso / al / modello) o rotaie rake URL: templates: copia # rake rails: update # Aggiorna configs e alcuni altri file generati inizialmente (o usa solo update: configs o update: bin) rake rails: update: bin # rake rails: update: configs # rake railties: installa: migrations # rake routes # Stampa tutti i percorsi definiti nell'ordine delle partite, con i nomi rake secret # Genera una chiave segreta crittograficamente protetta (generalmente utilizzata per generare un segreto per le sessioni di cookie) rake spec # Esegui tutte le specifiche nella directory spec (escluso specifiche del plugin) rake spec : controller # Esegue gli esempi di codice in spec / con trollers rake spec: features # Esegui gli esempi di codice in spec / features spec rake: helpers # Esegui gli esempi di codice in spec / helpers rake spec: models # Esegui gli esempi di codice in spec / models rake spec: prepare # rake spec: statsetup # rake spec: views # Esegui gli esempi di codice in spec / views rake stats # riporta le statistiche del codice (KLOCs, ecc.) dall'applicazione o tempo di rake del motore: zone: tutte # Visualizza tutti i fusi orari, disponibili anche: time: zone: us, time: zone: local - filtro con parametro OFFSET, ad es. OFFSET = -6 tempo di rake: zone: local # tempo di rake: zone: us # rake tmp # rake tmp / cache # rake tmp / cache / assets # rake tmp / cache / assets / development # rake tmp / cache / assets / production # rake tmp / cache / assets / test # rake tmp / pids # rake tmp / sessions # rake tmp / sockets # rake tmp: cache: clear # rake tmp: clear # Cancella i file di sessione, cache e socket da tmp / (narrow w / tmp: sessioni: clear, tmp: cache: clear, tmp: socket: clear) rake tmp: create # Crea directory tmp per sessioni, cache, socket e pids rake tmp : pids: clear # rake tmp: session: clear # rake tmp: socket: clear #
Sorpresa, quasi tre volte tanto! Date un'occhiata a loro e giocate se vi piace, ma impegnate i punti salienti nella memoria per utilizzarli in futuro. Controllare le attività per vedere quali sono disponibili potrebbe impedirti di reinventare la ruota.
Un Rakefile può avere una delle seguenti cinque apparizioni:
Per lo più vedrai la pianura Rakefile versione, ma un framework come Rails ha bisogno di un'organizzazione più complessa. Usa quello che ti fa scorrere il sangue. Inizi creando creando un Rakefile o file con a .rastrello estensione se si desidera suddividere le attività logicamente su più file. Quindi definire le attività all'interno di uno di essi.
Rails rende questo incredibilmente facile. Ha un Rakefile nella radice della tua app. Contiene quanto segue:
Accentsconagua
richiede File.expand_path ('... / config / application', __FILE__) Rails.application.load_tasksQuando hai un sacco di compiti personalizzati, ha più senso dividerli in discreti .rastrello file e inserirli lib / task. Il Rakefile sopra li carica, ma il lib directory è una casa logica migliore per le attività. Esiste anche un generatore di Rails per automatizzare parte del processo. Se si digita:
rails genera some_task => crea lib / tasks / some_task.rake
Otterrai un Rakefile posizionato automaticamente nella directory giusta. Anche il compito è già impostato per te. Bello! In altri progetti, non usando Rails, devi solo creare un rakelib directory e posiziona i tuoi Rakefiles lì, preferibilmente con .rastrello estensioni di file. Quindi creare un file chiamato Rakefile e tutti questi file sono già a tua disposizione.
desc 'Elenco delle versioni di tutti i framework Rails e dell'ambiente' task: about do puts 'Some magic goes in here ...' end
Per i neofiti di Ruby completi tra di voi, e per le persone che provengono da linguaggi di parentesi pesanti, questo è il modo in cui apparirebbe tra parentesi.
desc ('Elenca le versioni di tutti i framework Rails e l'ambiente') task (: about) do puts ('Some magic goes in here ...') endA proposito, sembra molto strano. Basta perdere le parentesi in più: nessuno scrive i compiti in questo modo.
Abbiamo fornito un compito con nome :di con una descrizione che non solo ci ricorda in futuro ciò che volevamo ottenere con compiti particolari, ma si rivela anche quando corriamo rastrello -T. Non farti pigro da questa parte; probabilmente non ne vale la pena.
Subito sotto è l'attività della parola chiave che definisce una nuova attività nominata di. Questo può essere richiamato sulla riga di comando tramite rastrellare che fa la sua magia allora. rastrello: circa d'altra parte causerà l'aborto di Rake, non sapendo "come costruire il compito: about".
Via il fine blocco, abbiamo un lambda, e il suo corpo specifica cosa fa il compito. Questa è l'impostazione di base di cui avrà bisogno un'attività. Offre molte più opzioni, ovviamente, ma la struttura generale è la stessa.
richiede './whatever.rb'
Se è necessario includere altri file Ruby o Rakefiles, può essere facilmente raggiunto con uno standard richiedere dichiarazione.
importare "whatever.rb"
Rake stesso ci fornisce un altro modo per farlo: il importare metodo. Questo può essere usato in qualsiasi linea del Rakefile. Questo ti aiuterà quando ti troverai nei guai perché il file richiesto è stato caricato prima che il Rakefile finisse di caricare e scoppiare, quindi. Il file importato, d'altro canto, verrà sempre caricato dopo Rakefile.
A volte potresti voler eseguire alcune attività definite dal tuo Compito classe manualmente. A questo scopo, hai due metodi di Rake :: Task classe: eseguire e invocare.
Rake :: Task ['some_task']. Invoca Rake :: Task ['some_task']. Esegui
Con il Rake :: Task [ 'some_task'] codice, abbiamo ottenuto il some_task Attività di rake da eseguire. Restituisce un'istanza di Rake :: Task classe e quindi esegue qualsiasi metodo su di esso che è disponibile.
Una caratteristica molto interessante è la capacità di assegnare un nome ai compiti. Probabilmente hai già usato decine di volte. Quando corri rake db: migrate, hai fatto uso del db spazio dei nomi, per esempio. Invochi l'attività separandola con due punti : dal namespace. I namespace sono un modo pratico per organizzare i tuoi compiti all'interno di un file rake: li tiene separati logicamente. Più domini come tempo di rake: zone: tutte vanno bene, a proposito.
Altri esempi includono:
rake db: drop rake db: seed rake log: clear rake spec: views rake spec: model rake db: rollback rake specifica: helper rake spec: caratteristiche rake db: schema: carico rake asset: precompile rake db: migrate: status
namespace: db do desc Attività 'Migrating some stuff': migrate do ... end end
Questa è l'impostazione di base. In realtà è molto più complicato e può persino essere annidato più volte. Dai una rapida occhiata al codice di Rails e vedi da te come rake db: migrate è implementato. Non sentirti male se è sopra la tua testa. Basta guardarsi intorno, cercare di discernere come è strutturato e andare avanti per ora.
Un'altra strategia per organizzare i tuoi compiti e mantenerli DRY sta usando i prerequisiti per l'esecuzione di un'attività. È come una dipendenza che deve essere eseguita prima che l'attività effettiva inizi il suo lavoro. In questo modo è possibile creare attività più complesse, complesse quanto è necessario. Ma raccomanderei di non diventare troppo intelligente e di mantenerlo il più semplice possibile, e anche il più facile da capire possibile.
compito: stop_megalomaniac mette "Un sacco di chiacchiere intelligenti, inseguimenti di auto e pistole sparate" fine compito: bond_saves_the_day =>: stop_psychotic_megalomaniac fa mettere "Un sacco di Dom Pérignon, ostriche e bond girl business" fine
Se vuoi fare affidamento su più attività, devi semplicemente inserirle in un array. L'ordine con cui le posizioni è importante, ovviamente.
compito: get_mr_wolf mette "Non hai nessun problema, Jules, ci sono! Vai dentro e rilassali e aspetta il lupo che dovrebbe venire direttamente!" end task: figure_out_bonnie_situation fa puts "Se sono stato informato correttamente, il tempo stringe: è giusto Jimmy?" end task: calm_down_jimmy do puts "Jimmy, fammi un favore, vuoi? Ho sentito un po 'di caffè laggiù. Mi faresti una tazza?" end task: get_vince_vega_in_line fa puts "Vieni di nuovo? Prendi il buster dritto, non sono qui per dire per favore! Sono qui per dirti cosa fare!" end task: clean_car fa puts "Ho bisogno di voi due ragazzi per portare quei prodotti per la pulizia e pulire l'interno dell'auto. Sto parlando veloce, veloce, veloce!" fine compito: clean_crew mette "Jim, il sapone! O.K. signori, siete stati entrambi in contea prima che ne sia sicuro. Eccolo!" fine compito: get_rid_of_evidence_at_monster_joes fa "Allora che cosa è con gli abiti? Ragazzi andate a una partita di pallavolo o qualcosa del genere?" end task: drive_into_the_sunrise fa "Call me Winston!" end task: solve_bonnie_situation => [: get_mr_wolf,: calm_down_jimmy,: figure_out_bonnie_situation,: get_vince_vega_in_line,: clean_car,: clean_crew,: get_rid_of_evidence_at_monster_joes,: drive_into_the_sunrise] do puts "Sai, andrei a fare colazione, mi fa piacere fare colazione con me ?" fine
Se esegui l'attività rake che dipende dall'altra, otterremo il seguente risultato:
$ rake solve_bonnie_situation Non hai nessun problema Jules, ci sono! Entra li e rilassali e aspetta il lupo che dovrebbe venire direttamente! Jimmy, fammi un favore, vuoi? Ho sentito un po 'di caffè laggiù. Mi faresti una tazza? Se sono stato informato correttamente, il tempo stringe. È giusto Jimmy? Vieni di nuovo? Ottienilo dritto. Non sono qui per dire per favore! Sono qui per dirti cosa fare! Ho bisogno di voi due ragazzi per prendere quei prodotti per la pulizia e pulire l'interno dell'auto. Sto parlando veloce, veloce, veloce! Jim, il sapone! OK. signori, siete stati entrambi della contea prima che ne sia sicuro. Ecco che arriva! Allora, che cosa è con gli abiti? Ragazzi state andando a una partita di pallavolo o qualcosa del genere? Chiamami Winston! Sai, andrei a fare colazione. Senti come fare colazione con me?
L'ordine in cui vengono definite le attività di rake non ha alcun effetto sull'output: solo l'ordine in cui si inseriscono le attività prerequisite nell'array per le dipendenze delle attività. Inoltre, si prega di utilizzare l'hashrocket => sintassi per questo.
Un lungo elenco di dipendenze potrebbe essere un odore di codice. Se hai a che fare con qualcosa di lungo, puliscilo incapsulandolo in un metodo che poi passiamo come prerequisito.
def mr_wolf_tasks [: get_mr_wolf,: calm_down_jimmy,: figure_out_bonnie_situation,: get_vince_vega_in_line,: clean_car,: clean_crew,: get_rid_of_evidence_at_monster_joes,: drive_into_the_sunrise] end ... task: solve_bonnie_situation => mr_wolf_tasks do puts 'Sai, andrei a fare colazione. Ti va di fare colazione con me? fine
Nel contesto dei prerequisiti, una cosa da tenere a mente è che devi solo menzionare uno spazio dei nomi se sei fuori da quello pertinente.
namespace: marsellus_wallace do task: call_winston_wolf do ... end end task: solve_bonnie_situation => 'marsellus_wallace: call_winston_wolf' do ... end namespace: marsellus_wallace fai task: call_winston_wolf do ... end task: solve_bonnie_situation =>: call_winston_wolf do ... end end
È importante notare, tuttavia: nel caso in cui sia necessario menzionare lo spazio dei nomi, è necessario passare il prerequisito come stringa => 'marsellus_wallace: call_winston_wolf'.
Naturalmente, gli esempi sopra sono stupidi e non esempi di vita reale, ma l'intenzione era di mostrarti come funzionano i prerequisiti e come li avresti messi insieme mentre dipendono l'uno dall'altro.
Hai due opzioni per passare argomenti alle attività di Rake: usando le variabili di Bash o facendo uso della stessa sintassi di Rake.
Nel caso in cui non avessi suonato con Bash prima - o Bash suona come un gobbledegook per te - prendiamone cinque e iniziamo dall'inizio. Bash nella tua shell offre due tipi di variabili: variabili globali (aka ambiente) e locali. Entrambi sono scritti in maiuscolo. Le variabili di ambiente sono globali, il che significa che sono disponibili in tutte le shell e non svaniscono quando si chiudono le variabili one Bash diverse, che sono disponibili solo nella shell corrente.
Le variabili di ambiente possono contenere dati che possono essere utilizzati da più applicazioni e sono spesso usati come un modo pratico per condividere le impostazioni di configurazione. Al contrario, le variabili Bash locali sono proprio questo, locale. Nel nostro contesto dell'uso di Rake, hai la possibilità di accedere sia tramite Ruby che in effetti passa le variabili dalla riga di comando.
Un po 'da parte, se digiti ENV o ENV nella tua shell, avrai accesso a tutta una serie di variabili d'ambiente. Ho redatto la lista, ma per una migliore comprensione di quali sono le variabili di ambiente e cosa includono, vi incoraggio a eseguirlo per voi stessi.
ENV
TERM_PROGRAM = TERMINOLOGIA Apple_Terminal = SHELL schermo-256 SHELL = / bin / bash TMUX = / private / var / folders / 4z / 3np9k5ks62b1xpbn_w_lmrgh0000gr / T / tmux-504 / default, 4146,0 EDITOR = vim LANG = it_US.UTF-8 TMUX_PANE = % 1 is_vim = echo "# pane_current_command" | grep -iqE "(^ | \ /) g? (view | n? vim? x?) (diff)? $" ...
Se si desidera visualizzare un elenco di variabili Bash locali, è possibile eseguire impostato.
(imposta -o posix; imposta) | Di meno
Il impostato il comando ti dà molto più output, ma il precedente mostra i bit rilevanti subito.
Ruby offre un modo per usare l'ambiente e le variabili Bash locali allo stesso modo tramite un accettore tipo hash. Per le nostre esigenze, quando passiamo una variabile a un'attività Rake, sarà una variabile Bash locale, che puoi trovare nell'elenco di variabili in esecuzione impostato o una variazione di esso. Ruby può leggerlo usando ENV [ 'VARIABILE'].
rake prepare_book BOOKTITLE = "Confessioni di un unicorno"
Quello che voglio chiarire, però, è che questa variabile non verrà aggiunta alla lista ENV utilizzata dal tuo sistema, quella che hai visto chiamare ENV dalla shell. Per aggiungerlo a quell'elenco, è necessario esportare esso. Questa è un'altra storia, ma ho pensato di chiarirlo.
task: prepare_book do book_title = ENV ['BOOKTITLE'] || 'Working Title' mette "Fai qualcosa con il # book_title" fine
In questa definizione di attività, è possibile vedere come siamo disposti ad accettare o incorporare la variabile passata al richiamo dell'attività. ruby ENV [BASHVARIABLE] fa tutto il sollevamento pesante. Se TITOLO DEL LIBRO era stata una variabile di ambiente globale, tuttavia, avremmo potuto accedervi anche all'interno di questa definizione di compito con questa sintassi.
Il secondo approccio utilizza la sintassi Rake pura. È sufficiente passare le variabili in parentesi quadre. Questo approccio è migliore e puoi mantenere le cose più isolate. Perché coinvolgere Bash se Rake è perfettamente in grado di gestirlo? Inoltre non hai nessuna variabile Bash che fluttua in quel modo. Se vuoi passare più argomenti in un'attività, è anche molto più elegante.
rake "create_mi6_agent [James, Bond, 007]"
compito: create_mi6_agent, [: first_name,: last_name,: number] do | t, args | puts "Numero # args.number è il comandante # args.first_name # args.last_name." fine
Quando passi più argomenti di quelli che hai definito nel tuo compito, puoi semplicemente accedervi tramite args. args.extras visualizza una matrice di tutti i parametri aggiuntivi passati. args.to_a mostra tutti i parametri, ovviamente anche in un array.
Di seguito è riportato un breve elenco di attività di Rake fornite con Rails:
Sotto ci sono un paio di compiti utili sotto il db spazio dei nomi per l'esecuzione delle migrazioni di Active Record:
rake db: versione stampa la versione corrente dello schema. L'output è simile a questo:
Versione corrente: 20160129135912
rake db: migrate esegue l'ultima migrazione (s) -quelle che non sono ancora state eseguite. Puoi anche passargli una migrazione specifica da eseguire.
rake db: migrate VERSION = 20080906120000
rake db: create crea il tuo database. Se il valore predefinito è lo sviluppo e testare i database.
db / development.sqlite3 db / test.sqlite3
rake db: test: preparare si assicura che anche le migrazioni che sono già in esecuzione nel database di sviluppo vengano eseguite per il database di test. Se lo schema del database di test non fosse sincronizzato con il database di sviluppo, ovviamente non sarebbe molto utile.
rake db: drop: all elimina i database di test e di sviluppo per impostazione predefinita.
rake db: migrate: up, rake db: migrate: down corre il su e giù metodi per la migrazione in questione.
rake db: redo assicura che, dopo aver eseguito una migrazione, la migrazione sia reversibile. Corre rake db: down prima e poi rake db: up.
rake db: rollback annulla l'ultima migrazione.
rake db: drop scende dal database di sviluppo e test per impostazione predefinita.
rake db: reset elimina prima i database e li imposta nuovamente caricando lo schema e seminando il database.
rake doc: app genera documentazione sotto doc / app. Crea pagine HTML sul tuo codice sorgente per una facile navigazione. Molto carino!
rake doc: rails genera una documentazione API sotto doc / api-anche come pagine HTML. Pratico se sei offline, immagino.
Il tmp la directory nella directory principale della tua app Rails è il posto per i file temporanei, i file più importanti per sessioni e cache. rake tmp: creare ti imposta con tutto ciò che ti serve per gestire i file temporanei. rake tmp: cache: clear cancella il tmp / cache elenco. rake tmp: sessioni: chiaro cancella il tmp / sessions elenco.
statistiche rake ti dà una bella panoramica della tua app.
+----------------------+-------+-------+---------+---------+-----+-------+ | Nome | Linee | LOC | Classi | Metodi | M / C | LOC / M | + ---------------------- + ------- + ------- + --------- + --------- + ----- + ------- + | Controller | 89 | 69 | 6 | 18 | 3 | 1 | | Aiutanti | 13 | 13 | 0 | 1 | 0 | 11 | | Modelli | 89 | 54 | 6 | 7 | 1 | 5 | | Mailers | 0 | 0 | 0 | 0 | 0 | 0 | | Javascripts | 25 | 0 | 0 | 0 | 0 | 0 | | Librerie | 0 | 0 | 0 | 0 | 0 | 0 | | Specifiche del controller | 99 | 81 | 0 | 0 | 0 | 0 | | Caratteristiche tecniche | 14 | 11 | 0 | 0 | 0 | 0 | | Specifiche di aiuto | 45 | 12 | 0 | 0 | 0 | 0 | | Specifiche del modello | 10 | 8 | 0 | 0 | 0 | 0 | | Visualizza le specifiche | 60 | 48 | 0 | 0 | 0 | 0 | + ---------------------- + ------- + ------- + --------- + --------- + ----- + ------- + | Totale | 444 | 296 | 12 | 26 | 2 | 9 | + ---------------------- + ------- + ------- + --------- + --------- + ----- + ------- + Codice LOC: 136 LOC test: 160 Codice rapporto test: 1: 1.2
Puoi lasciare note nel tuo codice. Puoi inserire come prefisso nei commenti con FARE, AGGIUSTAMI, OTTIMIZZARE.
# FIXME Qualcosa da sistemare qui agente di classe < ActiveRecord::Base belongs_to :operation belongs_to :mission…
Quando corri note di rastrello, Rake analizza questi prefissi e ti fornisce un elenco di tutte queste note dal tuo codice.
app / models / agent.rb: * [1] [FIXME] Qualcosa da sistemare qui
Puoi anche ottenere un elenco dettagliato dove li trovi: directory, nome file, numero di riga [Numero linea], tutto è incluso. Fantastico, giusto?
rastrellare ti dà una panoramica dei numeri di versione per:
