Fixing the order of headings because the old way is seriously dumb.

taylorotwell · taylorotwell · commit 958f0ba8c8a5 · 2014-04-18T00:00:20.000-05:00
diff --git a/eloquent.md b/eloquent.md
@@ -86,10 +86,10 @@ To register the error handler, listen for the `ModelNotFoundException`
 		var_dump($user->name);
 	}
 
-Of course, you may also use the query builder aggregate functions.
-
 #### Eloquent Aggregates
 
+Of course, you may also use the query builder aggregate functions.
+
 	$count = User::where('votes', '>', 100)->count();
 
 If you are unable to generate the query you need via the fluent interface, feel free to use `whereRaw`:
@@ -123,10 +123,10 @@ When creating a new model, you pass an array of attributes to the model construc
 
 To get started, set the `fillable` or `guarded` properties on your model.
 
-The `fillable` property specifies which attributes should be mass-assignable. This can be set at the class or instance level.
-
 #### Defining Fillable Attributes On A Model
 
+The `fillable` property specifies which attributes should be mass-assignable. This can be set at the class or instance level.
+
 	class User extends Eloquent {
 
 		protected $fillable = array('first_name', 'last_name', 'email');
@@ -135,20 +135,20 @@ The `fillable` property specifies which attributes should be mass-assignable. Th
 
 In this example, only the three listed attributes will be mass-assignable.
 
-The inverse of `fillable` is `guarded`, and serves as a "black-list" instead of a "white-list":
-
 #### Defining Guarded Attributes On A Model
 
+The inverse of `fillable` is `guarded`, and serves as a "black-list" instead of a "white-list":
+
 	class User extends Eloquent {
 
 		protected $guarded = array('id', 'password');
 
 	}
 
-In the example above, the `id` and `password` attributes may **not** be mass assigned. All other attributes will be mass assignable. You may also block **all** attributes from mass assignment using the guard property:
-
 #### Blocking All Attributes From Mass Assignment
 
+In the example above, the `id` and `password` attributes may **not** be mass assigned. All other attributes will be mass assignable. You may also block **all** attributes from mass assignment using the guard property:
+
 	protected $guarded = array('*');
 
 <a name="insert-update-delete"></a>
@@ -191,20 +191,20 @@ After saving or creating a new model that uses auto-incrementing IDs, you may re
 	// Retrieve the user by the attributes, or instantiate a new instance...
 	$user = User::firstOrNew(array('name' => 'John'));
 
-To update a model, you may retrieve it, change an attribute, and use the `save` method:
-
 #### Updating A Retrieved Model
 
+To update a model, you may retrieve it, change an attribute, and use the `save` method:
+
 	$user = User::find(1);
 
 	$user->email = 'john@foo.com';
 
 	$user->save();
 
-Sometimes you may wish to save not only a model, but also all of its relationships. To do so, you may use the `push` method:
-
 #### Saving A Model And Relationships
 
+Sometimes you may wish to save not only a model, but also all of its relationships. To do so, you may use the `push` method:
+
 	$user->push();
 
 You may also run updates as queries against a set of models:
@@ -254,10 +254,12 @@ To add a `deleted_at` column to your table, you may use the `softDeletes` method
 
 	$table->softDeletes();
 
-Now, when you call the `delete` method on the model, the `deleted_at` column will be set to the current timestamp. When querying a model that uses soft deletes, the "deleted" models will not be included in query results. To force soft deleted models to appear in a result set, use the `withTrashed` method on the query:
+Now, when you call the `delete` method on the model, the `deleted_at` column will be set to the current timestamp. When querying a model that uses soft deletes, the "deleted" models will not be included in query results.
 
 #### Forcing Soft Deleted Models Into Results
 
+To force soft deleted models to appear in a result set, use the `withTrashed` method on the query:
+
 	$users = User::withTrashed()->where('account_id', 1)->get();
 
 The `withTrashed` method may be used on a defined relationship:
@@ -310,10 +312,10 @@ By default, Eloquent will maintain the `created_at` and `updated_at` columns on
 
 	}
 
