Standardize docs code block declarations (#37)

* Replace file names starting with /tests/ with tests/

* change filename from `/app/` to `app/`

* fix language name for js code blocks

* Correct codeblocks language from apache to apacheconf

* Correct codeblock language name from hbs to handlebars

* correct language from `js` to `javascript` in code blocks

* change `shell` and `sh` to `bash in languages

* Correct `sh` to `bash` in language

* Fix filepaths for config path

* Remove whitespace between ``` and language

* fix codeblocks for .jshintrc files

* Fix codeblocks for acceptance tests

* Fix typo in guides

* Fix syntatic mistakes

* Add language to codeblock

* Fix codeblocks

* Fix code block backticks

* Fix filename extension

* Standardise codeblock languages.

Some fenced blocks don't have languages mentioned & some don't use the data-diff format for diff. this fixes it

Author: sivakumar-kailasam

guides/v1.10.0/components/handling-user-interaction-with-actions.md

@@ -6,7 +6,7 @@ To make a reusable control useful, however, you first need to allow
 users of your application to interact with it.
 
 You can make elements in your component interactive by using the
-`{{action}}` helper. This is the [same `{{action}}` helper you use in
+`{{action}}` helper. This is the same `{{action}}` helper you use in
 [application templates](../../templates/actions/), but it has an
 important difference when used inside a component.
 

guides/v1.10.0/components/passing-properties-to-a-component.md

@@ -27,7 +27,7 @@ App.IndexRoute = Ember.Route.extend({
 ```
 
 ```handlebars
-{{! index.handlebars }}
+{{!-- index.handlebars --}}
 <h1>Template: {{title}}</h1>
 {{blog-post}}
 ```
@@ -54,7 +54,7 @@ available inside the component's template using the same name, `title`.
 If, in the above example, the model's `title` property was instead
 called `name`, we would change the component usage to:
 
-```
+```handlebars
 {{blog-post title=name}}
 ```
 

guides/v1.10.0/components/sending-actions-from-components-to-your-application.md

@@ -94,7 +94,7 @@ App.IndexRoute = Ember.Route.extend({
 ```
 
 ```handlebars
-{{! index.handlebars }}
+{{!-- index.handlebars --}}
 
 {{#each todo in todos}}
   <p>{{todo.title}} <button {{action "deleteTodo" todo}}>Delete</button></p>
@@ -138,7 +138,7 @@ Now we can update our initial template and replace the `{{action}}`
 helper with our new component:
 
 ```handlebars
-{{! index.handlebars }}
+{{!-- index.handlebars --}}
 
     {{#each todo in todos}}
       <p>{{todo.title}} {{confirm-button title="Delete" action="deleteTodo" param=todo}}</p>

guides/v1.10.0/configuring-ember/disabling-prototype-extensions.md

@@ -35,7 +35,7 @@ EmberENV.EXTEND_PROTOTYPES = false;
 ```
 
 Or you can choose class which you want to disable prototype extension.
-``` javascript
+```javascript
 EmberENV.EXTEND_PROTOTYPES = {
   String: false,
   Array: true

guides/v1.10.0/models/defining-models.md

@@ -110,7 +110,7 @@ attribute types, and new types can be registered as transforms. See the
 
   Example
 
-  ```JavaScript
+  ```javascript
   var attr = DS.attr;
 
   App.User = DS.Model.extend({

guides/v1.10.0/models/the-fixture-adapter.md

@@ -16,7 +16,7 @@ Using the fixture adapter entails three very simple setup steps:
 Simply attach it as the `ApplicationAdapter` property on your instance
 of `Ember.Application`:
 
-```JavaScript
+```javascript
 var App = Ember.Application.create();
 App.ApplicationAdapter = DS.FixtureAdapter;
 ```
@@ -27,7 +27,7 @@ You should refer to [Defining a Model][1] for a more in-depth guide on using
 Ember Data Models, but for the purposes of demonstration we'll use an example
 modeling people who document Ember.js.
 
-```JavaScript
+```javascript
 App.Documenter = DS.Model.extend({
   firstName: DS.attr( 'string' ),
   lastName: DS.attr( 'string' )
@@ -39,7 +39,7 @@ App.Documenter = DS.Model.extend({
 In order to attach fixtures to your model, you have to use `reopenClass` method and define
 fixtures:
 
-```JavaScript
+```javascript
 App.Documenter.reopenClass({
   FIXTURES: [
     { id: 1, firstName: 'Trek', lastName: 'Glowacki' },
@@ -51,7 +51,7 @@ App.Documenter.reopenClass({
 That's it! You can now use all of methods for [Finding Records][2] in your
 application. For example:
 
-```JavaScript
+```javascript
 App.DocumenterRoute = Ember.Route.extend({
   model: function() {
     return this.store.find('documenter', 1); // returns a promise that will resolve

guides/v1.10.0/routing/specifying-a-routes-model.md

@@ -158,7 +158,7 @@ For example, if you transitioned to the `photo` route with a model whose
 `id` property was `47`, the URL in the user's browser would be updated
 to:
 
-```shell
+```bash
 /photos/47
 ```
 

guides/v1.10.0/testing/testing-xhr.md

@@ -10,7 +10,7 @@ When a promise runs, it schedules fulfillment/rejection to be executed by the ru
 
 Getting the results of a promise requires you to use the `then` method. Calling the `then` function on an existing promise:
 
-``` javascript
+```javascript
 // let's call the existing promise promise1, so you'd write:
 promise1.then(fulfillmentCallback, rejectionCallback);
 
@@ -27,7 +27,7 @@ In the case that `promise1` succeeds, then the `fulfillmentCallback` function wi
 
 If you pass in a function to `then` it casts the function into a promise and returns the promise.  The results of that promise will be what's returned from the function.
 
-``` javascript
+```javascript
 // let's call the existing promise promise1 and will have the result `3`, so you'd write:
 var promise2 = promise1.then(function(results){
   return results + 2;
@@ -57,7 +57,7 @@ var promise4 = promise1.then(function(results){
 
 If you pass a promise into `then` it will return the results of that promise.
 
-``` javascript
+```javascript
 // let's call the existing promises promise1 and promise2, so you'd write:
 var promise3 = promise1.then(promise2);
 
@@ -100,7 +100,7 @@ promise3.then(function(result){
 6. Run loop: run "fulfill the promise" task (which includes notifying all chained promises/observers of fulfillment)
 7. Run loop is off since there are no more tasks
 
-``` javascript
+```javascript
 new Ember.RSVP.Promise(function(resolve){
   // resolve will run ~10 ms after the then has been called and is observing
   Ember.run.later(this, resolve, 'hello', 10);
@@ -121,7 +121,7 @@ new Ember.RSVP.Promise(function(resolve){
 8. Code: Observe Promise1 (since the promise has already fulfilled, schedule an async task to notify this observer of fulfillment)
 9. Uncaught Error: Assertion Failed: You have turned on testing mode, which disabled the run-loop's autorun. You will need to wrap any code with asynchronous side-effects in an Ember.run
 
-``` javascript
+```javascript
 var promise = new Ember.RSVP.Promise(function(resolve){
   // this will run before the then has happened below
   // and finish the triggered run loop

guides/v1.10.0/understanding-ember/dependency-injection-and-service-lookup.md

@@ -1,6 +1,6 @@
 Dependency injection and service lookup are two important framework concepts. The first, **dependency injection**, refers to a dependent object being injected onto another object during instantiation. For example, all route objects have the property `router` set on them during instantiation. We say that the dependency of the router has been injected onto the route object.
 
-```JavaScript
+```javascript
 App.IndexRoute = Ember.Route.extend({
   actions: {
     showPath: function(){
@@ -13,7 +13,7 @@ App.IndexRoute = Ember.Route.extend({
 
 Sometimes an Ember.js library will use dependency injection to expose its API to developers. An example of this is Ember-Data, which injects its store into all routes and controllers.
 
-```JavaScript
+```javascript
 App.IndexController = Ember.ObjectController.extend({
   actions: {
     findItems: function(){
@@ -149,7 +149,7 @@ Instead of accessing the container directly, Ember provides an API for registeri
 
 There are two ways to access this API. Many Ember applications can access this API directly on the application instance:
 
-```JavaScript
+```javascript
 App = Ember.Application.create();
 
 App.register('logger:main', {
@@ -163,7 +163,7 @@ App.inject('route', 'logger', 'logger:main');
 
 But ember-cli applications (and libraries) will need to use a more flexible hook, an initializer:
 
-```JavaScript
+```javascript
 Ember.Application.initializer({
   name: 'logger',
 
@@ -184,7 +184,7 @@ Initializers can be declared at any time before an application is instantiated,
 
 Any dependency injection is comprised of two parts. The first is the **factory registration**:
 
-```JavaScript
+```javascript
 var logger = {
   log: function(m) {
     console.log(m);
@@ -198,7 +198,7 @@ The `register` function adds the factory (`logger`) into the container. It adds
 
 Often, it is preferable to register a factory that can be instantiated:
 
-```JavaScript
+```javascript
 var Logger = Ember.Object.extend({
   log: function(m) {
     console.log(m);
@@ -212,13 +212,13 @@ This class will be instantiated before it is used by the container. This gives i
 
 The second part of dependency injection is, you guessed it, the **dependency injection**:
 
-```JavaScript
+```javascript
 application.inject('route', 'logger', 'logger:main');
 ```
 
 This is an example of a *type injection*. Onto all factories of the type `route` the property, `logger` will be injected with the factory named `logger:main`. Routes in this example application can now access the logger:
 
-```JavaScript
+```javascript
 App = Ember.Application.extend();
 
 App.Logger = Ember.Object.extend({
@@ -248,7 +248,7 @@ App.create();
 
 Injections can also be made on a specific factory by using its full name:
 
-```JavaScript
+```javascript
 application.inject('route:index', 'logger', 'logger:main');
 ```
 
@@ -257,7 +257,7 @@ Injections can be made onto all of Ember's major framework classes, including vi
 **Note:** For injections into models (if not using ember-cli), you need to enable the `MODEL_FACTORY_INJECTIONS` 
 flag before you initialize your application. You can do this like so:
 
-```JavaScript
+```javascript
 Ember.MODEL_FACTORY_INJECTIONS = true;
 
 var App = Ember.Application.create({

guides/v1.10.0/understanding-ember/the-view-layer.md

@@ -336,7 +336,7 @@ And here's the Handlebars template that uses them:
 If you clicked on the `<h1>`, you'd see the following output in your
 browser's console:
 
-```shell
+```bash
 Child!
 Parent!
 ```