Je Gehoorzame Assistent Yeoman

Eén ding is zeker: de tijden zijn zeker veranderd. Nog niet zo lang geleden was front-end ontwikkeling, hoewel niet eenvoudig, beheersbaar. Leer HTML, een beetje CSS, en je komt eraan. Tegenwoordig zijn er echter bij gebrek aan betere woorden veel meer variabelen om te jongleren.

Preprocessors, prestatie-optimalisatie, testen, beeldoptimalisatie en minificatie vertegenwoordigen slechts enkele van de belangrijkste factoren die de moderne front-end ontwikkelaar in gedachten moet houden.

Hoewel CSS eenvoudig in gebruik is, schaalt het zeker niet goed. En hoewel krachtig, kan JavaScript soms een lelijke, moeilijke taal zijn om mee te werken. Dan is er het prestatieaspect; we ontwerpen niet langer alleen voor Internet Explorer en Firefox. Nee, tegenwoordig hebben we een groot aantal browsers, apparaten, resoluties en verbindingssnelheden waarmee we rekening moeten houden bij het ontwikkelen van nieuwe applicaties.

Om te zeggen dat de onze een ongelooflijk moeilijke industrie is, zou de understatement van de eeuw zijn.

Het voordeel is dat voor elke wegversperring oplossingen zijn voorzien.

Het voordeel is dat, voor elke wegversperring, oplossingen zeker zijn geleverd door leden van de gemeenschap. Overweeg het CSS-schalingsprobleem; wel, preprocessors, zoals Sass, Less en Stylus werden geïntroduceerd om ons leven drastisch te vereenvoudigen. Hoe zit het met het vervelende CSS3-browser-voorvoegsel probleem? Compass zorgt daar voor! En het JavaScript-dilemma? Nogmaals, CoffeeScript en, nu, TypeScript te redden! Het enige probleem is dat elke nieuwe oplossing zijn eigen systeem en proces nodig heeft. Zoals te verwachten is, kan dit na verloop van tijd uw workflow aanzienlijk bemoeilijken. Nu hebben we meerdere Terminal-tabbladen geopend, die elk een deelverzameling van de bestanden in onze projecten bewaken en luisteren naar wijzigingen. En dat is nog maar het topje van de ijsberg. We hebben nog niet gesproken over workflow, codering van best practices, beeldoptimalisatie, testen en ontwikkelen van een geautomatiseerd bouwproces. Zelfs schrijven over al deze stappen is mijn adem inkorten! Zou het niet fantastisch zijn als iemand al deze preprocessors en best practices in één gemakkelijk te gebruiken pakket heeft gestopt??


Zeg hallo tegen Yeoman

Gemaakt door een aantal van de vriendelijke mensen bij Google (waaronder Paul Irish en Addy Osmani), is Yeoman de oplossing voor uw problemen. Zoals het kernteam zegt, biedt Yeoman een eigenzinnige workflow om je zo snel mogelijk aan de slag te helpen met nieuwe projecten. Maar wat betekent dit eigenlijk? Welnu, het biedt de mogelijkheid om nieuwe projecten te ondersteunen, evenals de nodige kaders en testtools. Wat dit in essentie vertaalt naar is minder vervelend configuratie, en meer creatie.

Om te beginnen met Yeoman, moeten we het eerst installeren vanaf de opdrachtregel. Voer de volgende opdracht uit:

krul -L get.yeoman.io | bash

Dit script zal verschillende dingen doen, inclusief het installeren van de nodige bibliotheken voor Yeoman om zijn werk te doen. U zult waarschijnlijk merken dat het een handvol stappen van uw kant vereist, maar maakt u zich geen zorgen; het zal u precies vertellen wat er moet gebeuren!

Zodra de installatie is voltooid, uitvoeren eigenerfde om te zien wat er beschikbaar is. Je zult een verscheidenheid aan opties vinden, zoals in het, voor het initialiseren van een nieuw project, bouwen, voor het maken van een speciale, geoptimaliseerde dist map voor implementatie, en installeren, wat het proces van omgaan met pakketbeheer zo eenvoudig mogelijk maakt.

Voor meer informatie over wat elke optie doet, voegt u toe --helpen naar het commando: yeoman init --help.

Laten we een nieuw project met Yeoman maken. Maak een nieuwe map op uw bureaublad, CD naar het van de Terminal, en voer:

yeoman init

