Doc fixes. Really, markdown? Really?

README.markdown

@@ -55,7 +55,7 @@ Well, say you need to make a call that is asynchronous - an AJAX API, or some ot
 
 Jasmine allows you to do this with `runs()` and `waits()` blocks.
 
-    `runs()` blocks by themselves simply run as if they were called directly. The following snippets of code should provide similar results:
+`runs()` blocks by themselves simply run as if they were called directly. The following snippets of code should provide similar results:
 
 
     it('should be a test', function () {
@@ -65,7 +65,7 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
 	    expect(foo).toEqual(1);
     });
 
-    and
+and
 
     it('should be a test', function () {
       runs( function () {
@@ -76,7 +76,7 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
       });
     });
 
-    multiple `runs()` blocks in a spec will run serially. For example,
+multiple `runs()` blocks in a spec will run serially. For example,
 
     it('should be a test', function () {
       runs( function () {
@@ -93,7 +93,7 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
       });
     });
 
-    `runs()` blocks share functional scope -- `this` properties will be common to all blocks, but simple vars will not!
+`runs()` blocks share functional scope -- `this` properties will be common to all blocks, but simple `vars` will not!
 
      it('should be a test', function () {
       runs( function () {
@@ -115,8 +115,8 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
       });
     });
 
-    `runs()` blocks exist so you can test asynchronous processes. The function `waits()` works with `runs()` to provide a naive
-    timeout before the next block is run. You supply a time to wait before the next `runs()` function is executed.  For example:
+`runs()` blocks exist so you can test asynchronous processes. The function `waits()` works with `runs()` to provide a naive
+timeout before the next block is run. You supply a time to wait before the next `runs()` function is executed.  For example:
 
 	it('should be a test', function () {
 	  runs(function () {
@@ -205,17 +205,29 @@ There is a `Jasmine.Reporters` namespace for you to see how to handle reporting.
 Jasmine has several matchers:
 
 `toEqual` compares objects or primitives and returns true if they are equal
+
 `toNotEqual` compares objects or primitives and returns true if they are not equal
+
 `toMatch` takes a regex or a string and returns true if it matches
+
 `toNotMatch` takes a regex or a string and returns true if it does not match
+
 `toBeDefined` returns true if the object or primitive is not `undefined`
+
 `toBeNull` returns true if the object or primitive is not `null`
+
 `toBeTruthy` returns true if the object or primitive evaluates to true
+
 `toBeFalsy` returns true if the object or primitive evaluates to false
+
 `wasCalled` returns true if the object is a spy and was called
+
 `wasNotCalled` returns true if the object is a spy and was not called
+
 `wasNotCalledWith` returns true if the object is a spy and was called with the passed arguments
+
 `toContain` returns true if an array or string contains the passed variable.
+
 `toNotContain` returns true if an array or string does not contain the passed variable.
 
 ### Writing new Matchers
@@ -237,7 +249,7 @@ suites may be disabled by calling `xdescribe()` instead of `describe()`
 
 beforeEach takes a function that is run before each spec. For example:
 
-describe('some suite', function () {
+  describe('some suite', function () {
 
     var suiteWideFoo;
     beforeEach(function () {
@@ -247,13 +259,13 @@ describe('some suite', function () {
     it('should equal bar', function () {
       expect(suiteWideFoo).toEqual(1);
     };
-});
+  });
 
 ### afterEach
 
 afterEach takes a function that is run after each spec. For example:
 
-describe('some suite', function () {
+  describe('some suite', function () {
 
     var suiteWideFoo;
     afterEach(function () {
@@ -267,49 +279,55 @@ describe('some suite', function () {
     it('should equal 0 after', function () {
       expect(suiteWideFoo).toEqual(0);
     };
-});
+  });
 
 
 ### Spies
 
 Jasmine integrates 'spies' that permit many spying, mocking, and faking behaviors.
 
-Here is an few examples:
+Here are a few examples:
 
-var Klass = function () {
-}
+  var Klass = function () {
+  }
 
-var Klass.prototype.method = function (arg) {
+  var Klass.prototype.method = function (arg) {
     return arg;
-}
+  }
 
-var Klass.prototype.methodWithCallback = function (callback) {
+  var Klass.prototype.methodWithCallback = function (callback) {
     return callback('foo');
-}
+  }
 
 
 ...
 
-it('should spy on Klass#method') {
+  it('should spy on Klass#method') {
     spyOn(Klass, 'method');
     Klass.method('foo argument');
     expect(Klass.method).wasCalledWith('foo argument');
-}
+  });
 
-it('should spy on Klass#methodWithCallback') {
+  it('should spy on Klass#methodWithCallback') {
     var callback = Jasmine.createSpy();
     Klass.method(callback);
     expect(callback).wasCalledWith('foo');
-}
+  });
 
 Many other options are available for spies:
 
 `andCallThrough()`: spies on AND calls the original function spied on
+
 `andReturn()`: returns passed arguments when spy is called
+
 `andThrow()`: throws passed exception when spy is called
+
 `andCallFake()`: calls passed function when spy is called
+
 `callCount`: returns number of times spy was called
+
 `mostRecentCall.args`: returns argument array from last call to spy.
+
 `argsForCall[i]` returns arguments array for call `i` to spy.
 
 Spies are automatically removed after each spec. They may be set in the beforeEach function.