-If you wish to customize the format of your timestamps, you may override the `getDateFormat` method in your model:
-
 #### Providing A Custom Timestamp Format
 
+If you wish to customize the format of your timestamps, you may override the `getDateFormat` method in your model:
+
 	class User extends Eloquent {
 
 		protected function getDateFormat()
@@ -326,10 +328,10 @@ If you wish to customize the format of your timestamps, you may override the `ge
 <a name="query-scopes"></a>
 ## Query Scopes
 
-Scopes allow you to easily re-use query logic in your models. To define a scope, simply prefix a model method with `scope`:
-
 #### Defining A Query Scope
 
+Scopes allow you to easily re-use query logic in your models. To define a scope, simply prefix a model method with `scope`:
+
 	class User extends Eloquent {
 
 		public function scopePopular($query)
@@ -380,10 +382,10 @@ Of course, your database tables are probably related to one another. For example
 <a name="one-to-one"></a>
 ### One To One
 
-A one-to-one relationship is a very basic relation. For example, a `User` model might have one `Phone`. We can define this relation in Eloquent:
-
 #### Defining A One To One Relation
 
+A one-to-one relationship is a very basic relation. For example, a `User` model might have one `Phone`. We can define this relation in Eloquent:
+
 	class User extends Eloquent {
 
 		public function phone()
@@ -472,10 +474,10 @@ Again, you may override the conventional foreign key by passing a second argumen
 
 	return $this->hasMany('Comment', 'foreign_key', 'local_key');
 
-To define the inverse of the relationship on the `Comment` model, we use the `belongsTo` method:
-
 #### Defining The Inverse Of A Relation
 
+To define the inverse of the relationship on the `Comment` model, we use the `belongsTo` method:
+
 	class Comment extends Eloquent {
 
 		public function post()
@@ -597,10 +599,10 @@ Polymorphic relations allow a model to belong to more than one other model, on a
 
 	}
 
-Now, we can retrieve the photos for either a staff member or an order:
-
 #### Retrieving A Polymorphic Relation
 
+Now, we can retrieve the photos for either a staff member or an order:
+
 	$staff = Staff::find(1);
 
 	foreach ($staff->photos as $photo)
@@ -618,10 +620,10 @@ However, the true "polymorphic" magic is when you access the staff or order from
 
 The `imageable` relation on the `Photo` model will return either a `Staff` or `Order` instance, depending on which type of model owns the photo.
 
-To help understand how this works, let's explore the database structure for a polymorphic relation:
-
 #### Polymorphic Relation Table Structure
 
+To help understand how this works, let's explore the database structure for a polymorphic relation:
+
 	staff
 		id - integer
 		name - string
@@ -641,10 +643,10 @@ The key fields to notice here are the `imageable_id` and `imageable_type` on the
 <a name="many-to-many-polymorphic-relations"></a>
 ### Many To Many Polymorphic Relations
 
-In addition to traditional polymorphic relations, you may also specify many-to-many polymorphic relations. For example, a blog `Post` and `Video` model could share a polymorphic relation to a `Tag` model. First, let's examine the table structure:
-
 #### Polymorphic Many To Many Relation Table Structure
 
+In addition to traditional polymorphic relations, you may also specify many-to-many polymorphic relations. For example, a blog `Post` and `Video` model could share a polymorphic relation to a `Tag` model. First, let's examine the table structure:
+
 	posts
 		id - integer
 		name - string
@@ -692,10 +694,10 @@ The `Tag` model may define a method for each of its relationships:
 <a name="querying-relations"></a>
 ## Querying Relations
 
-When accessing the records for a model, you may wish to limit your results based on the existence of a relationship. For example, you wish to pull all blog posts that have at least one comment. To do so, you may use the `has` method:
-
 #### Querying Relations When Selecting
 
+When accessing the records for a model, you may wish to limit your results based on the existence of a relationship. For example, you wish to pull all blog posts that have at least one comment. To do so, you may use the `has` method:
+
 	$posts = Post::has('comments')->get();
 
 You may also specify an operator and a count:
@@ -815,10 +817,10 @@ It is also possible to eagerly load related models directly from an already exis
 <a name="inserting-related-models"></a>
 ## Inserting Related Models
 
-You will often need to insert new related models. For example, you may wish to insert a new comment for a post. Instead of manually setting the `post_id` foreign key on the model, you may insert the new comment from its parent `Post` model directly:
-
 #### Attaching A Related Model
 
+You will often need to insert new related models. For example, you may wish to insert a new comment for a post. Instead of manually setting the `post_id` foreign key on the model, you may insert the new comment from its parent `Post` model directly:
+
 	$comment = new Comment(array('message' => 'A new comment.'));
 
 	$post = Post::find(1);
@@ -855,16 +857,16 @@ Of course, the opposite of `attach` is `detach`:
 
 	$user->roles()->detach(1);
 
-You may also use the `sync` method to attach related models. The `sync` method accepts an array of IDs to place on the pivot table. After this operation is complete, only the IDs in the array will be on the intermediate table for the model:
-
 #### Using Sync To Attach Many To Many Models
 
-	$user->roles()->sync(array(1, 2, 3));
+You may also use the `sync` method to attach related models. The `sync` method accepts an array of IDs to place on the pivot table. After this operation is complete, only the IDs in the array will be on the intermediate table for the model:
 
-You may also associate other pivot table values with the given IDs:
+	$user->roles()->sync(array(1, 2, 3));
 
 #### Adding Pivot Data When Syncing
 
+You may also associate other pivot table values with the given IDs:
+
 	$user->roles()->sync(array(1 => array('expires' => true)));
 
 Sometimes you may wish to create a new related model and attach it in a single command. For this operation, you may use the `save` method:
@@ -925,10 +927,10 @@ If you want your pivot table to have automatically maintained `created_at` and `
 
 	return $this->belongsToMany('Role')->withTimestamps();
 
-To delete all records on the pivot table for a model, you may use the `detach` method:
-
 #### Deleting Records On A Pivot Table
 
+To delete all records on the pivot table for a model, you may use the `detach` method:
+
 	User::find(1)->roles()->detach();
 
 Note that this operation does not delete records from the `roles` table, but only from the pivot table.
@@ -947,10 +949,10 @@ Laravel also allows you to define a custom Pivot model. To define a custom model
 
 All multi-result sets returned by Eloquent, either via the `get` method or a `relationship`, will return a collection object. This object implements the `IteratorAggregate` PHP interface so it can be iterated over like an array. However, this object also has a variety of other helpful methods for working with result sets.
 
-For example, we may determine if a result set contains a given primary key using the `contains` method:
-
 #### Checking If A Collection Contains A Key
 
+For example, we may determine if a result set contains a given primary key using the `contains` method:
+
 	$roles = User::find(1)->roles;
 
 	if ($roles->contains(2))
@@ -968,10 +970,10 @@ If a collection is cast to a string, it will be returned as JSON:
 
 	$roles = (string) User::find(1)->roles;
 
-Eloquent collections also contain a few helpful methods for looping and filtering the items they contain:
-
 #### Iterating Collections
 
+Eloquent collections also contain a few helpful methods for looping and filtering the items they contain:
+
 	$roles = $user->roles->each(function($role)
 	{
 		//
@@ -1008,10 +1010,10 @@ When filtering collections, the callback provided will be used as callback for [
 
 	$roles = $roles->sortBy('created_at');
 
-Sometimes, you may wish to return a custom Collection object with your own added methods. You may specify this on your Eloquent model by overriding the `newCollection` method:
-
 #### Returning A Custom Collection Type
 
+Sometimes, you may wish to return a custom Collection object with your own added methods. You may specify this on your Eloquent model by overriding the `newCollection` method:
+
 	class User extends Eloquent {
 
 		public function newCollection(array $models = array())
@@ -1024,10 +1026,10 @@ Sometimes, you may wish to return a custom Collection object with your own added
 <a name="accessors-and-mutators"></a>
 ## Accessors & Mutators
 
-Eloquent provides a convenient way to transform your model attributes when getting or setting them. Simply define a `getFooAttribute` method on your model to declare an accessor. Keep in mind that the methods should follow camel-casing, even though your database columns are snake-case:
-
 #### Defining An Accessor
 
+Eloquent provides a convenient way to transform your model attributes when getting or setting them. Simply define a `getFooAttribute` method on your model to declare an accessor. Keep in mind that the methods should follow camel-casing, even though your database columns are snake-case:
+
 	class User extends Eloquent {
 
 		public function getFirstNameAttribute($value)
@@ -1039,10 +1041,10 @@ Eloquent provides a convenient way to transform your model attributes when getti
 
 In the example above, the `first_name` column has an accessor. Note that the value of the attribute is passed to the accessor.
 
-Mutators are declared in a similar fashion:
-
 #### Defining A Mutator
 
+Mutators are declared in a similar fashion:
+
 	class User extends Eloquent {
 
 		public function setFirstNameAttribute($value)
@@ -1080,19 +1082,19 @@ Eloquent models fire several events, allowing you to hook into various points in
 
 Whenever a new item is saved for the first time, the `creating` and `created` events will fire. If an item is not new and the `save` method is called, the `updating` / `updated` events will fire. In both cases, the `saving` / `saved` events will fire.
 
-If `false` is returned from the `creating`, `updating`, `saving`, or `deleting` events, the action will be cancelled:
-
 #### Cancelling Save Operations Via Events
 
+If `false` is returned from the `creating`, `updating`, `saving`, or `deleting` events, the action will be cancelled:
+
 	User::creating(function($user)
 	{
 		if ( ! $user->isValid()) return false;
 	});
 
-Eloquent models also contain a static `boot` method, which may provide a convenient place to register your event bindings.
-
 #### Setting A Model Boot Method
 
+Eloquent models also contain a static `boot` method, which may provide a convenient place to register your event bindings.
+
 	class User extends Eloquent {
 
 		public static function boot()
@@ -1132,10 +1134,10 @@ You may register an observer instance using the `observe` method:
 <a name="converting-to-arrays-or-json"></a>
 ## Converting To Arrays / JSON
 
-When building JSON APIs, you may often need to convert your models and relationships to arrays or JSON. So, Eloquent includes methods for doing so. To convert a model and its loaded relationship to an array, you may use the `toArray` method:
-
 #### Converting A Model To An Array
 
+When building JSON APIs, you may often need to convert your models and relationships to arrays or JSON. So, Eloquent includes methods for doing so. To convert a model and its loaded relationship to an array, you may use the `toArray` method:
+
 	$user = User::with('roles')->first();
 
 	return $user->toArray();
@@ -1144,25 +1146,25 @@ Note that entire collections of models may also be converted to arrays:
 
 	return User::all()->toArray();
 
-To convert a model to JSON, you may use the `toJson` method:
-
 #### Converting A Model To JSON
 
-	return User::find(1)->toJson();
+To convert a model to JSON, you may use the `toJson` method:
 
-Note that when a model or collection is cast to a string, it will be converted to JSON, meaning you can return Eloquent objects directly from your application's routes!
+	return User::find(1)->toJson();
 
 #### Returning A Model From A Route
 
+Note that when a model or collection is cast to a string, it will be converted to JSON, meaning you can return Eloquent objects directly from your application's routes!
+
 	Route::get('users', function()
 	{
 		return User::all();
 	});
 
-Sometimes you may wish to limit the attributes that are included in your model's array or JSON form, such as passwords. To do so, add a `hidden` property definition to your model:
-
 #### Hiding Attributes From Array Or JSON Conversion
 
+Sometimes you may wish to limit the attributes that are included in your model's array or JSON form, such as passwords. To do so, add a `hidden` property definition to your model:
+
 	class User extends Eloquent {
 
 		protected $hidden = array('password');