Op dit punt wordt u gevraagd een handvol vragen te beantwoorden.

  • Wilt u Twitter Bootstrap voor Compass opnemen??
  • Wilt u de Twitter Bootstrap-plug-ins opnemen??
  • Wilt u RequireJS opnemen (voor AMD-ondersteuning)?
  • Wilt u ondersteuning bieden voor het schrijven van ECMAScript 6-modules?

Met deze vragen kunt u uw nieuwe project direct uit de verpakking configureren. Kies voor nu "Nee" voor elke vraag.

Als u in de toekomst deze vragen liever wilt omzeilen, voert u in plaats daarvan uit yeoman init quickstart. Hiermee wordt een nieuwe applicatie voorbereid met Modernizr, jQuery en HTML5 Boilerplate ingebakken.

Met dat ene commando alleen steekt Yeoman meteen een nieuw project voor je in de steigers. Wees echter niet overweldigd door al deze bestanden; Als ze niet voor u zijn gegenereerd, kunt u ze uiteindelijk handmatig maken. Denk alleen maar aan Yeoman als de behulpzame robot, die al het handenarbeid voor u doet.

"Yo, man; ga me jQuery en Modernizr halen! "

Nu we een nieuw project hebben, laten we een preview-server starten en beginnen we de applicatie te controleren op wijzigingen.

yeoman server

Onmiddellijk wordt Google Chrome gestart en wordt uw project weergegeven (ook geen beveiligingsfouten meer). Wel, dat is handig, maar zoals je snel zult vinden, is er nog veel, veel meer te zien. Plaats uw browser en editor zij aan zij en probeer de volgende dingen:

LiveReloading

Verander de h1 tag-tekst, en kijk hoe het onmiddellijk wordt bijgewerkt in de browser, zonder een vernieuwing. Yeoman tot uw dienst! Dit wordt bereikt via de LiveReload Google Chrome-extensie, maar als dat niet is geïnstalleerd, wordt er een fallback-herlaadproces gebruikt.

Sass

Verandering main.css naar main.sass (of main.scss, als dat uw voorkeur heeft) en geniet van direct compileren en updaten in de browser. Probeer een variabele te maken en te gebruiken om het uit te testen.

// main.sass $ textColor: # 666 bodykleur: $ textColor

Leuk! Nul instellen vereist. U kunt uw stylesheets nu scheiden, indien nodig, en ze importeren main.sass.

// main.sass @import 'grid' @import 'knoppen' @import 'module'

Elke keer dat een bestand wordt opgeslagen, zal Yeoman automatisch uw Sass opnieuw compileren in reguliere CSS en de browser vernieuwen.

Kompas

Als je een Sass-fan bent, dan heb je waarschijnlijk ook de voorkeur voor het uitstekende Compass-framework. Maak je geen zorgen; Yeoman is blij om te verplichten. Compass-ondersteuning is al beschikbaar; importeer gewoon de van toepassing zijnde modules en ga gewoon door.

// main.sass @import 'compass / css' * + box-sizing (border-box) .box width: 200px + transition (width 1s) &: hover width: 400px

Als u nog geen preprocessor convert bent, moet u toegeven: dit is aanzienlijk beter dan het alternatief:

* -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box;  .box width: 200px; -webkit-overgang: breedte 1s; -moz-overgang: breedte 1s; -ms-overgang: breedte 1s; -o-overgang: breedte 1s; overgang: breedte 1s;  .box: hover width: 400px; 

CoffeeScript

JavaScript is prima en dandy, maar sommigen vinden dat CoffeeScript een aanzienlijk schonere syntaxis biedt die veel van de hiaten in de taal opvult (ten minste visueel).

Binnen de scripts / map, optioneel een nieuwe map maken, koffie/, en voeg je eerste CoffeeScript-bestand toe: person.coffee.

# scripts / coffee / person.coffee class Person

Sla het bestand op en, net als magie, Yeoman compileert het onmiddellijk in vanilla JavaScript en plaatst het nieuwe bestand direct in de bovenliggende map scripts / directory. Kijk zelf maar:

// scripts / person.js var Persoon; Person = (function () function Person ()  return Person;) ();

Perfect, en nog belangrijker, moeiteloos!

Als u de directorystructuur op enigerlei wijze moet wijzigen, raadpleegt u de gruntfile.js bestand in de hoofdmap van uw toepassing. Achter de schermen is het grunt-gereedschap van Ben Alman de configuratie van de compilatie.

