Share
Denna artikel förklarar grunderna i Rake. Det är ett super populärt byggverktyg som är skrivet i Ruby. Det ger mycket flexibilitet och används för att hantera alla typer av uppgifter. Om du använder Rails rekommenderar jag att du tittar under huven för att ta reda på vilka uppgifter som står till ditt förfogande och hur du skriver din egen.
Tack vare Rails har Rake blivit en de facto-standard som ett Ruby-byggverktyg. Det är super populärt i Ruby-samhället. Mycket tidigt bestämde laget bakom Rails att använda Rake som byggare för Rails själv, vilket innebar att du tidigare behövde en kopia av Rake i det förflutna när du laddade ner Rails. På så sätt utsattes Rake för många människor. Lite senare var det inkluderat i Ruby (1.9) själv.
Rake de facto ersatt Unix-verktyget Gör som ett byggverktyg i Ruby land. Ett byggverktyg som Rake är användbart för att automatisera olika slags uppdrag, en programvara för hantering av uppgifter i grund och botten. Det används ofta för administrativa uppgifter i Rails-det är där du sannolikt har stött på det hittills, men dess användningsfall är mycket. Vissa människor skriver sina e-böcker i Markdown och har satt upp Rake-uppgifter som konverterar relevanta filer till mellanliggande HTML-filer, som i sin tur omvandlas till ebook-format, till exempel. Sparar mycket problem att använda Rake för det.
Det som gör Rake riktigt kraftfullt är att dessa uppgifter kan relatera till varandra och kan byggas ovanpå varandra. Dessutom, eftersom det är skrivet i Ruby, kan du skriva någon Ruby-kod för dina uppgifter. Vill du använda Ruby-bibliotek i dina Rake-uppgifter? Inga problem! Roligt faktum: det är den mest nedladdade RubyGem, med över 100 miljoner nedladdningar. Så definitivt något i ditt verktygsband att du borde betala lite mer uppmärksamhet åt.
Den var tänkt av den sena Jim Weirich, en välkänd och älskad utvecklare, talare och bidragsgivare till Ruby-ekosystemet. Det är ett vackert verktyg, tack, Jim! VILA I FRID!
Låt oss ta en titt på några uppgifter som Rails erbjuder direkt ur lådan. Jag slår vad om att du är lite förvånad över vad som är tillgängligt om du inte har kontrollerat förut. I den relevanta katalogen i din app eller din Rakefile kan du lista dem genom att skriva följande i ett skal:
rake - väskor # eller rake -T
rake om # Lista versioner av alla Rails-ramar och miljön rake-tillgångar: ren [behåll] # Ta bort gamla sammanslagna tillgångar rake-tillgångar: clobber # Ta bort sammanställda tillgångar rake-tillgångar: miljö # Ladda tillgången kompilera miljön rake-tillgångar: förkompilera # Kompilera alla tillgångar uppkallad i config.assets.precompile rake cache_digests: beroenden # Sök efter första nivå beroenden för TEMPLATE (som meddelanden / visa eller komm ... rake cache_digests: nested_dependencies # Lookup nestade beroenden för TEMPLATE (som meddelanden / visa eller kommentarer / ... rake db: skapa # Skapar databasen från DATABASE_URL eller config / database.yml för cu ... rake db: drop # Släpper databasen från DATABASE_URL eller config / database.yml för curr ... rake db: fixtures: load # Lastanordningar i den aktuella miljöens databas rake db: migrera # Migrera databasen (alternativ: VERSION = x, VERBOSE = false, SCOPE = blogg) rake db: migrera: status # Visa status för migreringar rake db: rollback # Rullar schemat tillbaka till föregående vers på (ange steg w / STEP = n) rake db: schema: cache: clear # Rensa en db / schema_cache.dump fil rake db: schema: cache: dump # Skapa en db / schema_cache.dump fil rake db: schema: dump # Skapa en db / schema.rb-fil som är portabel mot vilken DB som helst som stöds av AR rake db: schema: ladda # Ladda en schema.rb-fil i databasen rake db: frö # Ladda frödata från db / seed.rb rake db: setup # Skapa databasen, ladda schemat och initiera med frödata ... rake db: struktur: dump # Dump databasstrukturen till db / structure.sql rake db: struktur: ladda # Återskapa databaserna från strukturen. sql file rake db: version # Hämtar nuvarande schemaversionsnummer rake doc: app # Generera dokument för appen - även tillgängligt doc: rails, doc: guides (optio ... rake logg: clear # Avkortar alla * .loggfiler i logg / till noll byte (ange vilka loggar med ... rake middleware # Skriver ut dina racknoteringar för Rack middleware stack # Räkna upp alla anteckningar (använd anteckningar: optimera, fixme,: todo for focus) es: custom # Räkna upp en anpassad anteckning, ange med ANNOTATION = CUSTOM rake rails: mall # Tillämpar mallen levererad av LOCATION = (/ path / to / mall) eller URL rake rails: uppdatera # Update configs och några andra ursprungligen genererade filer ( eller använd bara uppdatera ... rake-rutter # Skriv ut alla definierade rutter i matchningsordning, med namnen rake secret # Skapa en kryptografiskt säker hemlig nyckel (detta används vanligtvis t ... rake spec # Kör alla specifikationer i spec-katalogen (exklusive plugin specs) rake spec: controllers # Kör kodexemplen i spec / controllers rake spec: features # Kör kodexemplen i spec / features rake spec: helpers # Kör kodexemplen i spec / helpers rake spec: models # Kör kodexemplen i spec / modeller rake spec: visningar # Kör kodexemplen i spec / visnings rake statistik # Rapportkodsstatistik (KLOCs, etc) från applikations- eller motorns rake-tid: zoner: alla # Visar alla tidszoner, även tillgängliga: tid: zoner: oss , tid: zoner: lokal ... rake tmp: clear # Clear session, cache, och socket-filer från tmp / (smala w / tmp: sessioner ... rake tmp: skapa # Skapar tmp-kataloger för sessioner, cache, uttag och pids
Utmatningen i en Rails-app är förvånansvärt riklig, eller hur? Du kan hitta mycket mer praktiska uppgifter än de vanliga rake db: migrera eller rake rutter att vi är så bekanta med och kör flera gånger på daglig basis.
Till vänster ser du de olika uppgifterna och till höger ser du vad som eventuellt tillhandahålls som en beskrivning för varje rake-uppgift. Om du vill se hela listan, som bland annat även innehåller uppgifter som saknar en beskrivning, måste du lägga till en ytterligare flagga.
rake -T-A # eller rake -T -all
rake om # Lista versioner av alla Rails-ramar och miljön rake-tillgångar: ren [behåll] # Ta bort gamla sammanslagna tillgångar rake-tillgångar: clobber # Ta bort sammanställda tillgångar rake-tillgångar: miljö # Ladda tillgången kompilera miljön rake-tillgångar: förkompilera # Kompilera alla tillgångar namngiven i config.assets.precompile rake cache_digests: beroenden # Lookup på grundnivå beroende på TEMPLATE (som meddelanden / visa eller kommentarer / _comment.html) rake cache_digests: nested_dependencies # Lookup nestade beroenden för TEMPLATE (som meddelanden / visa eller kommentarer / _comment .html) rake db: _dump # rake db: abort_if_pending_migrations # rake db: charset # rake db: collation # rake db: skapa # Skapar databasen från DATABASE_URL eller config / database.yml för den aktuella RAILS_ENV (använd db: skapa: allt att skapa alla databaser i config) rake db: skapa: all # rake db: drop # Släpper databasen från DATABASE_URL eller config / database.yml för den aktuella RAILS_ENV (använd db: drop: alla att släppa alla databaser i config) rake db : droppe: alla # rake db: fixtures: identifiera # rake db: fixtures: load # Ladda fixturer i den aktuella miljöens databas rake db: framåt # rake db: load_config # rake db: migrera # Migrera databasen (alternativ: VERSION = x , VERBOSE = false, SCOPE = blogg) rake db: migrera: ner # rake db: migrera: redo # rake db: migrera: återställ # rake db: migrera: status # Visa status för migreringar rake db: migrera: upp # rake db : rensa # rake db: rena: alla # rake db: återställa # rake db: rollback # Rulla schemat tillbaka till föregående version (ange steg w / STEP = n) rake db: schema: cache: clear # Rensa en db / schema_cache.dump file rake db: schema: cache: dump # Skapa en db / schema_cache.dump fil rake db: schema: dump # Skapa en db / schema.rb-fil som är portabel mot en DB som stöds av AR rake db: schema: ladda # Ladda en schema.rb-fil i databasen rake db: schema: load_if_ruby # rake db: frö # Ladda frödata från db / seeds.rb rake db: setup # Skapa databasen, ladda schemat och initiera med frödata (använd db: återställ för att även släppa databasen först) rake db: struktur: dump # Dump databasstrukturen till db / structure.sql rake db: struktur: ladda # Återskapa databaserna från struktur.sql file rake db: struktur: load_if_sql # rake db: test: klon # rake db: test: klon_schema # rake db: test: clone_structure # rake db: test: deprecated # rake db: test: ladda # rake db: test: load_schema # rake db: test: load_structure # rake db: test : förbereda # rake db: test: rena # rake db: version # Hämtar nuvarande schemaversionsnummer rake default # rake doc # rake doc / app # rake doc / app / created.rid # rake doc: app # Generera docs för app - även tillgängligt doc: rails, doc: guider (alternativ: TEMPLATE = / rdoc-template.rb, TITLE = "Anpassad titel") rake doc: clobber # rake doc: clobber_app # rake doc: clobber_rails # rake doc: guider # rake doc: rails # rake doc: reapp # rake doc: rerails # rake miljö # rake html # rake html / created.rid # rake logg: clear # Avkortar alla * .logfiler i logg / till noll byte (specificera vilka loggar med LOGS = test, utveckling) rake magic # Magic rake task rake middleware # Skriver ut din Rack middleware stack rake no_description # rake notes # Räkna upp alla anteckningar (använd anteckningar: optimera: fixme,: todo for focus) rake noteringar: custom # anpassad anteckning, ange med ANNOTATION = CUSTOM rake-anteckningar: fixme # rake noteringar: optimera # rake noter: todo # rake rails: mall # Använd mallen som tillhandahålls av LOCATION = (/ path / to / template) eller URL rake rails: mallar: kopiera # rake rails: update # Uppdatera configs och några andra ursprungligen genererade filer (eller använd bara uppdatera: konfigs eller uppdatera: bin) rake rails: update: bin # rake rails: uppdatering: configs # rake railties: installera: migreringar # rake rutter # Skriv ut alla definierade rutter i matchningsordning, med namnen rake secret # Skapa en kryptografiskt säker hemlig nyckel (det här brukar användas för att skapa en hemlighet för cookie-sessioner) rake spec # Kör alla specifikationer i spec katalog (exklusive plugin specs) rake spec : controllers # Kör kodexemplen i spec / con trollers rake spec: features # Kör kodexemplen i spec / features rake spec: helpers # Kör kodexemplen i spec / helpers rake spec: models # Kör kodexemplen i spec / models rake spec: förbereda # rake spec: statsetup # rake spec: views # Kör kodexemplen i spec / view rake statistik # Rapportkodsstatistik (KLOCs, etc) från applikations- eller motorns rake-tid: zoner: alla # Visar alla tidszoner, även tillgängliga: tid: zoner: oss, tid: zoner: lokal - filter med OFFSET-parameter, t.ex. OFFSET = -6 rake tid: zoner: lokal # rake tid: zoner: us # rake tmp # rake tmp / cache # rake tmp / cache / tillgångar # rake tmp / cache / assets / development # rake tmp / cache / assets / production # rake tmp / cache / assets / test # rake tmp / pids # rake tmp / sessioner # rake tmp / sockets # rake tmp: cache: clear # rake tmp: clear # Rensa sessions-, cache- och socketfiler från tmp / (smala w / tmp: sessioner: clear, tmp: cache: clear, tmp: sockets: clear) rake tmp: skapa # Skapar tmp-kataloger för sessioner, cache, uttag och pids rake tmp : pids: clear # rake tmp: sessioner: clear # rake tmp: sockets: clear #
Överraskning, nästan tre gånger så mycket! Ta en titt på dem och lek om du vill, men begå höjdpunkterna till minne för senare användning i framtiden. Om du kontrollerar uppgifterna för att se vad som är tillgängligt kan du hindra dig från att uppfinna hjulet igen.
En Rakefile kan ha en av följande fem utseenden:
För det mesta ser du slätten Rakefile version, men ett ramverk som Rails behöver en mer komplex organisation. Använd vad som helst som får blodet att flöda. Du börjar med att skapa en Rakefile eller filer med en .räfsa förlängning om du vill dela upp uppgifter logiskt över flera filer. Definiera sedan dina uppgifter i någon av dem.
Rails gör det otroligt enkelt. Den har en Rakefile i roten på din app. Den innehåller följande:
Accentsconagua
kräver File.expand_path ('... / config / application', __FILE__) Rails.application.load_tasksNär du har många anpassade uppgifter är det mer meningsfullt att dela dem i diskreta .räfsa filer och placera dem in lib / uppgifter. Rakefilen ovan laddar bara dem, men lib katalog är ett bättre logiskt hem för uppgifterna. Det finns även en Railsgenerator för att automatisera en del av processen. Om du skriver:
rails generera some_task => skapa lib / tasks / some_task.rake
Du kommer att få en Rakefile placerad automatiskt i rätt katalog. Även uppgiften är redan inrättad för dig. Trevlig! I andra projekt, som inte använder Rails, behöver du bara skapa en rakelib katalog och placera dina Rakefiles där-helst med .räfsa filtillägg. Skapa sedan en fil som heter Rakefile och alla dessa filer finns redan till ditt förfogande.
desc "Lista versioner av alla Rails ramar och miljön" uppgift: om sätter "Vissa magiker går in här ..." slutet
För de kompletta Ruby nybörjarna bland dig, och för människor som kommer från bracket-tunga språk, så här ser det ut med parentes.
desc ("Lista versioner av alla Rails ramar och miljön") uppgift (: om) gör sätter ("Något magi går in här ...") slutetSer väldigt konstigt ut förresten. Bara förlora de extra parenteserna - ingen skriver uppdrag på detta sätt.
Vi gav en namngiven uppgift :handla om med en beskrivning som inte bara påminner oss om framtiden vad vi ville uppnå med specifika uppgifter, men visar också upp när vi kör rake -T. Bli inte lat på denna del; det är nog inte värt det.
Längre nedan är nyckelordsuppgiften som definierar en ny uppgift som heter handla om. Detta kan åberopas på kommandoraden via rake om vilken gör dess magi då. rake: ca Å andra sidan kommer Rake att avbryta, inte veta "hur man bygger upp uppgift: om".
Via sluta blockera, vi har a lambda, och dess kropp anger vad uppgiften gör. Det här är den grundläggande inställningen som en uppgift behöver. Det erbjuder naturligtvis många fler alternativ, men den övergripande strukturen är densamma.
kräver './whatever.rb'
Om du behöver inkludera andra Ruby-filer eller Rakefiles kan det enkelt uppnås med en standard fordra påstående.
importera "whatever.rb"
Rake sig ger oss ett annat sätt att göra det här importera metod. Detta kan användas i vilken linje som helst i Rakefile. Den här hjälper dig när du stöter på problem eftersom den begärda filen laddades innan Rakefile slutade ladda och blåste upp därför. Den importerade filen kommer däremot alltid att laddas efter Rakefile.
Ibland kanske du vill utföra en viss definierad uppgift från din Uppgift klass manuellt. För detta ändamål har du två metoder för Rake :: Task klass: Kör och åberopa.
Rake :: Uppgift ['some_task']. Åberopa Rake :: Uppgift ['some_task']. Execute
Med Rake :: Task [ 'some_task'] kod, vi har some_task Rake uppgift att utföra. Den returnerar en instans av Rake :: Task klass och kör sedan någon metod på den som är tillgänglig.
En mycket cool funktion är möjligheten att namnge dina uppgifter. Du har nog redan använt dessa dussintals gånger. När du kör rake db: migrera, du har utnyttjat db namnrymd, till exempel. Du åberopar uppgiften genom att skilja den med ett kolon : från namnutrymmet. Namnrymder är ett praktiskt sätt att organisera dina uppgifter inom en rakefil - det håller dem logiskt åtskilda. Flera namnområden som rake tid: zoner: allt är bra, förresten.
Andra exempel inkluderar:
rake db: drop rake db: rake db: rake db: rake db: schema: ladda rake assets: precompile rake db: migrera: status
namespace: db do desc "Migrera några saker" uppgift: migrera gör ... änden
Det här är den grundläggande inställningen. I verkligheten är det mycket mer komplicerat och kan till och med vara kapslat flera gånger. Ta en snabb titt på Rails kodbas och se själv hur rake db: migrera är implementerad. Känn inte dåligt om det är över huvudet. Titta bara, försök att urskilja hur det är strukturerat och fortsätt för nu.
En annan strategi för att organisera dina uppgifter och att behålla dem DRY använder förutsättningar för att utföra en uppgift. Det är som ett beroende som måste springa först innan den faktiska uppgiften startar sitt jobb. På så sätt kan du bygga upp mer komplexa uppgifter - så komplicerat som du behöver. Men jag skulle rekommendera att inte bli för smart och att hålla den så enkel som möjligt - och så lätt att förstå som möjligt också.
uppgift: stop_megalomaniac sätter "Massor av smarta prat, bilchaser och vapen avfyras" slutuppgift: bond_saves_the_day =>: stop_psychotic_megalomaniac sätter "Massor av Dom Pérignon, ostron och bond girl business" slutet
Om du vill förlita dig på flera uppgifter, håller du bara in dem i en array. Den ordning i vilken du placerar dem betyder självklart.
uppgift: get_mr_wolf sätter "Du har inget problem Jules, jag är på! Gå in där och slappna av dem och vänta på vargen som ska komma direkt!" slutlig uppgift: figure_out_bonnie_situation sätter "Om jag blev informerad korrekt, klockan kollar. Är det rätt Jimmy?" slutlig uppgift: calm_down_jimmy sätter "Jimmy, gör mig en tjänst, vill du? Jag luktade lite kaffe tillbaka där. Skulle du göra mig en kopp?" slutlig uppgift: get_vince_vega_in_line sätter "Kom igen? Hämta det rakt buster. Jag är inte här för att säga tack! Jag är här för att berätta vad du ska göra!" slutlig uppgift: clean_car sätter "Jag behöver dig två fellas för att ta dessa rengöringsprodukter och rengöra insidan av bilen. Jag pratar snabbt, snabbt, snabbt!" slutlig uppgift: clean_crew sätter "Jim, tvålen! Också herrar, du har varit länet innan jag är säker. Här kommer det!" slutlig uppgift: get_rid_of_evidence_at_monster_joes sätter "Så vad är det med outfitsna? Du kommer till ett volleybollspel eller något?" slutet uppgift: drive_into_the_sunrise sätter "Call me Winston!" avsluta uppgiften: 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] sätter "Du vet att jag skulle gå till frukost. ?" slutet
Om du kör rakeuppgiften som beror på den andra får vi följande utdata:
$ rake solve_bonnie_situation Du har inget problem Jules, jag är på den! Gå in där och slappna av dem och vänta på vargen som borde komma direkt! Jimmy, gör mig en tjänst, vill du? Jag luktade lite kaffe tillbaka där. Skulle du göra mig en kopp? Om jag blev korrekt informerad klockar klockan. Är det rätt Jimmy? Kom igen? Få det rakt buster. Jag är inte här för att säga tack! Jag är här för att berätta vad du ska göra! Jag behöver dig två fellas att ta dessa rengöringsmedel och rengöra insidan av bilen. Jag pratar snabbt, snabbt, snabbt! Jim, tvålen! OK. herrar, ni båda varit länet innan jag är säker. Här kommer det! Så vad är det med kläderna? Går ni till ett volleybollspel eller något? Ring mig Winston! Du vet att jag skulle gå till frukost. Känner som att ha frukost med mig?
Den ordning i vilken du definierar dina rake-uppgifter har ingen inverkan på utmatningen - endast den ordning i vilken du ställer förutsättningsuppgifterna i arrayen för uppgiftsberoende. Också, använd ishrocket => syntax för detta.
En lång lista över beroenden kan vara en kodlukt. Om du måste ta itu med någonting långa, rengör du det genom att inkapslera det inuti en metod som vi sedan passerar som en förutsättning.
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] än ... uppgift: solve_bonnie_situation => mr_wolf_tasks lägger 'Du vet att jag skulle gå till frukost. Känner du att ha frukost med mig? " slutet
I samband med förutsättningar är en sak att tänka på att du bara behöver nämna en namnrymd om du är utanför den relevanta.
namespace: marsellus_wallace do task: call_winston_wolf gör ... slutändans uppgift: solve_bonnie_situation => 'marsellus_wallace: call_winston_wolf' do ... slut namnrymd: marsellus_wallace gör uppgift: call_winston_wolf do ... slutuppgift: solve_bonnie_situation =>: call_winston_wolf do ... slutet
Viktigt att notera, men: om du behöver nämna namnrymden måste du klara förutsättningen som en sträng => 'marsellus_wallace: call_winston_wolf'.
Naturligtvis är exemplen ovan goofiga och inte egentliga exempel, men avsikten var att visa dig hur förutsättningarna fungerar och hur du skulle sätta dem ihop medan de är beroende av varandra.
Du har två alternativ att skicka argument till Rake-uppgifter: antingen genom att använda Bash-variabler eller genom att använda sig av Rake's syntax själv.
Om du inte har spelat med Bash innan-eller Bash låter som gobbledegook till dig-låt oss ta fem och börja från början. Bash i ditt skal erbjuder två typer av variabler: globala (aka-miljö) variabler och lokala. Båda är skrivna i stor bokstav. Miljövariablerna är globala, vilket betyder att de är tillgängliga i alla skal och inte försvinner när du stänger en till skillnad från lokala basvariabler som endast är tillgängliga i det nuvarande skalet.
Miljövariabler kan innehålla data som kan användas av flera applikationer och används ofta som ett användbart sätt att dela konfigurationsinställningar. Till skillnad från det är lokala Bash-variabler bara det lokala. I vårt sammanhang att använda Rake har du möjlighet att få tillgång till både via Ruby och effektpass variabler från kommandoraden.
Precis som lite åt sidan, om du skriver env eller ENV I ditt skal får du tillgång till en hel massa miljövariabler. Jag redigerade listan, men för att bättre förstå vad miljövariabler är och vad de innehåller, uppmuntrar jag dig att köra det för er själva.
env
TERM_PROGRAM = Apple_Terminal TERM = skärm-256färg SHELL = / bin / bash TMUX = / privat / var / mappar / 4z / 3np9k5ks62b1xpbn_w_lmrgh0000gr / T / tmux-504 / default, 4146,0 EDITOR = vim LANG = en_US.UTF-8 TMUX_PANE = % 1 is_vim = eko "# pane_current_command" | grep -iqE "(^ | \ / g) (se | n? vim? x?) (diff)? $" ...
Om du vill se en lista med lokala Bash-variabler kan du springa uppsättning.
(set -o posix; set) | mindre
De uppsättning kommandot ger dig mycket mer effekt, men ovanstående visar de relevanta bitarna direkt.
Ruby erbjuder ett sätt att använda både miljö och lokala Bash-variabler via en hash-liknande accessor. För våra behov, när vi överför en variabel till en Rake-uppgift, kommer det att bli en lokal Bash-variabel, som du kan hitta i listan över variabler som körs uppsättning eller en variation av det. Ruby kan läsa ut det med ENV [ 'VARIABEL'].
rake prepare_book BOOKTITLE = "Confessions of a unicorn"
Vad jag vill klargöra är dock att denna variabel inte kommer att läggas till i ENV-listan som ditt system använder - de saker som du såg att ringa env från skalet. För att lägga till den i listan, skulle du behöva exportera Det. Det här är en annan historia, men jag trodde jag skulle klargöra det.
uppgift: prepare_book do book_title = ENV ['BOOKTITLE'] || "Working Title" sätter "Gör något med # book_title" slutet
I den här uppgiftsdefinitionen kan du se hur vi förberedde oss för att acceptera eller införliva variabeln som skickats till uppmaningen. Rubys ENV [BASHVARIABLE] gör allt tungt lyft. Om BOKTITEL hade varit en global miljövariabel, men vi kunde även ha tillgång till den inom denna uppgiftsdefinition med denna syntax.
Det andra tillvägagångssättet använder ren Rake-syntax. Du skickar helt enkelt variabler i fyrkantiga hängslen. Det här tillvägagångssättet är bättre, och du kan hålla sakerna mer isolerade. Varför involverar Bash om Rake är helt kapabel att hantera detta? Dessutom har du inga Bash-variabler som flyter runt den vägen. Om du vill skicka flera argument till en uppgift är det också mycket mer elegant.
rake "create_mi6_agent [James, Bond, 007]"
uppgift: create_mi6_agent, [: first_name,: last_name,: number] do | t, args | sätter "Nummer # args.number är kommandot # args.first_name # args.last_name." slutet
När du skickar in fler argument än vad du har definierat i din uppgift, kan du helt enkelt komma åt dem via args. args.extras visar en uppsättning av alla ytterligare passerade parametrar. args.to_a visar dig alla parametrar-i en uppsättning också, förstås.
Nedan är en kort lista över Rake-uppgifter som följer med Rails:
Nedan följer några användbara uppgifter under db namnrymd för att köra Active Record-migreringar:
rake db: version skriver ut den aktuella versionen av schemat. Utsignalen ser något ut så här:
Nuvarande version: 20160129135912
rake db: migrera kör den sista migrationen (s) - de som inte har kört än. Du kan också ge den en viss migrering för att köra.
rake db: migrera VERSION = 20080906120000
rake db: skapa skapar din databas Om standard till utvecklings- och testdatabaser.
db / development.sqlite3 db / test.sqlite3
rake db: test: förbereda ser till att migreringar som redan körs på din utvecklingsdatabas körs även för din testdatabas. Om testdatabasens schema inte var synkroniserat med din utvecklingsdatabas, skulle det inte vara mycket användbart självklart.
rake db: drop: all droppar både test- och utvecklingsdatabaser som standard.
rake db: migrera: upp, rake db: migrera: ner kör den upp och ner metoder för migrering i fråga.
rake db: redo säkerställer att migreringen är reversibel när du har kört en migrering. Den springer rake db: ner först och då rake db: up.
rake db: rollback ångrar den senaste migreringen.
rake db: drop faller av utvecklings- och testdatabaser som standard.
rake db: återställ släpper databaserna först och sätter upp dem igen genom att ladda schemat och sådda databasen.
rake doc: app genererar dokumentation under doc / app. Det skapar HTML-sidor om källkoden för enkel sökning. Ganska cool!
rake doc: rails genererar en API dokumentation under doc / api-även som HTML-sidor. Praktiskt om du är offline, antar jag.
De tmp katalog i rotkatalogen i din Rails-app är platsen för tillfälliga filer - mest framträdande filer för sessioner och cacheminne. rake tmp: skapa ställer upp dig med allt du behöver för att hantera tillfälliga filer. rake tmp: cache: clear rensar tmp / cache katalog. rake tmp: sessioner: clear rensar tmp / sessioner katalog.
rake statistik ger dig en fin översikt över din app.
+----------------------+-------+-------+---------+---------+-----+-------+ | Namn | Linjer | LOC | Klasser | Metoder | M / C | LOC / M | + ---------------------- + ------- + ------- + --------- + --------- + ----- + ------- + | Controllers | 89 | 69 | 6 | 18 | 3 | 1 | | Hjälpare | 13 | 13 | 0 | 1 | 0 | 11 | | Modeller | 89 | 54 | 6 | 7 | 1 | 5 | | Mailers | 0 | 0 | 0 | 0 | 0 | 0 | | Javascripts | 25 | 0 | 0 | 0 | 0 | 0 | | Bibliotek | 0 | 0 | 0 | 0 | 0 | 0 | | Controller specs | 99 | 81 | 0 | 0 | 0 | 0 | | Funktionsspecifikationer | 14 | 11 | 0 | 0 | 0 | 0 | | Helperspecifikationer | 45 | 12 | 0 | 0 | 0 | 0 | | Modellspecifikationer | 10 | 8 | 0 | 0 | 0 | 0 | | Visa specifikationer | 60 | 48 | 0 | 0 | 0 | 0 | + ---------------------- + ------- + ------- + --------- + --------- + ----- + ------- + | Totalt | 444 | 296 | 12 | 26 | 2 | 9 | + ---------------------- + ------- + ------- + --------- + --------- + ----- + ------- + Kod LOC: 136 Test LOC: 160 Kod till testförhållande: 1: 1.2
Du kan lämna anteckningar i din kod. Du kan prefixa dem i dina kommentarer med ATT GÖRA, FIXA MIG, OPTIMERA.
# FIXME Något att fixa här klassen Agent < ActiveRecord::Base belongs_to :operation belongs_to :mission…
När du kör rake noter, Rake analyserar dessa prefix och får dig en lista över alla dessa anteckningar från din kod.
app / models / agent.rb: * [1] [FIXME] Något att fixa här
Du får även en detaljerad lista där du hittar dem-katalog, filnamn, radnummer [Linje nummer], allt ingår. Häftigt, rätt?
rake om ger dig en översikt över versionsnummer för:
och massor av annan användbar information.
Om du är paranoid om din sessionsnyckel och vill byta ut den, rake hemlighet kommer att skapa en ny pseudo-slumpmässig nyckel för dig. Det ersätter dock inte nyckeln för dig. Utgången i skalet ser ut så här:
b40a74b94cd93fed370fd4f8f9333633c03990b7d9128383511de5240acf3fa6b6b07127e875814fdadb32f1aa44d69c4e82592b0ce97f763ea216a21e61881d
rake tillgångar: förkompilera låter dig förkompilera dina tillgångar under offentliga / tillgångar. Om du vill bli av med äldre tillgångar, spring bara rake tillgångar: ren. Slutligen kör rake tillgångar: clobber raderar hela offentliga / tillgångar katalog.
rake rutter kan vara den viktigaste. Det visar dig alla rutter i din app.
Skriva Rake-uppgifter utan att veta vad som händer under huven blir tråkigt ganska snabbt. Denna artikel var en liten uppvärmning och introduktion för människor som ville kika in i Rake för första gången.
Jag hoppas att det täckte alla grunderna utan att vara för torr - trots allt är Rake super dope och allt, men det är kanske inte den sexigaste leksakerna. Denna grundläggande kunskap om Rake bör dock ge dig allt du behöver för
