enmi-conf.org: comparison wp/wp-admin/js/revisions.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-admin/js/revisions.js

changeset 5	5e2f62d02dcd
parent 0	d970ebf37754
child 7	cf61fcea0001

equal deleted inserted replaced

-:346c88efed21
+:5e2f62d02dcd
+/* global isRtl */
+/**
+* @file Revisions interface functions, Backbone classes and
+* the revisions.php document.ready bootstrap.
+*
+*/
 window.wp = window.wp || {};
 (function($) {
 	var revisions;
+	/**
+	 * Expose the module in window.wp.revisions.
+	 */
 	revisions = wp.revisions = { model: {}, view: {}, controller: {} };
-	// Link settings.
+	// Link post revisions data served from the back-end.
-	revisions.settings = _.isUndefined( _wpRevisionsSettings ) ? {} : _wpRevisionsSettings;
+	revisions.settings = window._wpRevisionsSettings || {};
 	// For debugging
 	revisions.debug = false;
+	/**
+	 * wp.revisions.log
+	 *
+	 * A debugging utility for revisions. Works only when a
+	 * debug flag is on and the browser supports it.
+	 */
 	revisions.log = function() {
-		if ( window.console && revisions.debug )
+		if ( window.console && revisions.debug ) {
-			console.log.apply( console, arguments );
+			window.console.log.apply( window.console, arguments );
+		}
 	};
 	// Handy functions to help with positioning
 	$.fn.allOffsets = function() {
 		var offset = this.offset() || {top: 0, left: 0}, win = $(window);
 		return _.extend( position, {
 			right:  parent.outerWidth()  - position.left - this.outerWidth(),
 			bottom: parent.outerHeight() - position.top  - this.outerHeight()
 		});
 	};
-	// wp_localize_script transforms top-level numbers into strings. Undo that.
-	if ( revisions.settings.to )
-		revisions.settings.to = parseInt( revisions.settings.to, 10 );
-	if ( revisions.settings.from )
-		revisions.settings.from = parseInt( revisions.settings.from, 10 );
-	// wp_localize_script does not allow for top-level booleans. Fix that.
-	if ( revisions.settings.compareTwoMode )
-		revisions.settings.compareTwoMode = revisions.settings.compareTwoMode === '1';
 	/**
 	 * ========================================================================
 	 * MODELS
 	 * ========================================================================
 			// Listen for changes to the revisions or mode from outside
 			this.listenTo( this.frame, 'update:revisions', this.receiveRevisions );
 			this.listenTo( this.frame, 'change:compareTwoMode', this.updateMode );
 			// Listen for internal changes
-			this.listenTo( this, 'change:from', this.handleLocalChanges );
+			this.on( 'change:from', this.handleLocalChanges );
-			this.listenTo( this, 'change:to', this.handleLocalChanges );
+			this.on( 'change:to', this.handleLocalChanges );
-			this.listenTo( this, 'change:compareTwoMode', this.updateSliderSettings );
+			this.on( 'change:compareTwoMode', this.updateSliderSettings );
-			this.listenTo( this, 'update:revisions', this.updateSliderSettings );
+			this.on( 'update:revisions', this.updateSliderSettings );
 			// Listen for changes to the hovered revision
-			this.listenTo( this, 'change:hoveredRevision', this.hoverRevision );
+			this.on( 'change:hoveredRevision', this.hoverRevision );
 			this.set({
 				max:   this.revisions.length - 1,
 				compareTwoMode: this.frame.get('compareTwoMode'),
 				from: this.frame.get('from'),
 		},
 		// Receives revisions changes from outside the model
 		receiveRevisions: function( from, to ) {
 			// Bail if nothing changed
-			if ( this.get('from') === from && this.get('to') === to )
+			if ( this.get('from') === from && this.get('to') === to ) {
 				return;
+			}
 			this.set({ from: from, to: to }, { silent: true });
 			this.trigger( 'update:revisions', from, to );
 		}
 		}
 	});
 	revisions.model.Revision = Backbone.Model.extend({});
+	/**
+	 * wp.revisions.model.Revisions
+	 *
+	 * A collection of post revisions.
+	 */
 	revisions.model.Revisions = Backbone.Collection.extend({
 		model: revisions.model.Revision,
 		initialize: function() {
 			_.bindAll( this, 'next', 'prev' );
 		},
 		next: function( revision ) {
 			var index = this.indexOf( revision );
-			if ( index !== -1 && index !== this.length - 1 )
+			if ( index !== -1 && index !== this.length - 1 ) {
 				return this.at( index + 1 );
+			}
 		},
 		prev: function( revision ) {
 			var index = this.indexOf( revision );
-			if ( index !== -1 && index !== 0 )
+			if ( index !== -1 && index !== 0 ) {
 				return this.at( index - 1 );
+			}
 		}
 	});
 	revisions.model.Field = Backbone.Model.extend({});
 	revisions.model.Fields = Backbone.Collection.extend({
 		model: revisions.model.Field
 	});
 	revisions.model.Diff = Backbone.Model.extend({
-		initialize: function( attributes, options ) {
+		initialize: function() {
 			var fields = this.get('fields');
 			this.unset('fields');
 			this.fields = new revisions.model.Fields( fields );
 		}
 	revisions.model.Diffs = Backbone.Collection.extend({
 		initialize: function( models, options ) {
 			_.bindAll( this, 'getClosestUnloaded' );
 			this.loadAll = _.once( this._loadAll );
 			this.revisions = options.revisions;
+			this.postId = options.postId;
 			this.requests  = {};
 		},
 		model: revisions.model.Diff,
 		ensure: function( id, context ) {
-			var diff     = this.get( id );
+			var diff     = this.get( id ),
-			var request  = this.requests[ id ];
+				request  = this.requests[ id ],
-			var deferred = $.Deferred();
+				deferred = $.Deferred(),
-			var ids      = {};
+				ids      = {},
-			var from     = id.split(':')[0];
+				from     = id.split(':')[0],
-			var to       = id.split(':')[1];
+				to       = id.split(':')[1];
 			ids[id] = true;
 			wp.revisions.log( 'ensure', id );
 			this.trigger( 'ensure', ids, from, to, deferred.promise() );
 				deferred.resolveWith( context, [ diff ] );
 			} else {
 				this.trigger( 'ensure:load', ids, from, to, deferred.promise() );
 				_.each( ids, _.bind( function( id ) {
 					// Remove anything that has an ongoing request
-					if ( this.requests[ id ] )
+					if ( this.requests[ id ] ) {
 						delete ids[ id ];
+					}
 					// Remove anything we already have
-					if ( this.get( id ) )
+					if ( this.get( id ) ) {
 						delete ids[ id ];
+					}
 				}, this ) );
 				if ( ! request ) {
 					// Always include the ID that started this ensure
 					ids[ id ] = true;
 					request   = this.load( _.keys( ids ) );
 				return _.isUndefined( self.get( diffId ) ) && ! self.requests[ diffId ];
 			}).value();
 		},
 		_loadAll: function( allRevisionIds, centerId, num ) {
-			var self = this, deferred = $.Deferred();
+			var self = this, deferred = $.Deferred(),
-			diffs = _.first( this.getClosestUnloaded( allRevisionIds, centerId ), num );
+				diffs = _.first( this.getClosestUnloaded( allRevisionIds, centerId ), num );
 			if ( _.size( diffs ) > 0 ) {
 				this.load( diffs ).done( function() {
 					self._loadAll( allRevisionIds, centerId, num ).done( function() {
 						deferred.resolve();
 					});
 		},
 		load: function( comparisons ) {
 			wp.revisions.log( 'load', comparisons );
 			// Our collection should only ever grow, never shrink, so remove: false
-			return this.fetch({ data: { compare: comparisons }, remove: false }).done( function(){
+			return this.fetch({ data: { compare: comparisons }, remove: false }).done( function() {
 				wp.revisions.log( 'load:complete', comparisons );
 			});
 		},
 		sync: function( method, model, options ) {
 			if ( 'read' === method ) {
 				options = options || {};
 				options.context = this;
 				options.data = _.extend( options.data || {}, {
 					action: 'get-revision-diffs',
-					post_id: revisions.settings.postId
+					post_id: this.postId
 				});
-				var deferred = wp.ajax.send( options );
+				var deferred = wp.ajax.send( options ),
-				var requests = this.requests;
+					requests = this.requests;
 				// Record that we're requesting each diff.
 				if ( options.data.compare ) {
 					_.each( options.data.compare, function( id ) {
 						requests[ id ] = deferred;
 			}
 		}
 	});
+	/**
+	 * wp.revisions.model.FrameState
+	 *
+	 * The frame state.
+	 *
+	 * @see wp.revisions.view.Frame
+	 *
+	 * @param {object}                    attributes        Model attributes - none are required.
+	 * @param {object}                    options           Options for the model.
+	 * @param {revisions.model.Revisions} options.revisions A collection of revisions.
+	 */
 	revisions.model.FrameState = Backbone.Model.extend({
 		defaults: {
 			loading: false,
 			error: false,
 			compareTwoMode: false
 		},
 		initialize: function( attributes, options ) {
-			var properties = {};
+			var state = this.get( 'initialDiffState' );
 			_.bindAll( this, 'receiveDiff' );
 			this._debouncedEnsureDiff = _.debounce( this._ensureDiff, 200 );
 			this.revisions = options.revisions;
-			this.diffs = new revisions.model.Diffs( [], { revisions: this.revisions });
+			this.diffs = new revisions.model.Diffs( [], {
-			// Set the initial diffs collection provided through the settings
+				revisions: this.revisions,
-			this.diffs.set( revisions.settings.diffData );
+				postId: this.get( 'postId' )
+			} );
+			// Set the initial diffs collection.
+			this.diffs.set( this.get( 'diffData' ) );
 			// Set up internal listeners
 			this.listenTo( this, 'change:from', this.changeRevisionHandler );
 			this.listenTo( this, 'change:to', this.changeRevisionHandler );
 			this.listenTo( this, 'change:compareTwoMode', this.changeMode );
 			this.listenTo( this, 'update:revisions', this.updatedRevisions );
 			this.listenTo( this.diffs, 'ensure:load', this.updateLoadingStatus );
 			this.listenTo( this, 'update:diff', this.updateLoadingStatus );
-			// Set the initial revisions, baseUrl, and mode as provided through settings
+			// Set the initial revisions, baseUrl, and mode as provided through attributes.
-			properties.to = this.revisions.get( revisions.settings.to );
-			properties.from = this.revisions.get( revisions.settings.from );
+			this.set( {
-			properties.compareTwoMode = revisions.settings.compareTwoMode;
+				to : this.revisions.get( state.to ),
-			properties.baseUrl = revisions.settings.baseUrl;
+				from : this.revisions.get( state.from ),
-			this.set( properties );
+				compareTwoMode : state.compareTwoMode
+			} );
 			// Start the router if browser supports History API
 			if ( window.history && window.history.pushState ) {
 				this.router = new revisions.Router({ model: this });
 				Backbone.history.start({ pushState: true });
 			this.set( 'error', false );
 			this.set( 'loading', ! this.diff() );
 		},
 		changeMode: function( model, value ) {
-			// If we were on the first revision before switching, we have to bump them over one
+			var toIndex = this.revisions.indexOf( this.get( 'to' ) );
-			if ( value && 0 === this.revisions.indexOf( this.get('to') ) ) {
+			// If we were on the first revision before switching to two-handled mode,
+			// bump the 'to' position over one
+			if ( value && 0 === toIndex ) {
 				this.set({
-					from: this.revisions.at(0),
+					from: this.revisions.at( toIndex ),
-					to: this.revisions.at(1)
+					to:   this.revisions.at( toIndex + 1 )
+				});
+			}
+			// When switching back to single-handled mode, reset 'from' model to
+			// one position before the 'to' model
+			if ( ! value && 0 !== toIndex ) { // '! value' means switching to single-handled mode
+				this.set({
+					from: this.revisions.at( toIndex - 1 ),
+					to:   this.revisions.at( toIndex )
 				});
 			}
 		},
 		updatedRevisions: function( from, to ) {
 			from = this.get('from');
 			to = this.get('to');
 			diffId = ( from ? from.id : 0 ) + ':' + to.id;
 			// Check if we're actually changing the diff id.
-			if ( this._diffId === diffId )
+			if ( this._diffId === diffId ) {
 				return $.Deferred().reject().promise();
+			}
 			this._diffId = diffId;
 			this.trigger( 'update:revisions', from, to );
 			diff = this.diffs.get( diffId );
 			}
 		},
 		// A simple wrapper around `updateDiff` to prevent the change event's
 		// parameters from being passed through.
-		changeRevisionHandler: function( model, value, options ) {
+		changeRevisionHandler: function() {
 			this.updateDiff();
 		},
 		receiveDiff: function( diff ) {
 			// Did we actually get a diff?
 	 * ========================================================================
 	 * VIEWS
 	 * ========================================================================
 	 */
-	// The frame view. This contains the entire page.
+	/**
+	 * wp.revisions.view.Frame
+	 *
+	 * Top level frame that orchestrates the revisions experience.
+	 *
+	 * @param {object}                     options       The options hash for the view.
+	 * @param {revisions.model.FrameState} options.model The frame state model.
+	 */
 	revisions.view.Frame = wp.Backbone.View.extend({
 		className: 'revisions',
 		template: wp.template('revisions-frame'),
 		initialize: function() {
 		updateCompareTwoMode: function() {
 			this.$el.toggleClass( 'comparing-two-revisions', this.model.get('compareTwoMode') );
 		}
 	});
-	// The control view.
+	/**
-	// This contains the revision slider, previous/next buttons, the meta info and the compare checkbox.
+	 * wp.revisions.view.Controls
+	 *
+	 * The controls view.
+	 *
+	 * Contains the revision slider, previous/next buttons, the meta info and the compare checkbox.
+	 */
 	revisions.view.Controls = wp.Backbone.View.extend({
 		className: 'revisions-controls',
 		initialize: function() {
 			_.bindAll( this, 'setWidth' );
 			// Prep the slider model
 			var slider = new revisions.model.Slider({
 				frame: this.model,
 				revisions: this.model.revisions
-			});
+			}),
 			// Prep the tooltip model
-			var tooltip = new revisions.model.Tooltip({
+			tooltip = new revisions.model.Tooltip({
 				frame: this.model,
 				revisions: this.model.revisions,
 				slider: slider
 			});
 		ready: function() {
 			this.top = this.$el.offset().top;
 			this.window = $(window);
 			this.window.on( 'scroll.wp.revisions', {controls: this}, function(e) {
-				var controls = e.data.controls;
+				var controls  = e.data.controls,
-				var container = controls.$el.parent();
+					container = controls.$el.parent(),
-				var scrolled = controls.window.scrollTop();
+					scrolled  = controls.window.scrollTop(),
-				var frame = controls.views.parent;
+					frame     = controls.views.parent;
 				if ( scrolled >= controls.top ) {
 					if ( ! frame.$el.hasClass('pinned') ) {
 						controls.setWidth();
 						container.css('height', container.height() + 'px' );
 		initialize: function() {
 			this.listenTo( this.model, 'change:compareTwoMode', this.updateCompareTwoMode );
 		},
 		ready: function() {
-			if ( this.model.revisions.length < 3 )
+			if ( this.model.revisions.length < 3 ) {
 				$('.revision-toggle-compare-mode').hide();
+			}
 		},
 		updateCompareTwoMode: function() {
 			this.$('.compare-two-revisions').prop( 'checked', this.model.get('compareTwoMode') );
 		},
 		// Toggle the compare two mode feature when the compare two checkbox is checked.
-		compareTwoToggle: function( event ) {
+		compareTwoToggle: function() {
 			// Activate compare two mode?
 			this.model.set({ compareTwoMode: $('.compare-two-revisions').prop('checked') });
 		}
 	});
 	// Encapsulates the tooltip.
 	revisions.view.Tooltip = wp.Backbone.View.extend({
 		className: 'revisions-tooltip',
 		template: wp.template('revisions-meta'),
-		initialize: function( options ) {
+		initialize: function() {
 			this.listenTo( this.model, 'change:offset', this.render );
 			this.listenTo( this.model, 'change:hovering', this.toggleVisibility );
 			this.listenTo( this.model, 'change:scrubbing', this.toggleVisibility );
 		},
 		prepare: function() {
-			if ( _.isNull( this.model.get('revision') ) )
+			if ( _.isNull( this.model.get('revision') ) ) {
 				return;
-			else
+			} else {
 				return _.extend( { type: 'tooltip' }, {
 					attributes: this.model.get('revision').toJSON()
 				});
+			}
 		},
 		render: function() {
-			var direction, directionVal, flipped, css = {}, position = this.model.revisions.indexOf( this.model.get('revision') ) + 1;
+			var otherDirection,
+				direction,
+				directionVal,
+				flipped,
+				css      = {},
+				position = this.model.revisions.indexOf( this.model.get('revision') ) + 1;
 			flipped = ( position / this.model.revisions.length ) > 0.5;
 			if ( isRtl ) {
 				direction = flipped ? 'left' : 'right';
 				directionVal = flipped ? 'leftPlusWidth' : direction;
 			} else {
 		visible: function() {
 			return this.model.get( 'scrubbing' ) || this.model.get( 'hovering' );
 		},
-		toggleVisibility: function( options ) {
+		toggleVisibility: function() {
-			if ( this.visible() )
+			if ( this.visible() ) {
 				this.$el.stop().show().fadeTo( 100 - this.el.style.opacity * 100, 1 );
-			else
+			} else {
 				this.$el.stop().fadeTo( this.el.style.opacity * 300, 0, function(){ $(this).hide(); } );
+			}
 			return;
 		}
 	});
 	// The buttons view.
 		gotoModel: function( toIndex ) {
 			var attributes = {
 				to: this.model.revisions.at( toIndex )
 			};
 			// If we're at the first revision, unset 'from'.
-			if ( toIndex )
+			if ( toIndex ) {
 				attributes.from = this.model.revisions.at( toIndex - 1 );
-			else
+			} else {
 				this.model.unset('from', { silent: true });
+			}
 			this.model.set( attributes );
 		},
 		// Go to the 'next' revision
 			this.gotoModel( toIndex );
 		},
 		// Check to see if the Previous or Next buttons need to be disabled or enabled.
 		disabledButtonCheck: function() {
-			var maxVal = this.model.revisions.length - 1,
+			var maxVal   = this.model.revisions.length - 1,
-				minVal = 0,
+				minVal   = 0,
-				next = $('.revisions-next .button'),
+				next     = $('.revisions-next .button'),
 				previous = $('.revisions-previous .button'),
-				val = this.model.revisions.indexOf( this.model.get('to') );
+				val      = this.model.revisions.indexOf( this.model.get('to') );
 			// Disable "Next" button if you're on the last node.
 			next.prop( 'disabled', ( maxVal === val ) );
 			// Disable "Previous" button if you're on the first node.
 			this.applySliderSettings();
 		},
 		mouseMove: function( e ) {
-			var zoneCount = this.model.revisions.length - 1, // One fewer zone than models
+			var zoneCount         = this.model.revisions.length - 1, // One fewer zone than models
-				sliderFrom = this.$el.allOffsets()[this.direction], // "From" edge of slider
+				sliderFrom        = this.$el.allOffsets()[this.direction], // "From" edge of slider
-				sliderWidth = this.$el.width(), // Width of slider
+				sliderWidth       = this.$el.width(), // Width of slider
-				tickWidth = sliderWidth / zoneCount, // Calculated width of zone
+				tickWidth         = sliderWidth / zoneCount, // Calculated width of zone
-				actualX = isRtl? $(window).width() - e.pageX : e.pageX; // Flipped for RTL - sliderFrom;
+				actualX           = ( isRtl ? $(window).width() - e.pageX : e.pageX ) - sliderFrom, // Flipped for RTL - sliderFrom;
-			actualX = actualX - sliderFrom; // Offset of mouse position in slider
+				currentModelIndex = Math.floor( ( actualX  + ( tickWidth / 2 )  ) / tickWidth ); // Calculate the model index
-			var currentModelIndex = Math.floor( ( actualX + ( tickWidth / 2 )  ) / tickWidth ); // Calculate the model index
 			// Ensure sane value for currentModelIndex.
-			if ( currentModelIndex < 0 )
+			if ( currentModelIndex < 0 ) {
 				currentModelIndex = 0;
-			else if ( currentModelIndex >= this.model.revisions.length )
+			} else if ( currentModelIndex >= this.model.revisions.length ) {
 				currentModelIndex = this.model.revisions.length - 1;
+			}
 			// Update the tooltip mode
 			this.model.set({ hoveredRevision: this.model.revisions.at( currentModelIndex ) });
 		},
 			this.model.set({ scrubbing: true });
 			// Track the mouse position to enable smooth dragging,
 			// overrides default jQuery UI step behavior.
 			$( window ).on( 'mousemove.wp.revisions', { view: this }, function( e ) {
-				var view              = e.data.view,
+				var handles,
-				    leftDragBoundary  = view.$el.offset().left,
+					view              = e.data.view,
-				    sliderOffset      = leftDragBoundary,
+					leftDragBoundary  = view.$el.offset().left,
-				    sliderRightEdge   = leftDragBoundary + view.$el.width(),
+					sliderOffset      = leftDragBoundary,
-				    rightDragBoundary = sliderRightEdge,
+					sliderRightEdge   = leftDragBoundary + view.$el.width(),
-				    leftDragReset     = '0',
+					rightDragBoundary = sliderRightEdge,
-				    rightDragReset    = '100%',
+					leftDragReset     = '0',
-				    handle            = $( ui.handle );
+					rightDragReset    = '100%',
+					handle            = $( ui.handle );
 				// In two handle mode, ensure handles can't be dragged past each other.
 				// Adjust left/right boundaries and reset points.
 				if ( view.model.get('compareTwoMode') ) {
-					var handles = handle.parent().find('.ui-slider-handle');
+					handles = handle.parent().find('.ui-slider-handle');
 					if ( handle.is( handles.first() ) ) { // We're the left handle
 						rightDragBoundary = handles.last().offset().left;
 						rightDragReset    = rightDragBoundary - sliderOffset;
 					} else { // We're the right handle
 						leftDragBoundary = handles.first().offset().left + handles.first().width();
 		slide: function( event, ui ) {
 			var attributes, movedRevision;
 			// Compare two revisions mode
 			if ( this.model.get('compareTwoMode') ) {
 				// Prevent sliders from occupying same spot
-				if ( ui.values[1] === ui.values[0] )
+				if ( ui.values[1] === ui.values[0] ) {
 					return false;
-				if ( isRtl )
+				}
+				if ( isRtl ) {
 					ui.values.reverse();
+				}
 				attributes = {
 					from: this.model.revisions.at( this.getPosition( ui.values[0] ) ),
 					to: this.model.revisions.at( this.getPosition( ui.values[1] ) )
 				};
 			} else {
 				attributes = {
 					to: this.model.revisions.at( this.getPosition( ui.value ) )
 				};
 				// If we're at the first revision, unset 'from'.
-				if ( this.getPosition( ui.value ) > 0 )
+				if ( this.getPosition( ui.value ) > 0 ) {
 					attributes.from = this.model.revisions.at( this.getPosition( ui.value ) - 1 );
-				else
+				} else {
 					attributes.from = undefined;
+				}
 			}
 			movedRevision = this.model.revisions.at( this.getPosition( ui.value ) );
 			// If we are scrubbing, a scrub to a revision is considered a hover
-			if ( this.model.get('scrubbing') )
+			if ( this.model.get('scrubbing') ) {
 				attributes.hoveredRevision = movedRevision;
+			}
 			this.model.set( attributes );
 		},
-		stop: function( event, ui ) {
+		stop: function() {
 			$( window ).off('mousemove.wp.revisions');
 			this.model.updateSliderSettings(); // To snap us back to a tick mark
 			this.model.set({ scrubbing: false });
 		}
 	});
 	// The diff view.
 	// This is the view for the current active diff.
 	revisions.view.Diff = wp.Backbone.View.extend({
 		className: 'revisions-diff',
-		template: wp.template('revisions-diff'),
+		template:  wp.template('revisions-diff'),
 		// Generate the options to be passed to the template.
 		prepare: function() {
 			return _.extend({ fields: this.model.fields.toJSON() }, this.options );
 		}
 	});
-	// The revisions router
+	// The revisions router.
-	// takes URLs with #hash fragments and routes them
+	// Maintains the URL routes so browser URL matches state.
 	revisions.Router = Backbone.Router.extend({
 		initialize: function( options ) {
 			this.model = options.model;
-			this.routes = _.object([
-				[ this.baseUrl( '?from=:from&to=:to' ), 'handleRoute' ],
-				[ this.baseUrl( '?from=:from&to=:to' ), 'handleRoute' ]
-			]);
 			// Maintain state and history when navigating
 			this.listenTo( this.model, 'update:diff', _.debounce( this.updateUrl, 250 ) );
 			this.listenTo( this.model, 'change:compareTwoMode', this.updateUrl );
 		},
 		baseUrl: function( url ) {
 			return this.model.get('baseUrl') + url;
 		},
 		updateUrl: function() {
-			var from = this.model.has('from') ? this.model.get('from').id : 0;
+			var from = this.model.has('from') ? this.model.get('from').id : 0,
-			var to = this.model.get('to').id;
+				to   = this.model.get('to').id;
-			if ( this.model.get('compareTwoMode' ) )
+			if ( this.model.get('compareTwoMode' ) ) {
-				this.navigate( this.baseUrl( '?from=' + from + '&to=' + to ) );
+				this.navigate( this.baseUrl( '?from=' + from + '&to=' + to ), { replace: true } );
-			else
+			} else {
-				this.navigate( this.baseUrl( '?revision=' + to ) );
+				this.navigate( this.baseUrl( '?revision=' + to ), { replace: true } );
+			}
 		},
 		handleRoute: function( a, b ) {
-			var from, to, compareTwo = _.isUndefined( b );
+			var compareTwo = _.isUndefined( b );
 			if ( ! compareTwo ) {
 				b = this.model.revisions.get( a );
 				a = this.model.revisions.prev( b );
 				b = b ? b.id : 0;
 				a = a ? a.id : 0;
 			}
+		}
-			this.model.set({
+	});
-				from: this.model.revisions.get( parseInt( a, 10 ) ),
-				to: this.model.revisions.get( parseInt( a, 10 ) ),
+	/**
-				compareTwoMode: compareTwo
+	 * Initialize the revisions UI for revision.php.
-			});
+	 */
-		}
-	});
-	// Initialize the revisions UI.
 	revisions.init = function() {
+		var state;
+		// Bail if the current page is not revision.php.
+		if ( ! window.adminpage || 'revision-php' !== window.adminpage ) {
+			return;
+		}
+		state = new revisions.model.FrameState({
+			initialDiffState: {
+				// wp_localize_script doesn't stringifies ints, so cast them.
+				to: parseInt( revisions.settings.to, 10 ),
+				from: parseInt( revisions.settings.from, 10 ),
+				// wp_localize_script does not allow for top-level booleans so do a comparator here.
+				compareTwoMode: ( revisions.settings.compareTwoMode === '1' )
+			},
+			diffData: revisions.settings.diffData,
+			baseUrl: revisions.settings.baseUrl,
+			postId: parseInt( revisions.settings.postId, 10 )
+		}, {
+			revisions: new revisions.model.Revisions( revisions.settings.revisionData )
+		});
 		revisions.view.frame = new revisions.view.Frame({
-			model: new revisions.model.FrameState({}, {
+			model: state
-				revisions: new revisions.model.Revisions( revisions.settings.revisionData )
-			})
 		}).render();
 	};
 	$( revisions.init );
 }(jQuery));

enmi-conf.org