Alleen al op dit punt heeft Yeoman ons veel flexibiliteit gegeven. Met die single yeoman init opdracht, kunt u uw websites nu stijlen met Sass, code in CoffeeScript, en terwijl u wijzigingen aanbrengt, ziet u meteen dat de updates in de browser worden weergegeven. Maar we zijn nog niet klaar! Niet eens in de buurt.

Pakketbeheer

Yeoman maakt gebruik van een krachtige pakketbeheerder voor het web, genaamd Bower. Wat is een pakketbeheerder? Nou, als je nog steeds handmatig downloadt, bijvoorbeeld de Underscore-bibliotheek van underscorejs.org, dan doe je het verkeerd. Wat gebeurt er als de bibliotheek een paar maanden later wordt bijgewerkt? Wilt u de bibliotheek handmatig opnieuw downloaden? Tijd is geld; dus laat Yeoman het werk voor je doen.

Laten we Underscore in ons project trekken.

de onderlegger van yeoman installeert

Yeoman zal op deze opdracht reageren door de nieuwste versie van de bibliotheek te downloaden en deze in een nieuwe te plaatsen verkoper directory. Nu is het klaar om te worden gebruikt!

 

Maar wat als we niet precies zeker weten wat de naam is van de asset die we nodig hebben? In deze situaties kunnen we verwijzen naar het zoeken naar joden. Zonder enige argumenten door te geven, zal Yeoman een lijst retourneren met alle items die beschikbaar zijn om te installeren. Laten we naar het populaire zoeken normalize.css project, door Nicolas Gallagher.

Let op: Bower is niet exclusief voor JavaScript-specifieke items.

het zoeken naar een jodendom normaliseert

Op het moment van schrijven moeten twee projecten worden geretourneerd:

  • normalize-css git: //github.com/necolas/normalize.css.git
  • underscore.normalize git: //github.com/michael-lawrence/underscore.normalize.git

Het lijkt op normaliseren-css is degene die we willen.

yeoman installeert normalize-css

Importeer het nu op dezelfde manier als u normaal zou doen:

U kunt ook de naam van het bestand wijzigen in normalize.scss, en importeer het in uw main.sass het dossier.

// main.sass @import '... / scripts / vendor / normalize-css / normalize'

Er zijn verschillende andere Bower-specifieke opdrachten die u wilt onthouden:

  • yeoman jailure verwijderen - Verwijder een pakket.
  • jubileum update van de jager - Update bibliotheek naar de nieuwste versie.
  • lijst met joden - Lijst van alle momenteel geïnstalleerde pakketten.

testen

Als testen nog geen deel uitmaakt van uw workflow, zou dat moeten zijn! Wat is er mooier dan een robot die na elke opslag automatisch uw werk verifieert? Gelukkig maakt Yeoman het ongelooflijk eenvoudig om je applicaties te testen. Out of the box, het populaire Mocha-framework en PhantomJS (headless-webkit) zijn beschikbaar, hoewel het eenvoudig configureerbaar is, als u de voorkeur geeft aan een andere tool, zoals Jasmine. Bovendien biedt het de Chai assertion-bibliotheek, waar je snel van zult gaan houden.

Open de proeven / index.html het dossier. Onderaan zie je een aantal voorbeeldtests. Ga je gang en verwijder deze en maak een nieuw testbestand aan: spec / person.js. Hier is een test om je op weg te helpen.

// test / spec / person.js beschrijven ('A Person', function () it ('should have a age over 0', function () var person = new Person name: 'Jeffrey', leeftijd: 27 verwachten (person.age) .to.be.boven (0);););

Moet Interface

Als u liever Chai's gebruikt (een bibliotheek met beweringen) moeten interface, keer terug naar index.html, en veranderen verwachten = chai.expect naar should = chai.should (). Nu kunt u uw specificatie bijwerken, zodat deze luidt:

person.age.should.be.above (0);

Welke methode u kiest, is geheel aan u. Er is geen juiste keuze; alleen voorkeuren.

Om deze test uit te voeren, gaat u terug naar de Terminal en typt u:

yeoman test

Zoals verwacht, zou de test moeten mislukken met de boodschap: "Kan variabele niet vinden: Persoon."Het is een mislukte test, maar wat nog belangrijker is, het werkt - we testen! Omdat Yeoman gebruik maakt van de uitstekende PhantomJS-tool (headless-webkit), kunnen deze tests zelfs zonder de browser worden uitgevoerd.

CoffeeScript-tests

