Share
Ai reușit să faci tutorialul avansat. Foarte bine! Acum pentru lucrarea reală. Alfred poate fi folosit pentru a face unele lucruri complicate, inclusiv programare recursivă! Conceptele de aici nu sunt ușor și nu pentru programatorul neexperimentat.
Filtru de scripturi este ultimul tip de bloc de discutat. Ca Filtru fișiere, A Filtru de scripturi oferă utilizatorului o listă de opțiuni din care să selectați. Diferența fiind, a Filtru de scripturi permite programatorului să creeze lista de opțiuni cu un script.
O alegere simplă de alegere pentru crearea unui proiect în dosarul proiectului va arăta utilizarea unui a Filtru de scripturi. Mai întâi, adăugați a Filtru de scripturi la Fluxul de lucru al managerului de proiect din tutorialul intermediar.
Seteaza cuvinte cheie la PM: crearea, verifică cu spațiu bifați caseta de validare, setați tipul argumentului la Argument Opțional, Title placeholder la Creați un proiect, Subtextul Substituent la Manager de proiect, "Vă rugăm să așteptați" subtext la Loading Options ... . Cele mai multe dintre aceste opțiuni sunt aceleași ca și în alte casete.
cu spațiu din caseta de validare îi spune lui Alfred să aștepte un spațiu înainte de argumentul opțional. Prin urmare, se va desprinde spațiul de conducere înainte de a trece argumentul la scenariu. În caz contrar, va trece pur și simplu totul după cuvinte cheie la scriptul pentru acest bloc.
Tipul argumentelor Selectorul are trei valori: Argumentul necesar, Argument Opțional, și Nici un argument. Argumentul necesar nu va accepta un retur de transport până când nu este dat un argument după cuvântul cheie. Acesta va trece totul la script ca tip utilizator. Argument Opțional va permite utilizatorului să atingă intrarea fără un argument dat. Nici un argument va trece la următorul cuvânt cheie care se potrivește dacă utilizatorul începe să dea un argument. În caz contrar, aceasta scade la o căutare implicită.
"Vă rugăm să așteptați" subtext vă permite să oferiți un subtext utilizatorului în timp ce scriptul din Filtru de scripturi este executată. Acest lucru permite utilizatorului scriptului să știe dacă toate opțiunile sunt disponibile sau nu.
Zona casetă de script este la fel ca a Rulați scriptul bloc. Alegeți limba de programare dorită, ce opțiuni de scăpare aveți nevoie și scriptul însuși. Setați-l la / Usr / bin / php, toate scapă și următorul script:
ecou <<EOF; Site-ul HTML de bază Manager de proiect icon.png Backbone Site-ul HTML Manager de proiect icon.png
Acest script PHP elimină XML pentru rezultatele scriptului. A Filtru de scripturi se așteaptă ca scriptul să emită o instrucțiune XML validă care conține o serie de elemente: una pentru fiecare opțiune disponibilă pentru utilizator.
Fiecare element are a uid, arg, valabil, și Completare automată Opțiuni. uid este un număr sau un nume unic pentru elementul respectiv. Dacă este întotdeauna același nume unic pentru acel element, cu cât îl selectează mai mult un utilizator, cu atât mai mult va fi plasat în partea de sus a listei. arg este ceea ce următorul bloc va primi dacă acel element este selectat. valabil argumentul poate fi doar da sau Nu. Dacă Nu, atunci acel element nu poate fi selectat, ci Completare automată valoarea va fi plasată în Alfred Prompt cu cuvântul cheie. Dacă da, atunci va accepta o intrare pentru a trimite argumentul la următorul bloc și la Completare automată valoarea este ignorată.
titlu, subtitlu, și icoană copiii din fiecare element permit scriptului să stabilească titlul, subtitrarea și pictograma folosite pentru a afișa rezultatele utilizatorului. Prin urmare, fiecare element poate avea o altă pictogramă. Dacă aveți un subdirector în zona fluxului de lucru numit icoane, puteți utiliza icoane / day.png calea de a se referi la o imagine numită day.png în subfolderul respectiv. Acest lucru vă permite să vă personalizați rezultatele pentru o selecție mai ușoară.
Acum, când Filtru de scripturi este activată, imaginile de mai sus arată rezultatele. Încă nu va efectua nimic decât trimiterea selecției către Alfred.
Pentru a face ceva bazat pe selecție, va trebui să adăugați o Rulați scriptul blocați-l și completați-l ca pe un script bash fără a scăpa. Zona scenariului poate fi umplută cu următorul script:
######################### # Contani. ######################### VPREFS = "$ HOME /Library/Caches/com.runningwithcrayons.Alfred-2/Workflow Data /" NVPREFS = "$ HOME / Bibliotecă / Suport pentru aplicații / Alfred 2 / Date despre fluxul de lucru /" ################################################################ ################################################ # Citit bundleid-ul din fluxul de lucru info.plist ################################## "################################# getBundleId () / usr / libexec / PlistBuddy -c" Print: bundleid "" info.plist " #################################### ######################################################################################################## ################################################## ######################## getDataDir () local BUNDLEID = $ (getBundleId) echo "$ NVPREFS $ BUNDLEID" dacă [! -d "$ (getDataDir)"; apoi mkdir -p "$ (getDataDir)"; atinge "$ (getDataDir) /projectDir.txt"; fi projD = "pisică" $ (getDataDir) /projectDir.txt ""; dacă [ ! -d "$ projD"]; apoi mkdir -p "$ projD"; fi cd "$ projD"; type = "query"; cazul "$ type" în bază) echo "Basic"; curl -o tmp.zip -L "https://codeload.github.com/h5bp/html5-boilerplate/zip/v4.3.0"; dezarhivați tmp.zip >> / dev / null; mv html5-boilerplate-4.3.0 / *. ; rm -Rf "html5-boilerplate-4.3.0 /"; rm -Rf "tmp.zip"; echo "Placa de bază HTML5 în loc."; ;; backbone) ecoul "BackBone"; curl -o tmp.zip -L "https://codeload.github.com/h5bp/html5-boilerplate/zip/v4.3.0"; dezarhivați tmp.zip >> / dev / null; mv html5-boilerplate-4.3.0 / *. ; rm -Rf "html5-boilerplate-4.3.0 /"; rm -Rf "tmp.zip"; curl -o js / vendor / backbone-min.js -L "http://backbonejs.org/backbone-min.js"; echo "Placă de bază HTML5 cu Backbone.js în loc."; ;; ESAC
Acest script creează pur și simplu tipul de proiect din directorul care a fost setat ca directorul proiectului. Prima parte a script-ului este la fel ca scripturile utilizate în tutorialul intermediar pentru a accesa cele două locuri pot fi stocate date. director de date si director cache. Aici, numai directorul de date este folosit pentru a obține locația directorului de proiect.
Restul scriptului se va muta în directorul proiectului și se va completa pe baza tipului de proiect selectat. Un proiect HTML de bază va descărca șablonul Bootplate HTML5 și îl va instala în directorul proiectului. Un proiect Backbone va instala șablonul HTML5 Boilerplate Template și biblioteca JavaScript Backbone.js. Acest lucru poate fi îmbunătățit cu ușurință prin utilizarea Yeoman pentru a instala componentele proiectului, dar acest lucru ar depăși scopul acestui tutorial.
Problema cu modul în care aceasta Filtru de scripturi a fost scris că este greu să se extindă și să se mențină. Ar fi mult mai ușor să apelați o funcție care va crea XML după cum este necesar. De asemenea, folosind această abordare a programului, utilizatorul nu poate restrânge lista de acțiuni posibile prin tastare. Ei vor trebui doar să se mute în jos pe listă sau să apese o tastă rapidă pentru acel element.
Din moment ce Alfred are de gând să facă mai ușor găsirea și selectarea opțiunilor, trebuie să existe o modalitate de a face acest lucru. Mulțumită tuturor programatorilor devotați care ajută la Alfred, există câteva biblioteci scrise care vor ajuta acest proces mult mai ușor.
Una dintre binecuvântările ecosistemului Alfred este că mulți oameni proiectează biblioteci pentru limbajul scriptului lor preferat pentru a facilita programarea lui Alfred. Lista completă a bibliotecilor Alfred poate fi găsită pe forumul Alfred. Există biblioteci pentru Bash / Zsh (bucăți din care le-am folosit în aceste scripturi), Python, PHP, Ruby, AppleScript și go (este listată ca o bibliotecă AppleScript, dar este pentru limbaje de programare Google)!
Pentru a utiliza biblioteca pentru PHP, va trebui să descărcați fișierul workflows.php de pe acest site de David Ferguson. Plasați-o în dosarul fluxului de lucru. Acum, acest script trebuie încărcat în codul PHP pentru Filtru de scripturi. Modificați codul respectiv la:
Accentsconagua
// // Încărcați biblioteca fluxului de lucru PHP. // include_once ("workflows.php"); // // Creați obiectul de flux de lucru de folosit. // $ wf = fluxuri de lucru noi (); // // Obțineți interogarea și păstrați-o pentru utilizare. // $ clean = trim ("query"); // // Setați opțiunile. // $ wf-> rezultat ("1PM", "basic", "Site-ul HTML de bază", "Project Manager", "icon.png", "da"); $ wf-> rezultat ("2PM", "backbone", "Backbone HTML Site", "Project Manager", "icon.png", "da"); // // Redați xml din alegeri. // echo $ wf-> toxml (); Acest lucru este mult mai ușor de citit și de înțeles. Comentariile pot fi adăugate cu ușurință pentru a explica codul pentru referințe viitoare. Acest lucru va da exact aceleași rezultate ca lista XML goală, dar acum este într-o formă care va face expansiunea mai ușoară.
Acest script se încarcă acum în bibliotecă și inițiază o variabilă de clasă, $ wf, din Fluxul de lucru () clasa din bibliotecă. rezultat() membră este folosită pentru a crea codul XML cu opțiunile. Opțiunile după comandă sunt: număr, arg, titlu, subtitlu, fișier icoane și valide. toxml () funcția membru returnează pur și simplu ultimul cod XML care este reluat.
Acum, pentru a face Filtru de scripturi arată mai bine. Luați cele două fișiere imagine din fișierul de descărcare pentru acest tutorial și adăugați-le în directorul de flux de lucru. Apoi schimbați Setați opțiunile secțiune în Filtru de scripturi cod la:
// // Setați opțiunile. // $ wf-> rezultat ("1PM", "basic", "Site-ul HTML de bază", "Project Manager", "html5BP.jpeg", "da"); $ wf-> rezultat ("2PM", "backbone", "Backbone HTML Site", "Project Manager", "backbone.png", "da"); Pictograma utilizată pentru fiecare alegere reprezintă acum alegerea. O interfață de utilizator mult mai bună. Alfred poate lua fie fișiere grafice JPEG, fie png pentru pictogramele. De asemenea, redimensionează icoanele după cum este necesar. Rezultatele sunt prezentate mai jos:
După cum se poate vedea, a doua opțiune este afișată mai întâi. Asta pentru că l-am folosit cel mai mult în timpul testelor. Alfred își amintește ce alegere este folosită cel mai mult și încearcă să comande lista în consecință. Acest lucru este util pentru comenzile care sunt utilizate mai frecvent.
Dar lista nu poate fi restrânsă prin tastarea unei părți a numelui. Aceasta este o adevărată necesitate dacă trebuie să existe mai multe alegeri. Din păcate, această bibliotecă PHP nu are o funcție pentru asta. Prin urmare, trebuie definită o nouă funcție. Modificați zona de opțiuni la aceasta:
// // Setați opțiunile. // $ added = buildResult ($ wf, "$ clean", "1PM", "basic", "Site de bază HTML", "Project Manager", "html5BP.jpeg", "da"); $ added + = buildResult ($ wf, "$ curat", "2PM", "backbone", "Backbone HTML Site", "Project Manager", "backbone.png", "da"); dacă $ added == 0) $ wf-> result ("999", "", nici un tip de proiect nu se potrivește cu $ clean! "," Project Manager "," icon.png "," no "); buildResult () funcția ia tot ceea ce rezultat() a funcționat, dar are și doi parametri noi: Fluxul de lucru () obiect variabilă și textul pentru a se potrivi cu comanda.
Acum, adăugați definiția noii funcții imediat după includerea bibliotecii:
funcția buildResult ($ wf, $ input, $ count, $ arg, $ titlu, $ subtitlu, $ icon, $ valid) $ result = 0; dacă (preg_match ("/.*$ input / i", "$ arg") === 1) $ wf-> rezultat ($ count, $ arg, $ title, $ subtitle, $ icon, $ valid); $ rezultat = 1; retur ($ rezultat); Această funcție utilizează funcția preg_match () Funcția PHP pentru a face o potrivire expresie regulată a șirului cu o carte salvată adăugată la șirul de intrare. Dacă tipul de utilizatori nu se potrivește, acesta nu va adăuga acel rezultat. Dacă a fost adăugat un rezultat, acesta va returna unul. În caz contrar, va reveni la 0.
Ați observat codul suplimentar adăugat? Asta a fost pentru a vedea dacă ceva a fost adăugat la rezultate. În cazul în care nu a trecut nimic din testul de a include ca rezultat, se adaugă un rezultat implicit, spunând că nu a putut găsi nimic. Cu valabil parametrul setat la Nu, utilizatorul nu poate lovi returnul. Acest lucru vă păstrează fluxul de lucru de la dumping de utilizator în căutare implicită cu tot pe Alfred Prompt sau de la trimiterea de junk la următoarea scenariu pentru a afla.
Cu acel pic de verificare a erorilor, fluxul de lucru acum spune cu ușurință utilizatorilor că există o problemă fără a provoca o cădere la căutarea implicită. Ar trebui să vă gândiți întotdeauna la tratarea erorilor în fluxurile de lucru. Este important pentru un aspect profesional.
Din moment ce Filtru de scripturi bloc continuă să apeleze scriptul pentru fiecare literă tastată de utilizator, acesta face un loc minunat de a face programare recursivă. Cel mai adesea programarea recursivă este menționată când o rutină se cheamă. Aceasta este recursiunea directă. Ce se face în Alfred's Filtru de scripturi ar fi numit recursiune indirectă.
Primul tip de recursiune de investigat este mașina de stat. O mașină de stat este un program care este controlat de o variabilă care determină starea sau nivelul de execuție al programului.
Fluxul de lucru al managerului de proiect are nevoie de o modalitate de urmărire a proiectelor și de realizare a anumitor acțiuni privind aceste proiecte. Pentru ao porni, creați o Filtru de scripturi blocați ca mai sus. Apoi adăugați acest script la scenariu zonă:
// // Încărcați biblioteca fluxului de lucru PHP. // include_once ("workflows.php"); // // Funcție: buildResult // // Descriere: Condiționați construirea rezultatului XML dacă intrarea // conține argumentul. // funcția buildResult ($ wf, $ input, $ count, $ arg, $ titlu, $ subtitlu, $ icon, $ valid, $ ret) $ result = 0; $ parts = explode ("|", $ arg); dacă (numără ($ parts)> 0) $ arg = $ parts [0]; if (preg_match ("/.*$ input / i", "$ arg") === 1) $ wf-> rezultat ($ count, $ arg, $ title, $ subtitle, $ ret); $ rezultat = 1; retur ($ rezultat); // // Creați obiectul de flux de lucru pe care să îl utilizați. // $ wf = fluxuri de lucru noi (); // // Obțineți interogarea și păstrați-o pentru utilizare. // $ clean = trim ("query"); // // Figurați starea prin elementele de tip quey. // $ parts = explode ("|", $ curat); $ pcount = count ($ parts); $ returncount = 0; comutator ($ pcount) caz 1: // // Aceasta este starea de bază. Aici este listată lista proiectelor și // capacitatea de a crea un nou proiect. // // // Obțineți și listați proiectele. // $ count = 0; $ filename = $ wf-> date (). "/Projects.txt"; dacă (file_exists ($ filename)) $ projs = explode ("\ n", file_get_contents (nume fișier $)); foreach ($ projs ca $ proj) $ projparts = explode (":", $ proj); dacă $ ($ projparts [0], "")! = 0) $ returncount + = buildResult ($ wf, $ parts [0], $ count, "$ projparts [0] $ projparts [0] "," Manager de proiect "," icon.png "," nu "," projparts [0] | "); $ număr + = 1; // // Oferiți o opțiune pentru un nou proiect. // $ wf-> rezultat ("999", "nou |", "Adăugați un nou proiect", "Project Manager", "icon.png", "nu", "nou |"); $ returncount + = 1; pauză; cazul 2: // // Două domenii posibile: Acționarea unui anumit proiect sau // crearea unui nou proiect. // if (strcmp ($ parts [0], "new") === 0) // // Creați un nou proiect. Obțineți numele. // $ wf-> result ("999", "new | $ parts [1]", "Nume proiect: $ parts [1]", "Project manager", "icon.png" “, "noi | $ părți [1]"); $ returncount + = 1; altceva // // Acum pentru a efectua acțiuni asupra unui proiect. // count = 1; $ $ parts [0], "$ parts [0]", "$ $ parts [0]" , "Manager de proiect", "icon.png", "da", ""); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++ "pml", "pow parts [0]", "Add to Pow: $ parts [0] "," Project Manager "," icon.png "," da "," "); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++ "pml", "alfred" $ parts [0] " "," Project Manager "," icon.png "," da "," "); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++ "pml", "current parts [0]", "Make Current Project: $ parts [0] "," Project Manager "," icon.png "," da "," "); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++. "pml", " "," Project Manager "," icon.png "," da "," "); pauză; Dacă ($ returncount < 1) $wf->Rezultat ("999", "", "Stare nevalidă! Începeți din nou", "Project Manager", "icon.png", "Nu", ""); // // Echo xml din alegeri. // echo $ wf-> toxml (); Începutul scriptului este exact ca ultimul scenariu; Logica a fost adăugată pentru a păstra prima parte a unei părți multiple $ arg (Cu alte cuvinte, un șir dat în $ arg care are parametrul | simbol.) la buildResult () funcţie.
Chiar după curățarea intrărilor de la Alfred, intrarea este împărțită în funcție de | și numărul de piese este calculat. Aceste informații furnizează starea mașinii de stat. comuta ... caz declarația acționează asupra diferitelor state ale mașinii de stat. În acest caz, mașina de stat are doar două stări.
Prima stare enumeră numele proiectelor dintr-o listă de proiecte și oferă utilizatorului posibilitatea de a adăuga un nou proiect. Lista de proiecte este creată din dosar projects.txt în directorul de date privind fluxurile de lucru. Observați că aveți foarte multă grijă să vedeți dacă fișierul există și că există proiecte în fișier. Am vrut să mă asigur că fluxul de lucru nu va bombarda niciodată căutarea implicită.
Al doilea control de stat pentru nou comandă în linia de intrare. Apoi va aștepta ca orice tip de utilizator să fie un nou nume de proiect. Dacă nu este a nou comanda, atunci se presupune că este numele unui proiect. Acesta va crea apoi o listă de acțiuni care pot fi luate pe proiect.
Cu stările definite astfel, imaginea de mai sus este lista de proiecte cu adăugarea unui nou proiect.
Această imagine prezintă noul proiect care oferă un nou nume.
Odată ce proiectele sunt definite, un proiect poate fi selectat și este afișată o listă de acțiuni care pot fi luate pe proiect. Când este selectată, scriptul va trimite comanda de acțiune cu numele proiectului.
Acum că informația se află în plină desfășurare, este nevoie de o acțiune întreprinsă asupra acesteia. Adauga o Rulați scriptul bloca dreapta Filtru de scripturi bloc pentru a juca cu o nouă formă de recursiune: apelând alte fluxuri de lucru!
Acest Rulați scriptul bloc este un script PHP cu parametrii, după cum se arată mai sus. Apoi, trebuie să puneți acest lucru în scenariu zonă:
// // Încărcați biblioteca fluxului de lucru PHP. // include_once ("workflows.php"); // // Funcție: getProjDirectory // // Descriere: Această funcție este folosită pentru a obține directorul // legat de proiectul dat. // // Inputs: // $ projname Numele proiectului. // function getProjDirectory ($ wf, $ projname) // // Obțineți directorul Project din lista projects.dxt a proiectelor. // $ pdir = ""; $ projs = explode ("\ n", file_get_contents ($ wf-> data (). "/projects.txt"); foreach ($ projs ca $ proj) $ projparts = explode (":", $ proj); dacă (strcmp ($ projparts [0], $ projname) === 0) // // Acesta este numele proiectelor, salvați directorul. / / $ pdir = $ projparts [1]; retur ($ pdir); // // Creați obiectul de flux de lucru pe care să îl utilizați. // $ wf = fluxuri de lucru noi (); // // Obțineți interogarea și păstrați-o pentru utilizare. // $ clean = trim ("query"); // Figura starea de către elementele de interogare. // $ parts = explode ("|", $ curat); $ pcount = count ($ parts); switch ($ parts [0]) case "new": // // Creați o nouă listă de proiecte. / / file_put_contents ($ wf-> data (). "/ projectName.txt", $ parts [1]); // // Obțineți directorul sunând la Alfred. // system ("osascript -e" spune app \ "Alfred 2.app \" pentru a căuta \ "pm: setprojectdirectory \" '"); pauză; caz "pow": // // Obțineți directorul Project din lista projects.txt a proiectelor. // $ pdir = getProjDirectory ($ wf, $ părți [1]); // // Creați link-ul soft din directorul ~ / .pow. // $ home = getenv ("HOME"); dacă symlink ($ pdir, "$ home / .pow / $ parts [1]")) // // Spuneți utilizatorului. // echo "A adăugat $ parts [1] la POW."; altceva // // Ceva nu a funcționat. // echo "Nu am putut face legătura simbolică cu $ pdir!"; pauză; cazul "eliminați": // // Obțineți lista tuturor proiectelor și verificați fiecare dintre acestea. // $ projs = explode ("\ n", file_get_contents ($ wf-> data (). /projects.txt ")); $ linii [] = ""; foreach ($ projs ca $ proj) $ projparts = explode (":", $ proj); dacă (strcmp ($ projparts [0], $ parts [1])! = 0) // // Acesta nu este proiectul eliminat. Adăugați-o înapoi. // $ linii [] = $ proj; // // Salvați toate proiectele, cu excepția celei eliminate. // file_put_contents ($ wf-> date (). /projects.txt",implode("\n",$lines)); Informați utilizatorul. // echo "Eliminat proiectul $ parts [1]."; pauză; cazul "servi": Apelați fluxul de lucru POW pentru a vedea că este servit. // system ("osascript -e" spune app \ "Alfred 2.app \" pentru a căuta \ "pow browse $ parts [1] \" '"); pauză; caz "alfred": // // Obțineți directorul Project din lista projects.txt a proiectelor. // $ pdir = getProjDirectory ($ wf, $ părți [1]); // // Obțineți directorul sunând la Alfred. // sistem ("osascript -e" spune app \ "Alfred 2.app \" pentru a căuta \ "$ pdir \" '"); pauză; case "current": // // Obțineți directorul Project din lista projects.dxt a proiectelor. // $ pdir = getProjDirectory ($ wf, $ părți [1]); // // Setați directorul apelând la Alfred. / / file_put_contents ($ wf-> data (). /projectDir.txt",$pdir); echo "$ parts [1] este acum proiectul curent."; pauză; Imediat după încărcarea librăriei Alfred PHP Workflow, există o definiție a funcției getProjDirectory (). Această funcție ia numele proiectului și returnează directorul pentru acel proiect așa cum este stocat în projects.txt fișier în directorul de date privind fluxurile de lucru. Din moment ce această piesă de cod este folosită de multe ori, merită pusă într-o funcție.
Restul codului urmează exact Filtru de scripturi, cu excepția conținutului comuta ... caz afirmație. Acesta este încă un tip de mașină de stat, linia de intrare îi dă statului să proceseze. Aici, diferitele state sunt: noi, pow, eliminați, serviți, alfred și curent. Fiecare stat corespunde unei acțiuni care trebuie luată în legătură cu un proiect, așa cum se arată în documentul Filtru de scripturi.
noul stat este pentru crearea de noi proiecte în lista proiectelor. Nu creează nimic, ci pune o legătură în projects.txt fișier în directorul de date. Acest lucru se face salvând numele proiectului în projectName.txt fișier în directorul de date și apelarea pm: setprojectdirectory în Alfred pentru a căuta directorul pentru a se asocia la numele proiectului. Acesta este un tip de reacție a statului prin faptul că scriptul îl cheamă recursiv pe Alfred într-o stare nouă (căutând pe un nou simbol).
Observați cum se numește Alfred: codul PHP numește programul osascript pentru a spune Alfred 2.app a cauta pentru pm: setprojectdirectory. Această tehnică este cel mai simplu mod de a cere ceva de la Alfred și poate fi implementat în orice limbaj de scripting.
Sfârșitul scriptului în Rulați scriptul pentru pm: setprojectdirectory Rulați scriptul bloc trebuie să fie schimbat la:
dacă [-f "$ (getDataDir) /projectName.txt"]; apoi currentName = "cat" $ (getDataDir) /projectName.txt ""; echo "$ nume curent: interogare" >> "$ (getDataDir) /projects.txt"; rm "$ (getDataDir) /projectName.txt"; fi echo "query"> "$ (getDataDir) /projectDir.txt"; echo "Directorul de proiect este: query";
Ceea ce face acum este să verifice existența projectName.txt fișier atunci când este apelat acest script. Dacă există, atunci directorul dat și numele proiectului sunt adăugate la lista de proiecte din projects.txt și fișierul projectName.txt fișierul este eliminat. Încă o dată, acesta este un tip de mașină de stat în care existența projectName.txt fișierul definește o nouă stare de acțiune pentru acest script.
stat utilizează fluxul de lucru Alfred POW pentru a interacționa cu programul POW. Ambele dintre acestea vor trebui să fie instalate pe sistemul care rulează acest flux de lucru. Această stare ia pur și simplu directorul proiectului și numele proiectului și creează o legătură simbolică în ~ / .Pow director. Cu link-ul simbolic acolo, fluxul de lucru POW va putea să-l navigheze și să repornească serverul pentru el.
eliminați Statul ia numele proiectului și îl elimină din lista proiectelor. Depinde de utilizator să elimine directorul.
slujesc stat recursiv îl cheamă pe Alfred să folosească POW Alfred Workflow pentru a vizualiza serverul. POW programul de verificare pentru a vedea dacă serverul rulează bine înainte de a trece locația pentru a fi vizualizate în browser.
stat alfred recursiv îl numește pe Alfred cu directorul proiectului. Dacă Alfred este chemat cu o cale de director absolut, acesta va afișa acel director în Alfred Browser.
starea curenta face directorul proiectului proiectul curent pentru funcția de mutare a fișierelor create în tutorialul intermediar.
Cu toate stările definite în acest fel, este ușor să adăugați noi acțiuni pentru a extinde funcționalitatea acestui flux de lucru. Pur și simplu adăugați starea la Filtru de scripturi și acțiunea pentru stat în Rulați scriptul bloc.
Wow, asta a fost mult de acoperit. Acum Manager de proiect fluxul de lucru este util și poate fi ușor extins. Temele pe care trebuie să le faceți sunt să luați această bază și să adăugați mai multe funcții! Dacă adăugați la fluxul de lucru, vă rugăm să postați munca dvs. mai jos în comentarii. Schimbul de fluxuri de lucru este o mulțime de distracție și ajută pe alții să învețe din ceea ce ați făcut.
