Share
Bene, sei arrivato al tutorial avanzato. Molto bene! Ora per il vero lavoro. Alfred può essere usato per fare alcune cose complicate, inclusa la programmazione ricorsiva! I concetti qui non sono facili e non per il programmatore inesperto.
Script Filter è l'ultimo tipo di blocco da discutere. Come il Filtro file, un Script Filter fornisce all'utente un elenco di opzioni da cui selezionare. La differenza è, a Script Filter consente al programmatore di creare l'elenco di opzioni con uno script.
Una selezione di scelta semplice per la creazione di un progetto nella cartella del progetto mostrerà l'uso di a Script Filter. Innanzitutto, aggiungi un Script Filter al Flusso di lavoro del project manager dal tutorial intermedio.
Impostare il Parola chiave a pm: creare, controlla il con lo spazio checkbox, imposta il tipo di argomento su Argomento opzionale, il Titolo segnaposto a Crea un progetto, il Segnaposto sottotesto a Responsabile del progetto, il "Please Wait" Sottotesto a Opzioni di caricamento ... . La maggior parte di queste opzioni è la stessa di altre caselle.
Il con lo spazio checkbox dice ad Alfred di aspettarsi uno spazio prima dell'argomento facoltativo. Pertanto, rimuoverà lo spazio iniziale prima di passare l'argomento alla sceneggiatura. Altrimenti, passerà semplicemente tutto dopo il Parola chiave allo script per questo blocco.
Il Tipo di argomento il selettore ha tre valori: Argomento richiesto, Argomento opzionale, e Nessun argomento. Il Argomento richiesto non accetterà un ritorno a capo fino a quando non viene fornito un argomento dopo la parola chiave. Passerà tutto allo script mentre l'utente digita. Il Argomento opzionale permetterà all'utente di premere invio senza un argomento dato. Il Nessun argomento passerà alla successiva parola chiave corrispondente se l'utente inizia a dare un argomento. In caso contrario, si interrompe in una ricerca predefinita.
Il "Please Wait" Sottotesto ti permette di dare un sottotesto all'utente mentre lo script nel Script Filter è in esecuzione. Ciò consente all'utente di sapere se tutte le scelte sono disponibili o meno.
L'area della casella di script è proprio come a Esegui script bloccare. Si seleziona la lingua di programmazione desiderata, quali opzioni di escape sono necessarie e lo script stesso. Impostalo su / Usr / bin / php, tutti in fuga, e il seguente script:
eco <<EOF; Sito HTML di base Responsabile del progetto icon.png Sito HTML backbone Responsabile del progetto icon.png
Questo script PHP semplicemente echeggia l'XML per i risultati dello script. UN Script Filter si aspetta che lo script generi un'istruzione XML valida contenente una serie di elementi: uno per ogni opzione disponibile per l'utente.
Ogni oggetto ha un uid, arg, valido, e completamento automatico opzioni. Il uid è un numero o nome univoco per quell'elemento. Se è sempre lo stesso nome univoco per quell'elemento, più un utente lo seleziona, più sarà posizionato verso l'alto della lista. Il arg è ciò che il prossimo blocco riceverà se quell'elemento è selezionato. Il valido argomento può essere solo sì o no. Se no, allora quell'elemento non può essere selezionato, ma il completamento automatico il valore verrà inserito nel Alfred Prompt con la parola chiave. Se sì, allora accetterà un invio per inviare l'argomento al blocco successivo e il completamento automatico il valore è ignorato.
Il titolo, sottotitolo, e icona i bambini di ciascun elemento consentono allo script di impostare il titolo, il sottotitolo e l'icona utilizzata per visualizzare i risultati all'utente. Pertanto, ogni elemento può avere un'icona diversa. Se hai una sottodirectory nell'area del flusso di lavoro chiamata icone, puoi usare il Icone / day.png percorso per fare riferimento a una foto chiamata day.png in quella sottocartella. Ciò consente di personalizzare i risultati per una selezione più semplice.
Ora, quando il Script Filter è attivato, le immagini sopra mostrano i risultati. Non eseguirà ancora nulla se non inviare la selezione ad Alfred.
Per fare qualcosa in base alla selezione, dovrai aggiungere un Esegui script blocco successivo e compilarlo come uno script bash senza fuggire. L'area di script può essere riempita con il seguente script:
######################### # Contanti. ######################### VPREFS = "$ HOME /Library/Caches/com.runningwithcrayons.Alfred-2/Workflow Data /" NVPREFS = "$ HOME / Libreria / Supporto applicazione / Alfred 2 / Dati flusso di lavoro /" ############################################# ################################################ # Leggere il bundleid dal flusso di lavoro info.plist ########################################### ##################################### getBundleId () / usr / libexec / PlistBuddy -c " Stampa: bundleid "" info.plist " ######################################### ######################################## Ottieni la dir dei dati del flusso di lavoro ##### ################################################## ######################## getDataDir () local BUNDLEID = $ (getBundleId) echo "$ NVPREFS $ BUNDLEID" se [! -d "$ (getDataDir)"]; then mkdir -p "$ (getDataDir)"; toccare "$ (getDataDir) /projectDir.txt"; fi projD = "cat" $ (getDataDir) /projectDir.txt ""; Se [ ! -d "$ projD"]; then mkdir -p "$ projD"; fi cd "$ projD"; type = " richiesta"; case "$ type" in basic) echo "Basic"; curl -o tmp.zip -L "https://codeload.github.com/h5bp/html5-boilerplate/zip/v4.3.0"; decomprimere tmp.zip >> / dev / null; mv html5-boilerplate-4.3.0 / *. ; rm -Rf "html5-boilerplate-4.3.0 /"; rm -Rf "tmp.zip"; echo "HTML5 Boilerplate in place."; ;; backbone) echo "BackBone"; curl -o tmp.zip -L "https://codeload.github.com/h5bp/html5-boilerplate/zip/v4.3.0"; decomprimere 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 "HTML5 Boilerplate con Backbone.js in posizione."; ;; esac
Questo script crea semplicemente il tipo di progetto nella directory che è stata impostata come directory del progetto. La prima parte dello script è proprio come gli script utilizzati nel tutorial intermedio per accedere ai due luoghi in cui è possibile memorizzare i dati. Il directory dei dati e il directory della cache. Qui, viene utilizzata solo la directory dei dati per ottenere la posizione della directory del progetto.
Il resto dello script si sposterà nella directory del progetto e lo riempirà in base al tipo di progetto selezionato. Un progetto HTML di base scaricherà il modello HTML5 Boilerplate e lo installerà nella directory del progetto. Un progetto Backbone installerà il modello HTML5 Boilerplate e la libreria JavaScript Backbone.js. Questo può essere facilmente migliorato usando Yeoman per installare i componenti del progetto, ma ciò andrebbe oltre lo scopo di questo tutorial.
Il problema con il modo in cui questo Script Filter è stato scritto è che è difficile da espandere e mantenere. Sarebbe molto più semplice chiamare una funzione che creerà l'XML come necessario. Inoltre, utilizzando questo approccio al programma, l'utente non può restringere la lista delle azioni possibili digitando. Dovranno semplicemente spostarsi verso il basso nell'elenco o premere un tasto di scelta rapida per quell'elemento.
Dal momento che Alfred punta a rendere più semplice la ricerca e la selezione delle opzioni, deve esserci un modo per farlo accadere. Grazie a tutti i programmatori dedicati che aiutano con Alfred, ci sono alcune librerie scritte che aiuteranno a rendere questo processo molto più semplice.
Una delle benedizioni dell'ecosistema Alfred è che molte persone stanno progettando librerie per il loro linguaggio di script preferito per facilitare la programmazione di Alfred. L'elenco completo delle librerie Alfred può essere trovato su Alfred Forum. Ci sono librerie per Bash / Zsh (pezzi di cui ho usato in questi script), Python, PHP, Ruby, AppleScript e go (è elencata come una libreria AppleScript, ma è per il linguaggio di programmazione go di Google)!
Per utilizzare la libreria per PHP, è necessario scaricare il file workflow.php da questo sito di David Ferguson. Inserirlo nella cartella del flusso di lavoro. Ora, questo script deve essere caricato nel codice PHP per Script Filter. Cambia quel codice in:
Accentsconagua
// // Carica la libreria del flusso di lavoro PHP. // include_once ("workflows.php"); // // Crea l'oggetto del flusso di lavoro da utilizzare. // $ wf = new Workflow (); // // Ottieni la query non elaborata e memorizzala per l'uso. // $ clean = trim ("query"); // // Imposta le opzioni. // $ wf-> result ("1PM", "basic", "Sito HTML di base", "Project Manager", "icon.png", "yes"); $ wf-> result ("2PM", "backbone", "Backbone HTML Site", "Project Manager", "icon.png", "yes"); // // Visualizza l'xml delle scelte. // echo $ wf-> toxml (); Questo è molto più facile da leggere e capire. I commenti possono essere facilmente aggiunti per aiutare a spiegare il codice per riferimento futuro. Questo darà gli stessi esatti risultati della lista XML, ma ora è in una forma che renderà più facile l'espansione.
Questo script ora viene caricato nella libreria e inizializza una variabile di classe, wf $, del Flusso di lavoro () classe dalla biblioteca. Il risultato() la funzione membro viene utilizzata per creare il codice XML con le opzioni. Le opzioni dell'ordine sono: count, arg, titolo, sottotitolo, file icona e valido. Il toxml () la funzione membro restituisce semplicemente il codice XML finale che viene riprodotto.
Ora, per rendere il Script Filter sembra migliore. Prendi i due file immagine nel file di download per questo tutorial e aggiungili alla directory del tuo flusso di lavoro. Quindi, cambia il Imposta le opzioni sezione in Script Filter codice a:
// // Imposta le opzioni. // $ wf-> result ("1PM", "basic", "Sito HTML di base", "Project Manager", "html5BP.jpeg", "yes"); $ wf-> result ("2PM", "backbone", "Backbone HTML Site", "Project Manager", "backbone.png", "yes"); L'icona utilizzata per ciascuna scelta rappresenta ora la scelta. Un'interfaccia utente molto migliore. Alfred può prendere i file grafici jpeg o png per le icone. Ridimensiona anche le icone secondo necessità. I risultati sono mostrati sotto:
Come si può vedere, la seconda opzione viene visualizzata per prima. Questo perché l'ho usato di più durante i test. Alfred ricorda quale scelta è più utilizzata e cerca di ordinare la lista di conseguenza. Questo è utile per i comandi che vengono utilizzati più frequentemente.
Ma l'elenco non può essere ristretto digitando parte del nome. Questo è un vero must se ci devono essere molte scelte. Sfortunatamente, questa libreria PHP non ha una funzione per questo. Pertanto, è necessario definire una nuova funzione. Cambia l'area delle opzioni in questo modo:
// // Imposta le opzioni. // $ added = buildResult ($ wf, "$ clean", "1PM", "basic", "Sito HTML di base", "Project Manager", "html5BP.jpeg", "yes"); $ added + = buildResult ($ wf, "$ clean", "2PM", "backbone", "Backbone HTML Site", "Project Manager", "backbone.png", "yes"); if ($ added == 0) $ wf-> result ("999", "", "Nessun tipo di progetto corrisponde a $ clean!", "Project Manager", "icon.png", "no"); Il buildResult () la funzione prende tutto ciò che il risultato() la funzione ha funzionato, ma ha anche due nuovi parametri: il Flusso di lavoro () variabile dell'oggetto e il testo da abbinare al comando.
Ora, aggiungi la definizione della nuova funzione subito dopo che la libreria include:
function buildResult ($ wf, $ input, $ count, $ arg, $ title, $ sottotitoli, $ icon, $ valid) $ result = 0; if (preg_match ("/.*$ input / i", "$ arg") === 1) $ wf-> result ($ count, $ arg, $ title, $ sottotitolo, $ icon, $ valid); $ risultato = 1; return ($ result); Questa funzione utilizza il preg_match () Funzione PHP per eseguire una corrispondenza di espressioni regolari della stringa su una wild card aggiunta alla stringa di input. Se ciò che l'utente digita non corrisponde, non aggiungerà quel risultato. Se è stato aggiunto un risultato, ne verrà restituito uno. Altrimenti, restituirà uno 0.
Hai notato il codice aggiuntivo aggiunto? Questo è stato vedere se qualcosa è stato aggiunto ai risultati. Se nulla ha superato il test da includere come risultato, viene aggiunto un risultato predefinito che dice che non è stato possibile trovare nulla. Con il valido parametro impostato su no, l'utente non può ricevere il ritorno su di esso. Ciò impedisce al flusso di lavoro di scaricare l'utente nella ricerca predefinita con tutto il Alfred Prompt o dall'invio di cianfrusaglie allo script successivo per capire.
Con quel poco di controllo degli errori, il flusso di lavoro ora dice con grazia all'utente che c'è un problema senza causare un dump alla ricerca predefinita. Si dovrebbe sempre pensare alla gestione degli errori nei flussi di lavoro. È importante per un aspetto professionale.
Dal momento che il Script Filter il blocco continua a chiamare lo script per ogni lettera digitata dall'utente, è un ottimo posto per programmare in modo ricorsivo. Il più delle volte la programmazione ricorsiva è menzionata quando una routine si chiama da sola. Questa è una ricorsione diretta. Cosa è fatto in Alfred Script Filter si chiamerebbe ricorsione indiretta.
Il primo tipo di ricorsione da esaminare è la macchina a stati. Una macchina a stati è un programma che è controllato da una variabile che determina lo stato o il livello di esecuzione del programma.
Il Flusso di lavoro del project manager ha bisogno di un modo per tenere traccia dei progetti ed eseguire determinate azioni su quei progetti. Per avviarlo, crea un Script Filter bloccare come sopra. Quindi aggiungi questo script al copione la zona:
// // Carica la libreria del flusso di lavoro PHP. // include_once ("workflows.php"); // // Funzione: buildResult // // Descrizione: Crea in modo condizionale il risultato XML se l'input // contiene l'argomento. // function buildResult ($ wf, $ input, $ count, $ arg, $ title, $ sottotitoli, $ icon, $ valid, $ ret) $ result = 0; $ parti = esplode ("|", $ arg); if (count ($ parts)> 0) $ arg = $ parts [0]; if (preg_match ("/.*$ input / i", "$ arg") === 1) $ wf-> risultato ($ count, $ arg, $ title, $ sottotitolo, $ icon, $ valido, $ ret); $ risultato = 1; return ($ result); // // Crea l'oggetto del flusso di lavoro da utilizzare. // $ wf = new Workflow (); // // Ottieni la query non elaborata e memorizzala per l'uso. // $ clean = trim ("query"); // // Calcola lo stato tramite gli elementi quey. // $ parts = explode ("|", $ clean); $ account = conteggio ($ parti); $ returncount = 0; switch ($ account) caso 1: // // Questo è lo stato di base. Qui viene elencato un elenco di progetti e // la possibilità di creare un nuovo progetto. // // // Ottieni ed elenca i progetti. // $ count = 0; $ nomefile = $ wf-> dati (). "/Projects.txt"; if (file_exists ($ nomefile)) $ projs = esplode ("\ n", file_get_contents ($ nomefile)); foreach ($ projs as $ proj) $ projparts = explode (":", $ proj); if (strcmp ($ projparts [0], "")! = 0) $ returncount + = buildResult ($ wf, $ parts [0], $ count, "$ projparts [0] |", "Progetto: $ projparts [0] "," Project Manager "," icon.png "," no "," $ projparts [0] | "); $ count + = 1; // // Fornire un'opzione per un nuovo progetto. // $ wf-> result ("999", "new |", "Aggiungi un nuovo progetto", "Project Manager", "icon.png", "no", "new |"); $ returncount + = 1; rompere; caso 2: // // Due possibili aree: l'azione di un particolare progetto o // la creazione di un nuovo progetto. // if (strcmp ($ parts [0], "new") === 0) // // Crea un nuovo progetto. Prendi il nome. // $ wf-> result ("999", "new | $ parts [1]", "Project Name: $ parts [1]", "Project Manager", "icon.png", 'yes ', "nuovi | $ parti [1]"); $ returncount + = 1; else // // Ora per eseguire azioni su un progetto. // $ count = 1; $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++. "pml", "remove | $ parts [0]", "Remove Project: $ parts [0]" , "Project Manager", "icon.png", "yes", ""); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++. "pml", "pow | $ parts [0]", "Aggiungi a Pow: $ parts [0] "," Project Manager "," icon.png "," yes "," "); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++. "pml", "alfred | $ parts [0]", "Visualizza in Alfred: $ parts [0] "," Project Manager "," icon.png "," yes "," "); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++. "pml", "current | $ parts [0]", "Crea progetto corrente: $ parts [0] "," Project Manager "," icon.png "," yes "," "); $ returncount + = buildResult ($ wf, "$ parts [1]", $ count ++. "pml", "serve | $ parts [0]", "Avvia server nel progetto: $ parts [0] "," Project Manager "," icon.png "," yes "," "); rompere; If ($ returncount < 1) $wf->risultato ("999", "", "Stato non valido! Ricominciare da capo.", "Project Manager", "icon.png", "no", ""); // // Visualizza l'xml delle scelte. // echo $ wf-> toxml (); L'inizio della sceneggiatura è esattamente come l'ultimo script. La logica è stata aggiunta per mantenere la prima parte di una multiparte $ arg (In altre parole, una stringa data in $ arg parametro che ha il | simbolo.) al buildResult () funzione.
Subito dopo aver pulito l'input da Alfred, l'input viene diviso in base a | charater e il numero di parti è capito. Questa informazione fornisce lo stato per la macchina a stati. Il scatola dell'interruttore la dichiarazione agisce sui diversi stati della macchina di stato. In questo caso, la macchina di stato ha solo due stati.
Il primo stato elenca i nomi dei progetti da un elenco di progetti e offre all'utente la possibilità di aggiungere un nuovo progetto. L'elenco dei progetti viene creato dal file projects.txt nella directory dei dati dei flussi di lavoro. Si noti, molta cura è presa per vedere se il file esiste e che ci sono progetti nel file. Volevo assicurarmi che il flusso di lavoro non esplodesse mai nella ricerca predefinita.
Il secondo stato controlla per nuovo comando nella riga di input. Quindi si aspetterà che qualsiasi utente digiti un nuovo nome di progetto. Se non è un nuovo comando, quindi si presume che sia il nome di un progetto. Creerà quindi un elenco di azioni che possono essere intraprese nel progetto.
Con gli stati definiti in questo modo, l'immagine sopra è la lista dei progetti con l'aggiunta di un nuovo progetto.
Questa immagine mostra il nuovo progetto che dà un nuovo nome.
Una volta definiti i progetti, è possibile selezionare un progetto e visualizzare un elenco di azioni che possono essere intraprese sul progetto. Se selezionato, lo script invierà il comando di azione con il nome del progetto.
Ora che l'informazione è in cantiere, ha bisogno di un'azione su di essa. Aggiungere un Esegui script bloccare a destra il Script Filter blocco per giocare con una nuova forma di ricorsione: chiamare altri flussi di lavoro!
Questo Esegui script block è uno script PHP con i parametri mostrati sopra. Quindi, è necessario inserirlo nel copione la zona:
// // Carica la libreria del flusso di lavoro PHP. // include_once ("workflows.php"); // // Funzione: getProjDirectory // // Descrizione: questa funzione viene utilizzata per ottenere la directory relativa // al progetto specificato. // // Input: // $ projname Il nome del progetto. // function getProjDirectory ($ wf, $ projname) // // Ottieni la directory Project dall'elenco projects.txt dei progetti. // $ pdir = ""; $ projs = explode ("\ n", file_get_contents ($ wf-> data (). "/projects.txt")); foreach ($ projs as $ proj) $ projparts = explode (":", $ proj); if (strcmp ($ projparts [0], $ projname) === 0) // // Questo è il nome del progetto, salva la directory. // $ pdir = $ projparts [1]; return ($ pdir); // // Crea l'oggetto del flusso di lavoro da utilizzare. // $ wf = new Workflow (); // // Ottieni la query non elaborata e memorizzala per l'uso. // $ clean = trim ("query"); // // Calcola lo stato tramite gli elementi della query. // $ parts = explode ("|", $ clean); $ account = conteggio ($ parti); switch ($ parts [0]) case "new": // // Crea un nuovo elenco di progetti. // file_put_contents ($ wf-> data (). "/ projectName.txt", $ parts [1]); // // Ottieni la directory chiamando Alfred. // system ("osascript -e 'tell app \" Alfred 2.app \ "per cercare \" pm: setprojectdirectory \ "'"); rompere; case "pow": // // Prendi la directory del progetto dall'elenco projects.txt dei progetti. // $ pdir = getProjDirectory ($ wf, $ parts [1]); // // Crea il soft link nella directory ~ / .pow. // $ home = getenv ("HOME"); if (symlink ($ pdir, "$ home / .pow / $ parts [1]")) // // Dillo all'utente. // echo "Aggiunto $ parts [1] a POW."; else // // Qualcosa non ha funzionato. // echo "Impossibile creare il collegamento simbolico a $ pdir!"; rompere; case "remove": // // Ottieni l'elenco di tutti i progetti e controlla ciascuno di essi. // $ projs = explode ("\ n", file_get_contents ($ wf-> data (). "/projects.txt")); $ lines [] = ""; foreach ($ projs as $ proj) $ projparts = explode (":", $ proj); if (strcmp ($ projparts [0], $ parts [1])! = 0) // // Questo non è il progetto che viene rimosso. Aggiungilo di nuovo. // $ lines [] = $ proj; // // Salva tutti i progetti tranne quello rimosso. // file_put_contents ($ wf-> data (). "/projects.txt",implode("\n" ,$lines)); // // Dillo all'utente. // echo "Rimosso il progetto $ parts [1]."; rompere; case "serve": // // Chiama il flusso di lavoro POW per vederlo servito. // system ("osascript -e 'tell app \" Alfred 2.app \ "per cercare \" pow browse $ parts [1] \ "'"); rompere; caso "alfred": // // Ottieni la directory del progetto dall'elenco projects.txt dei progetti. // $ pdir = getProjDirectory ($ wf, $ parts [1]); // // Ottieni la directory chiamando Alfred. // system ("osascript -e 'tell app \" Alfred 2.app \ "per cercare \" $ pdir \ "'"); rompere; case "current": // // Prendi la directory Project dall'elenco projects.txt dei progetti. // $ pdir = getProjDirectory ($ wf, $ parts [1]); // // Imposta la directory chiamando Alfred. // file_put_contents ($ wf-> data (). "/projectDir.txt",$pdir); echo "$ parts [1] è ora il progetto corrente."; rompere; Subito dopo il caricamento della libreria Alfred PHP Workflow, esiste una definizione per la funzione getProjDirectory (). Questa funzione prende il nome del progetto e restituisce la directory per quel progetto come memorizzata in projects.txt file nella directory dei dati dei flussi di lavoro. Dal momento che questo pezzo di codice viene usato spesso, vale la pena inserire una funzione.
Il resto del codice segue esattamente il Script Filter, ad eccezione dei contenuti del scatola dell'interruttore dichiarazione. Questo è ancora un tipo di macchina a stati, la linea di input dà lo stato da elaborare. Qui, i diversi stati sono: nuovo, pow, remove, serve, alfred e current. Ogni stato corrisponde ad un'azione da intraprendere su un progetto come mostrato in Script Filter.
Il nuovo stato è per la creazione di nuovi progetti nell'elenco dei progetti. Non crea nulla ma inserisce un collegamento nel projects.txt file nella directory dei dati. Questo viene fatto salvando il nome del progetto nel projectName.txt file nella directory dei dati e chiamando il pm: setprojectdirectory in Alfred per cercare la directory da associare al nome del progetto. Questo è un tipo di feedback di stato in quanto lo script ricorsivamente chiama Alfred in un nuovo stato (cercando su un nuovo token).
Si noti come viene chiamato Alfred: il codice PHP chiama il programma osascript per dirlo Alfred 2.app cercare pm: setprojectdirectory. Questa tecnica è il modo più semplice per richiedere qualcosa da Alfred e può essere implementata in qualsiasi linguaggio di scripting.
La fine dello script in Esegui script per il pm: setprojectdirectory Esegui script il blocco deve essere cambiato in:
if [-f "$ (getDataDir) /projectName.txt"]; then currentName = "cat" $ (getDataDir) /projectName.txt ""; echo "$ currentName: query" >> "$ (getDataDir) /projects.txt"; rm "$ (getDataDir) /projectName.txt"; fi echo "query"> "$ (getDataDir) /projectDir.txt"; echo "La directory del progetto è: query";
Ciò che ora fa è verificare l'esistenza di projectName.txt file quando viene chiamato questo script. Se esiste, quindi la directory specificata e il nome del progetto vengono aggiunti all'elenco dei progetti nel projects.txt file e il projectName.txt il file è stato rimosso. Ancora una volta, questo è un tipo di macchina di stato in cui l'esistenza del projectName.txt il file definisce un nuovo stato di azione per quello script.
Il stato di guerra fa uso del POW Alfred Workflow per interagire con il programma POW. Dovranno essere installati entrambi sul sistema che esegue questo flusso di lavoro. Questo stato prende semplicemente la directory del progetto e il nome del progetto e crea un collegamento simbolico nel file ~ / .Pow directory. Con il collegamento simbolico, il flusso di lavoro POW sarà in grado di sfogliarlo e riavviare il server per esso.
Il rimuovere stato prende il nome del progetto e lo rimuove dall'elenco dei progetti. Spetta all'utente rimuovere la directory.
Il servire lo stato chiama ricorsivamente Alfred per utilizzare il POW Alfred Workflow per visualizzare il server. Il POW programma controlla per vedere se il server sta funzionando bene prima di passare il percorso per essere visualizzato nel browser.
Il stato alfred chiama ricorsivamente Alfred con la directory del progetto. Se Alfred viene chiamato con un percorso di directory assoluto, visualizzerà tale directory nel Browser Alfred.
Il stato attuale rende la directory del progetto il progetto corrente per la funzione dei file di spostamento creata nel tutorial intermedio.
Con tutti gli stati definiti in questo modo, è facile aggiungere nuove azioni per estendere la funzionalità di questo flusso di lavoro. Basta aggiungere lo stato al Script Filter e l'azione per lo stato nel Esegui script bloccare.
Wow, era molto da coprire. Ora il Responsabile del progetto il flusso di lavoro è utile e può essere facilmente esteso. I tuoi compiti sono di prendere questa base e aggiungere più funzioni! Se si aggiunge al flusso di lavoro, si prega di postare il lavoro qui sotto nei commenti. Condividere i flussi di lavoro è molto divertente e aiuta gli altri a imparare da ciò che hai fatto.