Als u liever uw tests in CoffeeScript schrijft, moet u een paar wijzigingen aanbrengen in uw gruntfile.js. Begin met het toevoegen van een nieuw compileren bezwaar tegen de kompas taak. Geef in dit object de bestanden op die moeten worden bekeken. In dit geval geven we Grunt de opdracht om alle CoffeeScript-bestanden te compileren test / spec / coffee.

// Coffee to JS-compilatiekoffie: dist: src: 'app / scripts / ** / *. Coffee', dest: 'app / scripts', compileer: files: "test / spec /": " test / spec / koffie / *. koffie "

De laatste stap is om Grunt te vertellen dat hij die map in de gaten moet houden. Wanneer een bestand wordt opgeslagen, moet het dienovereenkomstig opnieuw worden gecompileerd.

Vind de kijk maar taak en werk het koffie object, zoals zo:

koffie: bestanden: ['',' test / spec / coffee / *. coffee '], taken:' coffee reload '

Hierboven voegen we eenvoudigweg een nieuw pad toe aan de bestanden matrix. Op deze manier weet Grunt dat het de test / spec / coffee directory voor wijzigingen en voer de koffie en herladen taken, dienovereenkomstig.


Alles samenvoegen

Om nog een paar van de vaardigheden van Yeoman te illustreren, laten we dit nieuwe leren nemen en het vanuit het niets toepassen op een eenvoudig project. Ons doel is om de laatste tweets over Yeoman op de pagina weer te geven, inclusief de avatar van de tweeter en een link naar de originele tweet. Laten we beginnen.

We beginnen met het snel creëren van een nieuwe applicatie met Yeoman.

mkdir tweets && cd tweets yeoman init quickstart

Vervolgens starten we de server op en beginnen we onze Sass- en CoffeeScript-bestanden te bekijken op veranderingen. Als u meewerkt, moet u uw browser en editor naast elkaar plaatsen voor de beste workflow.

yeoman server

Voel je vrij om de standaard HTML-code die Yeoman biedt als voorbeeld te verwijderen. Vervolgens gaan we de nodige code schrijven om de tweets op te halen. Binnen de scripts / map, maak een nieuwe aan koffie / tweets.coffee bestand en verwijs naar de gecompileerde versie van dit bestand in index.html.

Vervolgens halen we de gewenste tweets op via de gebruiksvriendelijke Search API van Twitter. Om een ​​JSON-bestand met deze tweets op te halen, kunnen we de volgende URL gebruiken:

http://search.twitter.com/search.json?q=yeoman.io

Omdat we deze gegevens echter ophalen, gebruiken we $ .getJSON, we moeten een opgeven Bel terug parameter, zodat we het JSONP-formaat van Twitter activeren.

Raadpleeg Twitter's API voor meer zoekopties.

Laten we de klas maken.

App = App of  class App.TweetsCollection constructor: (query = 'yeoman.io', apiUrl = 'http://search.twitter.com/search.json') -> @query = query @apiUrl = apiUrl ophalen : -> $ .getJSON "# @ apiUrl? q = # @ query & callback =?"

Merk op dat we injectie van afhankelijkheid gebruiken (van de constructor) om het proces van het testen van deze code (buiten het bereik van deze tutorial) aanzienlijk eenvoudiger te maken.

Als u het wilt uitproberen, voert u binnen de console van uw browser het volgende uit:

var tweets = nieuwe App.TweetsCollection tweets.fetch (). done (function (data) console.log (data.results););

De console zou nu een lijst met tweets moeten weergeven, die verwijzen naar "yeoman.io."

Nu we de tweets hebben kunnen ophalen, moeten we vervolgens de HTML voorbereiden om ze weer te geven. Hoewel het wordt aanbevolen om een ​​goede templating-engine te gebruiken, zoals Handlebars of Underscore's implementatie, zullen we het voor de doeleinden van deze zelfstudie simpel houden. Gelukkig maken de blokkerings- en interpolatiefuncties van CoffeeScript het inbedden van HTML zo elegant mogelijk.

