What is Yoeman?? Why should we see this regularly in gruntfile.js?


Any of you are aware of this yoeman? But sure, i am not in one of you. I frequently see in gruntfile.js having following code..

<%= yeoman.app %> & <%= yeoman.dist %>

In files..

js: {
files: [‘<%= yeoman.app %>/**/*.js’],
tasks: [‘newer:jshint:all’],
options: {

html: {
files: [‘<%= yeoman.app %>/**/*.html’],
options: {


I dont understand anything..coz i am new to all..neither grunt not yoeman.. i am a new born baby with no thoughts 😛

Lets meet yoeman 🙂


Yoeman can write boilerplate code for your entire web application or individual pieces like Controllers and Models. Yeoman can fire up a preview web server and watch your files for edits in order to live reload changes and compile your Sass. Yeoman can also run your unit tests, minimize and concatenate your code, optimize images, plus more!

Yeoman also works with other tools for improving your productivity:

  • grunt is used to build, preview, and test your project, thanks to help from tasks curated by the Yeoman team and grunt-contrib.
  • gulp is an alternative to GruntJS that favors code over configuration.
  • bower is used for dependency management, so that you no longer have to manually download your front-end libraries.

You can install Yeoman generators using the npm command

Request to go thru this url once and even this

Stackoverflow says:

More specifically, yeah… Yeoman is a generator. For example, if I run the latest generator-angular, the Gruntfile.js it produces includes this bit of code:

yeoman: {
  // configurable paths
  app: require('./bower.json').appPath || 'app',
  dist: 'dist'

So you can see, at least from the generator I used, that <%= yeoman.app %> will default to a directory called ‘app’ and <%= yeoman.dist %> will point to ‘dist’. If I pasted the entire Gruntfile the generator created for me, you would also see these are used by many of the tasks that build and test the app.

Refer here

How to start up with yoeman?? here

Thought to explain the configuration and kickstart of yoeman..but after looking the documentation i changed my decision. Its really very simple with clear explanation & screen shots in the yoeman documentation

List of yoeman generators


How to start-up with grunt?? – Beginners Tutorial

Hi Pals,

Lets walk through the beginners tutorial of grunt. I would like to thank Brain P.Hogan for his detail explanation in “Automate with grunt” book.

Note: I just followed and simplifed Hogan theory for grunt.


1. Editor like sublime text/brackets

2. Node.js in your machine

What is Grunt? Why it is needed?

Grunt is a task runner, designed to be more configuration than code. if you know JavaScript, Grunt becomes a
very powerful automation tool for many types of projects. If you have a manual repetitive task you run as part of your development or deployment process, chances are there’s a way to automate that process with Grunt.

Installing & Configuring Grunt

Before we can do anything with Grunt, we have to install the Grunt commandline tool. Grunt is written in Node.js, and to install it we use npm, the tool Node uses to download and manage dependencies. Open a new Terminal and
type the following command:
$ npm install -g grunt-cli

The grunt-cli tool we installed globally on our system will then work with the version of grunt within our project. Let’s create a simple project folder and set everything up. Create a new folder called kicking_tires and navigate into that folder in your Terminal:
$ mkdir kicking_tires
$ cd kicking_tires

we can add Grunt as a development dependency in current project like this:
$ npm install grunt –save-dev // this allows grunt to install only in current project
Grunt will be installed into the node_modules/ subfolder of the current folder, and it’ll be added to the package.json file as a development dependency.

The –save-dev command also saves the version number into the package.json file, and it uses the tilde in front of the version number to signify that any version. The node_modules folder contains all of the libraries our project depends on. This means you have a copy of the Grunt library itself in the node_modules folder.

Adding things as development dependencies allows new people who want to work on our project to easily download all of the dependencies we specify by issuing the npm install command in the folder that contains the package.json file. In fact, let’s try this now. Remove the node_modules folder and then run npm install. You’ll see that npm fetches Grunt again, creating a new node_modules folder.

With Grunt installed, we can test things out by running it from the command line:
$ grunt
This fires off the grunt-cli library we installed globally, which then uses the grunt library we installed in our project’s node_modules folder.

Grunt is telling us that we need something called a Gruntfile in our project. A Gruntfile is a JavaScript file that specifies and configures the tasks you want to be able to run for your project.Grunt is specifically looking for a file called Gruntfile.js in the current working directory and it can’t find one, so let’s create a Gruntfile.

Every Gruntfile starts out with some boilerplate code. Create a new file called Gruntfile.js and add this:
path: basics/kicking_tires/Gruntfile.js


module.exports = function(grunt){
// Your tasks go here

Here you’re defining a Node.js module that receives a grunt object. You’ll use that object and its methods throughout your configuration files. Now, within the curly braces, define the following task, which prints some text to the screen:
grunt.registerTask(‘default’, function(){
console.log(‘Hello from Grunt.’);

We use grunt.registerTask() to create a new Grunt task. We pass in a task name followed by an associated callback function. Whatever we put in the callback function is executed when we invoke the task. To see it in action, run this new task from the Terminal:
$ grunt
You’ll see the following output:
Running “default” task
Hello from Grunt.
Done, without errors.

In this task we’ve used Node’s console.log function, but we really should use
Grunt’s grunt.log() object instead.

So, change the following:
console.log(‘Hello from Grunt.’);
grunt.log.writeln(‘Hello from Grunt.’);
and rerun the task with
$ grunt
You shouldn’t see anything different.

Let’s create another rather silly task that adds some numbers together. In the Gruntfile, add this task:
grunt.registerTask(‘addNumbers’, function(first, second){
var answer = Number(first) + Number(second);
grunt.log.writeln(first + ‘ + ‘ + second + ‘ is ‘ + answer);
To run this task, we have to supply both numbers as arguments to the task,and we do that using colons, like this:
$ grunt addNumbers:1:2
And when we do that, we see this result:
Running “addNumbers:1:2” (addNumbers) task
1 + 2 is 3.

Handling Errors:

we’ll want to log error messages. We can do that with grunt.log().In our addNumbers() task, let’s check to make sure the first argument is a number. If it isn’t, we’ll print an error on the screen:
grunt.warn(‘The first argument must be a number.’);
Now run this with
$ grunt addNumbers:a:2
and you’ll see an interesting response from Grunt:

Running “addNumbers:a:2” (addNumbers) task
Warning: The first argument must be a number. Use –force to continue.

Running our task with the –force option. Let’s try that:
$ grunt addNumbers:a:2 –force
Running “addNumbers:a:2” (addNumbers) task
Warning: The first argument must be a number. Used –force, continuing.
a + 2 is NaN
Done, but with warnings.

Run Multile Tasks as one:

Grunt offers the ability to create one task that fires off other tasks. Grunt refers to this as an alias.
To make a task like this we use registerTask() and pass it an array of tasks instead of a callback function.
grunt.registerTask(‘all’, [‘default’, ‘greet:Brian’, ‘addNumbers:2:3’]);
Notice that when we do this we pass these task names as strings, which means we can pass arguments as well.

We’ve called this task all, but if we renamed it to default we’d be able to run this task by running grunt with no arguments. The default task is commonly used to run the test suite for a project.

Adding text description to your tasks:

Let’s define a simple task called praise() that makes Grunt say some words of encouragement to you.
‘Have Grunt say nice things about you.’, function(){
var praise = [
“You’re awesome.”,
“You’re the best developer ever!”,
“You are extremely attractive.”,
“Everyone loves you!”
var pick = praise[(Math.floor(Math.random() * praise.length))];
Now type this:
$ grunt –help
This shows Grunt’s basic help page, but in the middle of the output you’ll see this:
Available tasks
default Custom task.
greet Custom task.
addNumbers Custom task.
all Alias for “default”, “greet:Brian”, “addNumbers:2:3” tasks.
praise Have Grunt say nice things about you.
All the tasks we didn’t document just say “Custom task,” but our praise() task shows its description.

1st chapter – creating a basic project

Let’s create a project folder called deployment and then navigate into it:
$ mkdir deployment
$ cd deployment
$ npm init
Fill in the basic information or leave it at its default values. Alternatively, create your own package.json file that contains this:
“name”: “deploying”,
“version”: “0.0.0”,
“description”: “A simple project to copy files for deployment.”
Next, we add Grunt as a dependency:
$ npm install grunt –save-dev
Now we’ll create a basic Gruntfile.js with the following content:

module.exports = function(grunt){
Now let’s create a few simple files and folders in this project. First, create an index.html file with a default HTML5 template:
<!DOCTYPE html>
<html lang=”en-US”>
<meta charset=”utf-8″>
<title>Test page</title>
<link rel=”stylesheet” href=”stylesheets/style.css”>
<h1>Test page</h1>
Then create the folders stylesheets and javascripts:
$ mkdir stylesheets
$ mkdir javascripts
After that, create a stylesheets/style.css file with the following contents:
h1{color: #F00;}

Finally, create the file javascripts/app.js, which looks like this:
var app = {};
app.name = ‘Hello’;
With the setup out of the way, let’s jump into how we work with these files in Grunt tasks.

Create a copy of files into another directory where build runs with these copied files

Grunt provides many options like watchers(if you save in any html/js file, automatically page reloads), working copy directory for your build etc etc.

Here we will see, how grunt helps in copying your files to working copy folder:

Grunt provides grunt.config.init(), which lets us define the configuration for our Grunt tasks by passing in a JavaScript object with the properties and values for our tasks.

Our target is to add a copyFiles property in this config file..

A best practice for creating configuration options for a task is to place all options within an options property.

We need a way to specify the destination folder that we’ll copy our files to, so we’ll create an option for the workingDirectory:
copyFiles: {
options: {
workingDirectory: ‘working’,

So, did you understood what exactly grunt is??

Well, in simple words..its pretty a task runner that runs with your own commands(which you creates as tasks).

Let me brief with a very small example..now i wanna create a folder/delete a folder with my own commands in grunt..so my commands would be something like

$grunt createFolder // this creates a folder in some specified path

$grunt clean// Deletes the working folder and its contents

Now lets explain with necessary code..

Grunt’s built-in grunt.util.mkdir() method creates folders, and so all we have to do is create a task, read the name of the directory from our configuration object, and create the folder.
Creating and Deleting Directories
grunt.registerTask(‘createFolder’, ‘Create the working folder’, function(){
We’re using grunt.config.requires() to ensure that the configuration property we want has been set.

We then use grunt.config.get() to fetch the value out of the object and use it to create the folder, using the same dot notation.At the command line we can run
$ grunt createFolder
and we’ll see the new working folder in our directory.

To remove the working folder, we can write a very similar task, but this time we’ll use Grunt’s grunt.file.delete() method instead. This deletes a file, or a folder and all of its contents.
‘Deletes the working folder and its contents’, function(){

Copying Files
Our project may have lots of files that we don’t want to deploy to the web server. For example, there’s no need to send up our Gruntfile.js or the node_modules folder if we’re building a basic website. So we’ll need to tell Grunt what files we want to copy over. Let’s create a new manifest property of our copyFiles configuration object, which will be an array of file paths we want to copy.

copyFiles: {
options: {
workingDirectory: ‘working’,
➤ manifest: [
➤ ‘index.html’, ‘stylesheets/style.css’, ‘javascripts/app.js’
➤ ]
Grunt provides grunt.file.copy(), which lets us specify a source file and a destination.

Our copyFiles task will check for the workingDirectory and manifest properties and then iterate over the files in the manifest, copying each file into the working folder.
grunt.registerTask(‘copyFiles’, function(){
var files, workingDirectory;
files = grunt.config.get(‘copyFiles.options.manifest’); workingDirectory =
files.forEach(function(file) {
var destination = workingDirectory + ‘/’ + file;
grunt.log.writeln(‘Copying ‘ + file + ‘ to ‘ + destination);
grunt.file.copy(file, destination);
We can run this task with
$ grunt copyFiles
Running “copyFiles” task
Copying index.html to working/index.html
Copying stylesheets/style.css to working/stylesheets/style.css
Copying javascripts/app.js to working/javascripts/app.js
Done, without errors.
and the files are copied now into our working folder.

All set, now do all at once

Now, to make this all fit together nicely, let’s create a new task that runs the clean, createFolder, and copyFiles tasks. Let’s call the task deploy, shall we?
grunt.registerTask(‘deploy’, ‘Deploys files’,
[‘clean’, ‘createFolder’, ‘copyFiles’]);
Creating and Deleting Directories • 15
Run this new task:
$ grunt deploy
Running “clean” task
Running “createFolder” task
Running “copyFiles” task
Copying index.html to working/index.html
Copying stylesheets/style.css to working/stylesheets/style.css
Copying javascripts/app.js to working/javascripts/app.js
Done, without errors.

Read JSON data

Grunt provides a function called file.readJSON() that reads json data from a file and parse it into a javascript object.


pkg: grunt.file.readJSON(‘package.json’),

Fetching Client-Side Libraries with Bower

Bower is a package manager for client-side libraries, and it’s a great way to quickly grab the libraries our project needs. Bower downloads any libraries we specify into a bower_components folder in our project. First, we’ll install
Bower globally:
$ npm install -g bower
Bower uses the Git version-control system to fetch libraries, so you’ll need to install the Git command-line client on your computer.And if you’re on Windows, you’ll need to install Git so that it runs from your Windows Command Prompt, not the default “Bash shell” option.

once Bower’s all set up, we can use it to fetch Angular and the other libraries, like this:

$ bower install angular
$ bower install angular-resource
$ bower install jquery
Now, if you look under the bower_components folder, you’ll see folders for angular,angular-resource, and jquery, with the appropriate JavaScript libraries in each folder. That’s a lot easier than finding, downloading, unzipping, and moving a bunch of files around :).

Note: If we didn’t specify any version info, Bower just grabs the latest version it knows about.

Minifying JavaScript
To make our JavaScript download faster, we’re going to minify it. This process removes comments, whitespace, and line breaks, and even obfuscates code by shortening variable names. We’ll use the Uglify utility to do this by way of
the grunt-contrib-uglify plug-in.
First, we install the plug-in:
$ npm install grunt-contrib-uglify –save-dev

grunt.config(‘uglify’, {
scripts: {
files: {
‘assets/app.js’ : ‘tmp/app.js’
And that takes care of the JavaScript! Test it out by running the following:
$ grunt uglify
Running “uglify:scripts” (uglify) task
File assets/app.js created: 816.58 kB → 128.81 kB
Done, without errors.

Adding Sass to Grunt
By this point you can probably guess how this will work. There’s a plug-in called grunt-contrib-sass that we have to install and configure. So, install the plug-in with npm:
$ npm install grunt-contrib-sass –save-dev
Then add the following configuration to the Gruntfile:
grunt.config(‘sass’, {
app: {
files: {
‘tmp/app.css’: [‘sass/style.scss’]
Notice that we placed the output file in the tmp folder. We’re not quite done with the stylesheet yet.

Minifying Our CSS
We’ve minified the JavaScript code in our app, and now we’ll do the same with our CSS. We’ll use the grunt-contrib-cssmin plug-in to do this, and the configuration for this is very easy. First, install the plug-in as a dependency:
$ npm install grunt-contrib-cssmin –save-dev
Then, configure it almost exactly like the uglify task for JavaScript, by reading in the tmp/app.css file that the Sass task created and placing the minified version in the assets/ folder:
grunt.config(‘cssmin’, {
app: {
files: {
‘assets/app.css’: [‘tmp/app.css’]
Now let’s run the cssmin task to generate the assets/app.css file that our interface wants:
$ grunt sass cssmin
Running “cssmin:app” (cssmin) task
File assets/app.css created: 1 kB → 537 B
Done, without errors.
The task runs perfectly, cutting our file size nearly in half. And now we have all the components of our workflow, as well as a completely working application that you should be able to view by opening index.html in your browser.
Let’s simplify this whole process with a build task that runs all of the steps.

 Simplifying the Build

We want one task that, when called, invokes the tasks to build the JavaScript files and the CSS files.
Let’s add a build task to our Gruntfile:
grunt.registerTask(‘build’, “Builds the application.”,
[‘coffee’, ‘concat:scripts’, ‘sass’, ‘cssmin’, ‘uglify’ ]);
When we execute this build task, the whole process runs.
$ grunt build
Running “coffee:app” (coffee) task
Running “concat:scripts” (concat) task
File “tmp/app.js” created.
Running “sass:app” (sass) task
File tmp/app.css created.

Running “cssmin:app” (cssmin) task
File assets/app.css created.
Running “uglify:scripts” (uglify) task
File assets/app.js created.
Done, without errors.
A single command builds our application, letting us take advantage of powerful preprocessors and minification tools.

Watching Files for Changes

We’ve set up a ton of tasks so far, but every time we make a change to a file we have to run Grunt manually. And we really should never have to do anything manually when it comes to task management. Let’s use the gruntcontrib-
watch plug-in to watch files for changes and run the appropriate tasks.
Install the plug-in first:
$ npm install grunt-contrib-watch –save-dev
To configure this plug-in, we specify a target, the files to watch, and the Grunt tasks that should run when those files change. For our JavaScript files, we’ll actually want to watch the CoffeeScript files for changes. When those files
change, we’ll need to run the coffee(), concat(), and uglify() tasks. Then we’ll want to watch the CSS files for changes and run the sass and cssmin tasks. So first, let’s set up the configuration to watch the JavaScript files:
grunt.config(‘watch’, {
scripts: {
files: [‘coffeescripts/**/*.coffee’],
tasks: [‘coffee’, ‘concat:scripts’, ‘uglify’],
options: {
spawn: false
And then, inside of that configuration block, we’ll add another target for the Sass files:

styles: {
files: [‘sass/**/*.scss’],
tasks: [‘sass’, ‘cssmin’],
options: {
spawn: false
To use this, we employ the grunt watch command. Unlike other tasks, Grunt doesn’t return to the command line. Instead, it stays running in a loop, watching files for changes. Open one of the Sass files or the CoffeeScript files,
make a change, save the file, and watch the changes happen.
To stop watching, press Ctrl-C

Refreshing the Browser Automatically

The grunt-contrib-watch plug-in has built-in support for LiveReload, an amazing tool that can automatically reload web pages and CSS documents in the browser whenever files change. This is incredibly useful for any web developer,
so let’s configure it.
All we have to do is add a few additional options to the configuration section for the grunt-contrib-watch plug-in. First, we’ll configure it to watch for changes to the index.html file. We won’t need to run any tasks when that file changes.
And then we’ll include the option to enable LiveReload support.
interface: {
files: [‘index.html’]
options: {
livereload: true
To see this in action, you’ll need to download the extension for your web browser. You can get extensions for Chrome, Firefox, and Safari from the LiveReload website.6 Install the plug-in, then fire up grunt-watch in your Terminal and activate the plug-in. Then change something in the HTML or the CSS and see the page update after you save the file.

Introduction to Grunt


Lets explore a new trendy task runner i.e., grunt today…


Built on top of Node.js, Grunt is a task-based command-line tool that speeds up workflows by reducing the effort required to prepare assets for production. It does this by wrapping up jobs into tasks that are compiled automatically as you go along. Basically, you can use Grunt on most tasks that you consider to be grunt work and would normally have to manually configure and run yourself.

What’s Grunt used for? Automating front-end and JavaScript workflow tasks. Refreshing the browser when you change a script. Minifying and concatenating.

Front-end developers are often told to do certain things:

  • Work in as small chunks of CSS and JavaScript as makes sense to you, then concatenate them together for the production website.
  • Compress your CSS and minify your JavaScript to make their file sizes as small as possible for your production website.
  • Optimize your images to reduce their file size without affecting quality.
  • Use Sass for CSS authoring because of all the useful abstraction it allows.
  • By using grunt you can validate javascript file and you can compress/uglify it too..you can even clean files in directory using contrib-clean



Grunt Setup:

In order to start with grunt you have to install nodejs as grunt runs on nodejs…so first install nodejs..

Then go to your working directory and type

npm install -g grunt-cli

then followed by npm install grunt –save-dev and npm install grunt-contrib-clean –save-dev

Now head up in creating package.json and grunt.js files…


“name”: “project-zero”,
“version”: “0.1.0”,
“devDependencies”: {
“grunt”: “^0.4.5”,
“grunt-contrib-jshint”: “~0.10.0”,
“grunt-contrib-nodeunit”: “~0.4.1”,
“grunt-contrib-uglify”: “~0.5.0”


module.exports = function(grunt) {

grunt.config(‘options.api’, grunt.option(‘api-server’) || ‘http://localhost:3000/&#8217;);

grunt.config(‘copy.index’, {
src: ‘index.html.ejs’,
dest: ‘index.html’,
options: {
process: function(content, path) {
return grunt.template.process(content);