updating README.md files

Author: crolek

Example1/README.md

@@ -25,7 +25,7 @@ somewhere, but don't want to type that long path each time.
 The src section can be a single file, array of files, or match a pattern. 
 Remember, because I used cwd above the current path is: `src/`
 The `css/**` piece tells Grunt to not only look in the root of the css folder, 
-also copy the contents of all of the sub folders.
+also copy the contents of all of the sub folders. This configuration uses the [dynamic file objects feature](http://gruntjs.com/configuring-tasks#building-the-files-object-dynamically) and the [global pattern syntax](http://gruntjs.com/configuring-tasks#globbing-patterns). 
 
 `src: ["js/*", "css/**"],`
 
@@ -47,4 +47,10 @@ To "run" a Grunt task you use a simple syntax of the word grunt and the task nam
 `grunt prod` will move the CSS and JS assets to the `/dist` folder.
 
 #Additional Notes
-For more information on the [grunt-contrib-copy make sure to visit their github page.](https://github.com/gruntjs/grunt-contrib-copy)
+For more information visit the following links:
+
+* [grunt-contrib-copy make sure to visit their github page.](https://github.com/gruntjs/grunt-contrib-copy)
+
+* [dynamic file objects feature](http://gruntjs.com/configuring-tasks#building-the-files-object-dynamically) 
+
+* [global pattern syntax](http://gruntjs.com/configuring-tasks#globbing-patterns)

Example2/README.md

@@ -1,41 +1,45 @@
 #Example2 Goals
-This example will compile a single Less file into one CSS file and the other task will take multiple Less files and compile them into one file. In this example you'll see there are two different registered Grunt tasks for you to use.
+This example will compile a single LESS file into one CSS file and the other task will take multiple LESS files and compile them into one file. In this example you'll see there are two different configurations for one Grunt task.
 
 #Example2 Explained
-In this example I setup 2 different Grunt tasks under the Less compiler. 
-The first task is:
+In this example I setup 2 different Grunt configurations under the `less` task. 
+The first configuration is:
 
 	onlyFile1: {
 		files: [
 			{"dist/css/file1.css": "src/less/file1.less"}
 		]
 	},
 
-This task targets only the Less file called file1 and compiles it into file1.css. This is a pretty simple example of 1 to 1 compiling for Less files.
+This configuration targets only the LESS file called `file1.less` and compiles it into `file1.css`. This is a pretty simple example of 1 to 1 compiling for LESS files.
 
-The next Less task is one that compiles multiple files:
+The next LESS configuration is one that compiles multiple files:
 
 	allFiles: {
 		files: [
 			{"dist/css/common.css": "src/less/*.less"}
 		]
 	}
 
-Any less files in the src/less/ folder will get compiled into 1 CSS file called dist/css/common.css. Grunt uses this 1 to many syntax for a lot of different tasks, so once you get use to it you can use it all over the place. If you were to aggregate CSS/JS files you'd use the same sytnax as the one above.
+Any less files in the `src/less/` folder will get compiled into 1 CSS file called `dist/css/common.css`. Grunt uses this 1 to many syntax for a lot of different tasks, so once you get use to it you can use it all over the place. If you were to aggregate CSS/JS files you'd use the same sytnax as the one above.
 
 One difference from Example1 that you'll notice is how I registerd the Grunt tasks.
 
 	grunt.registerTask("onlyfileone", ["less:onlyFile1"]);
 	grunt.registerTask("prod", ["less:allFiles"]);
 
-In both tasks there is the word `less`, a colon, and the sub-tasks (`onlyFile1`, or `allfiles`). This is where I think Grunt becomes really awesome. What Grunt is allowing me to do is point directly at a sub-task instead of the task as a whole. So if I registered: `grunt.registerTask("prod", ["less"]);` it would run all sub-tasks inside of the `less` task no matter how many there are. Using the : helps tell Grunt which tasks to specifically run; you can chain these together if you need to:
+In both tasks there is the word `less`, a colon, and the sub-tasks (`onlyFile1`, or `allfiles`). This is where I think Grunt becomes really awesome. What Grunt is allowing me to do is point directly at a specific configuration instead of the task as a whole. So if I registered: `grunt.registerTask("prod", ["less"]);` it would run all configurations inside of the `less` task no matter how many there are. Using the `:` helps tell Grunt which tasks to specifically run. This is awesome because you can chain these together if you need to:
 
 	grunt.registerTask("prod", ["less:allFiles", "less:someOtherTask", "less:anotherTask"]);
 
 #To run this Example
-`grunt onlyfileone` will compile only one Less file
+`grunt onlyfileone` will compile only one LESS file
 
-`grunt prod` will compile all of the Less files
+`grunt prod` will compile all of the LESS files
 
 #Additional Notes
-For more information on the [grunt-contrib-less make sure to visit their github page.](https://github.com/gruntjs/grunt-contrib-less)
+For more information visit the following links:
+
+* [grunt-contrib-less make sure to visit their github page.](https://github.com/gruntjs/grunt-contrib-less)
+
+* [configuring tasks](http://gruntjs.com/configuring-tasks)

Example3/README.md

@@ -2,7 +2,7 @@
 This example will show you how you'd setup a minified and non-minified version of css and js. Technically this is only a minor increase from Example2, but I think it was important enough to split out so certain parts can be clear.
 
 #Example3 Explained
-Debugging minified javascript is a pain, so its always nice to do development against an unminified code. In this example we'll be taking multiple Less files and compiling them into one CSS file, and then minifying them. We'll also be taking multiple JS files, concatenating them together, and then minifying them.
+Debugging minified javascript is a pain, so its always nice to do development against an unminified code. In this example we'll be taking multiple LESS files and compiling them into one CSS file, and then minifying them. We'll also be taking multiple JS files, concatenating them together, and then minifying them.
 
 The first task is the one that does the JS file concatenation:
 
@@ -13,9 +13,9 @@ The first task is the one that does the JS file concatenation:
 		}
 	},
 
-You might normally use this to concatanate CSS files if you were not already using a Less compiler. However, since I am using a Less compiler I'll just use it to concatenate all of the JS files.
+You might normally use this to concatanate CSS files if you were not already using a LESS compiler. However, since I am using a LESS compiler I'll just use it to concatenate all of the JS files.
 
-The Less task you already saw in Example2.
+The LESS task you already saw in Example2.
 
 The javascript uglify task is the next one:
 
@@ -30,7 +30,7 @@ The uglify task does basically what any other javascript uglifier/minifier does.
 
 
 
-I setup this Grunt file so when `grunt prod` is run an unminified version of the file will be created, and another minified verison of the file will be made. This way I can keep track of both version as I needed. The grunt task will first run the JS concatenator so that all the javascript files are turned into `dist/js/all-js.js`. Next the Less files will be compiled into `dist/css/common.css` much like Example2. However, the next two steps take those finished files, minify them, and save a copy off with thte word "min" in it. So `all-js.js` becomes `all-js.min.js`, and `common.css` becomes `common.min.css`.
+I setup this Grunt file so when `grunt prod` is run an unminified version of the file will be created, and another minified verison of the file will be made. This way I can keep track of both version as I needed. The grunt task will first run the JS concatenator so that all the javascript files are turned into `dist/js/all-js.js`. Next the LESS files will be compiled into `dist/css/common.css` much like Example2. However, the next step takes the finished JS file, minifies it, and then saves a copy off with thte word "min" in it. So `all-js.js` becomes `all-js.min.js`.
 
 
 I think if you go with a two file setup (one minified, one not) that its important to create 2 different Grunt tasks. One with the minification and one without it that way if you need an unminified version of the file(s) you don't have to monkey with your primary grunt task.
@@ -43,4 +43,7 @@ I think if you go with a two file setup (one minified, one not) that its importa
 
 
 #Additional Notes
-For more information on the [.]()
+For more information visit the following links:
+
+* [grunt-contrib-concat](https://github.com/gruntjs/grunt-contrib-concat)
+* [grunt-contrib-uglify](https://github.com/gruntjs/grunt-contrib-uglify)

Example4/README.md

@@ -1,10 +1,34 @@
 #Example4 Goals
-A you ready to "watch" something cool happen!? So you've got all of these awesome Grunt tasks, but who wants to type `grunt dev` each time they're working on something? Not me, so more than likely not you. This example will show you how to make it so Grunt tracks your file changes and runs any task(s) you want automatically.
+A you ready to "watch" something cool happen!? So you've got all of these awesome Grunt tasks, but who wants to type `grunt dev` (or whatever) each time they're working on something? Not me, so more than likely not you. This example will show you how to make it so Grunt tracks your file changes and runs any task(s) you want automatically.
 
 #Example4 Explained
-Before I get into the Watch command I want to try and clarify something up front. The files that Grunt Watches do not have to be the same files that are associated with that task you want run (most of the time they will be, but its not required). For example you could have Grunt compile Less files on any change done to an HTML file. It might seem wasteful, but there is probably a perfect case for it. Again, commonly when you configure the Watch you will probably have it the same files that the actual task is associated with. It'll look redudant, but I'll do my best to explain it clearly below.
+Before I get into the Watch command I want to try and clarify something up front. The files that Grunt "watches" do not have to be the same files that are associated with that task you want run (most of the time they will be, but its not required). For example you could have Grunt compile Less files on any change done to an HTML file. It might seem wasteful, but there is probably a perfect case for it. Again, commonly when you configure the Watch you will probably have it the same files that the actual task is associated with. It'll look redudant, but I'll do my best to explain it clearly below.
 
+In each Watch configuration you need to pick what files the task needs to watch and what tasks to run.
+
+	onlyhtml: {
+		files: ["src/test.html"],
+		tasks: ["concat", "less"]
+	},
+
+Above is the confugation for `onlyhtml`. The Grunt Watch feature will only trigger when you save the `src/test.html` file. When you save the the test.html file it will run the `concat` and `less` task. Do an `npm install`, and then type `grunt watch:onlyhtml`. when you do this you'll see a message like `Waiting...`. This is Grunt Watch's way of telling you that its waiting for you to save a file. When save that file it'll run those tasks, and upon completion go back into the `Waiting...` state.
+
+The Watch task has a `dev` and `prod` Watch configuration. The names of these configurations do not have to match the names used in the `grunt.registerTask("...")`. 
+
+#To run this Example
+
+`grunt dev` will generate an unminified set of aggregated CSS and JS assets
+
+`grunt prod` will generate an unminifed and minified set of aggregated CSS and JS assets
+
+`grunt watch` will run the last configuration in the `watch` task. (In this case it would be `watch:prod`)
+
+`grunt watch:dev` will be the same as `grunt dev`, but using the Watch feature.
+
+`grunt watch:prod` will be the same as `grunt prod`, but using the Watch feature.
 
 
 #Additional Notes
-For more information on the [.]()
+For more information visit the following links:
+
+* [grunt-contrib-watch](https://github.com/gruntjs/grunt-contrib-watch)

README.md

@@ -13,4 +13,5 @@ Once you've done that all you need to do is open a command prompt to where you'v
 * Example1: A simple copy/paste of source files.
 * Example2: Compiling Less files
 * Example3: Minifying/Aggregating CSS and JS using multple tasks.
-* Example4: Grunt Watch - bringing it all together!
+* Example4: Grunt Watch - bringing it all together!
+* StopDoingThingsManually - my "admin" project of sort for managing all the examples.