class App.TweetsView el: $ ('
    ') constructor: (tweets) -> @tweets = tweets render: -> $ .each @tweets, (index, tweet) => # Probeer in plaats daarvan een templerende engine te gebruiken. @ el.append "" "
  • # Tweet.from_user # Tweet.text
  • "" "@

Opmerking: wanneer je klaar bent om een ​​speciale templating-engine te gebruiken, vergeet dan niet om het te installeren met Yeoman en, achter de schermen, Bower: Yuan installeert stuur.

Deze code is vrij eenvoudig. Wanneer geïnstantieerd, verwacht het een aantal tweets (die we al weten op te halen). Wanneer het render () methode wordt getriggerd, zal het door die reeks tweets gaan en voor elke een een lijstitem met de nodige gegevens toevoegen aan een ongeordende lijst (@el). Dat is het!

Als je nieuwsgierig bent naar de => teken (in plaats van ->), dat is wat we een dikke pijl noemen in CoffeeScript. Het zorgt ervoor dat, binnen de anonieme functie, deze zal nog steeds verwijzen naar de TweetsView object, in plaats van de single gekwetter.

Nu onze code is ingevoerd, laten we de bal aan het rollen brengen! Terug naar de index.html bestand, voeg een nieuw toe app.js referentie.

  

Binnen scripts / koffie / app.coffee, toevoegen:

tweets = nieuwe App.TweetsCollection tweets.fetch (). done (data) -> tweetsView = new App.TweetsView (data.results) .render () $ (document.body) .html tweetsView.el

Bewaar, als je deze code bewaart, dankzij Yeoman de browser onmiddellijk vernieuwen om de laatste tweets over Yeoman weer te geven!

Je vraagt ​​je misschien af ​​waar dat is gedaan methode komt uit. Dit is nodig omdat, achter de schermen, wanneer het ophalen () methode wordt ingeschakeld App.TweetsCollection, er wordt een AJAX-verzoek ingediend. Als zodanig wordt een "belofte" teruggestuurd.

Denk aan een belofte als jQuery veelbelovend om u op de hoogte te stellen wanneer een asynchrone bewerking is voltooid. Wanneer deze asynchrone aanvraag "klaar" is, voert u deze callback-functie uit.

Toegegeven, dit was een vrij eenvoudig project, maar Yeoman heeft onze workflow aanzienlijk verbeterd.

De laatste stap is het bouwen van het project, om onze middelen en afbeeldingen (indien van toepassing) zo veel mogelijk te optimaliseren.

yeoman bouwen

Deze opdracht zal Yeoman instrueren om alle noodzakelijke taken uit te voeren en uiteindelijk een nieuwe te produceren dist map die naar uw server moet worden gepusht voor productie. Alle bestanden worden gecomprimeerd en geoptimaliseerd.

Zodra de bewerking is voltooid, kunt u een voorbeeld bekijken door het volgende uit te voeren:

yeoman server: dist

Bekijk de bron en merk op hoe de activa zijn gecomprimeerd! Maar we kunnen het beter doen. Op dit moment zijn de scripts en stylesheets (niet van toepassing in ons project) niet samengevoegd. Laten we dat oplossen met Yeoman!

Keer terug naar jouw index.html bestand en pak het script referenties met een HTML-opmerking, die Yeoman instrueert om de ingesloten bestanden samen te voegen en te verkleinen.

    

Dit vertaalt zich naar: bij het samenstellen van het project alle bestanden binnen de bouwen: js commentaarblok en vervang de scripts door een enkele verwijzing naar scripts / scripts.js, welke Yeoman automatisch voor u zal genereren. Op deze manier werken we in productie met slechts één HTTP-aanvraag in plaats van drie! Dit kan ook voor uw stylesheets worden gebruikt, maar als u Sass gebruikt, is dit niet nodig.

Met die verandering, bouw en bekijk je het project opnieuw.

yeoman build yeoman server: dist

Het werkt nog steeds! Bekijk de bron en merk op dat we nu slechts één scriptreferentie hebben.

Mensen, dit is gratis optimalisatie. Geen verborgen kosten. Gebruik het! Je laatste stap zou zijn om de dist map naar uw server en ga naar huis voor de dag!


Gedachten sluiten

Yeoman had niet op een beter moment kunnen komen.

Misschien wel het grootste aan Yeoman is dat het open is. Terwijl sommige soortgelijke tools geld kosten, is Yeoman open source, wat betekent dat jij - ja jij - het kunt vorkten en het kunt verbeteren!

Naarmate het web meer en meer naar client-side-centrische applicaties gaat, kon Yeoman niet op een beter moment komen. Dus vergeet de voorbereiding en configuratie; laten we beginnen met het bouwen van dingen.

Om op de hoogte te blijven van het laatste nieuws over de Yeoman, of om suggesties en functieverzoeken te doen, kun je @yeoman op Twitter volgen en je abonneren op zijn Google-groep.