EventRangeGroup -> EventInstanceGroup

src.json

@@ -56,8 +56,8 @@
     "models/event/SingleEventDef.js",
     "models/event/RecurringEventDef.js",
     "models/event/EventInstance.js",
+    "models/event/EventInstanceGroup.js",
     "models/event/EventDateProfile.js",
-    "models/event/EventRangeGroup.js",
     "models/event/EventRange.js",
     "models/event/EventFootprint.js",
     "models/event/EventDefMutation.js",

src/Calendar.business.js

@@ -9,13 +9,13 @@ var BUSINESS_HOUR_EVENT_DEFAULTS = {
 
 
 /*
-See note on buildBusinessRangeGroup about return value.
+See note on buildBusinessInstanceGroup about return value.
 */
-Calendar.prototype.buildCurrentBusinessRangeGroup = function(wholeDay) {
+Calendar.prototype.buildCurrentBusinessInstanceGroup = function(wholeDay) {
 	var eventPeriod = this.eventManager.currentPeriod;
 
 	if (eventPeriod) {
-		return this.buildBusinessRangeGroup(
+		return this.buildBusinessInstanceGroup(
 			wholeDay,
 			this.opt('businessHours'),
 			eventPeriod.start,
@@ -26,25 +26,23 @@ Calendar.prototype.buildCurrentBusinessRangeGroup = function(wholeDay) {
 
 
 /*
-If there are business hours, and they are within range, returns populated EventRangeGroup.
-If there are business hours, but they aren't within range, returns a zero-item EventRangeGroup.
+If there are business hours, and they are within range, returns populated EventInstanceGroup.
+If there are business hours, but they aren't within range, returns a zero-item EventInstanceGroup.
 If there are NOT business hours, returns undefined.
 */
-Calendar.prototype.buildBusinessRangeGroup = function(wholeDay, rawComplexDef, rangeStart, rangeEnd) {
+Calendar.prototype.buildBusinessInstanceGroup = function(wholeDay, rawComplexDef, rangeStart, rangeEnd) {
 	var eventDefs = this.buildBusinessDefs(wholeDay, rawComplexDef);
 	var eventInstances;
-	var eventRanges;
-	var eventRangeGroup;
+	var eventInstanceGroup;
 
 	if (eventDefs.length) {
 		eventInstances = eventDefsToEventInstances(eventDefs, rangeStart, rangeEnd);
-		eventRanges = eventInstancesToEventRanges(eventInstances);
-		eventRangeGroup = new EventRangeGroup(eventRanges);
+		eventInstanceGroup = new EventInstanceGroup(eventInstances);
 
 		// so that inverse-background rendering can happen even when no eventRanges in view
-		eventRangeGroup.explicitEventDef = eventDefs[0];
+		eventInstanceGroup.explicitEventDef = eventDefs[0];
 
-		return eventRangeGroup;
+		return eventInstanceGroup;
 	}
 };
 

src/Calendar.constraints.js

@@ -1,10 +1,11 @@
 
-Calendar.prototype.isEventRangeGroupAllowed = function(eventRangeGroup) {
-	var eventDef = eventRangeGroup.getEventDef();
-	var eventFootprints = this.eventRangesToEventFootprints(eventRangeGroup.eventRanges);
+Calendar.prototype.isEventInstanceGroupAllowed = function(eventInstanceGroup) {
+	var eventDef = eventInstanceGroup.getEventDef();
+	var eventFootprints = this.eventRangesToEventFootprints(eventInstanceGroup.getAllEventRanges());
 	var i;
 
-	var peerEventRanges = this.eventManager.getEventRangesWithoutId(eventDef.id);
+	var peerEventInstances = this.eventManager.getEventInstancesWithoutId(eventDef.id);
+	var peerEventRanges = eventInstancesToEventRanges(peerEventInstances);
 	var peerEventFootprints = this.eventRangesToEventFootprints(peerEventRanges);
 
 	var constraintVal = eventDef.getConstraint();
@@ -44,7 +45,8 @@ Calendar.prototype.isEventRangeGroupAllowed = function(eventRangeGroup) {
 
 
 Calendar.prototype.isSelectionFootprintAllowed = function(componentFootprint) {
-	var peerEventRanges = this.eventManager.getEventRanges();
+	var peerEventInstances = this.eventManager.getEventInstances();
+	var peerEventRanges = eventInstancesToEventRanges(peerEventInstances);
 	var peerEventFootprints = this.eventRangesToEventFootprints(peerEventRanges);
 
 	var selectAllowFunc;
@@ -130,20 +132,23 @@ Calendar.prototype.isFootprintWithinConstraints = function(componentFootprint, c
 
 
 Calendar.prototype.constraintValToFootprints = function(constraintVal, isAllDay) {
-	var eventRangeGroup;
+	var eventInstanceGroup;
 	var eventRanges = [];
 
 	if (constraintVal === 'businessHours') {
-		eventRangeGroup = this.buildCurrentBusinessRangeGroup(isAllDay);
-		if (eventRangeGroup) {
-			eventRanges = eventRangeGroup.eventRanges;
+		eventInstanceGroup = this.buildCurrentBusinessInstanceGroup(isAllDay);
+
+		if (eventInstanceGroup) {
+			eventRanges = eventInstanceGroup.getAllEventRanges();
 		}
 	}
 	else if (typeof constraintVal === 'object') {
 		eventRanges = this.parseEventDefToEventRanges(constraintVal);
 	}
 	else if (constraintVal != null) { // an ID
-		eventRanges = this.eventManager.getEventRangesWithId(constraintVal);
+		eventRanges = eventInstancesToEventRanges(
+			this.eventManager.getEventInstancesWithId(constraintVal)
+		);
 	}
 
 	return eventFootprintsToComponentFootprints(

src/Calendar.js

@@ -290,8 +290,8 @@ var Calendar = FC.Calendar = Class.extend(EmitterMixin, {
 			rawSources.unshift(singleRawSource);
 		}
 
-		eventManager.on('release', function(eventRangeGroups) {
-			_this.trigger('eventsReset', eventRangeGroups);
+		eventManager.on('release', function(eventsPayload) {
+			_this.trigger('eventsReset', eventsPayload);
 		});
 
 		eventManager.freeze();

src/agenda/AgendaView.js

@@ -302,17 +302,17 @@ var AgendaView = FC.AgendaView = View.extend({
 		var timedEventsPayload = {};
 		var daySegs = [];
 		var timedSegs;
-		var id, eventRangeGroup;
+		var id, eventInstanceGroup;
 
 		// separate the events into all-day and timed
 		for (id in eventsPayload) {
-			eventRangeGroup = eventsPayload[id];
+			eventInstanceGroup = eventsPayload[id];
 
-			if (eventRangeGroup.getEventDef().isAllDay()) {
-				dayEventsPayload[id] = eventRangeGroup;
+			if (eventInstanceGroup.getEventDef().isAllDay()) {
+				dayEventsPayload[id] = eventInstanceGroup;
 			}
 			else {
-				timedEventsPayload[id] = eventRangeGroup;
+				timedEventsPayload[id] = eventInstanceGroup;
 			}
 		}
 

src/common/Grid.events.js

@@ -17,7 +17,7 @@ Grid.mixin({
 
 	renderEventsPayload: function(eventsPayload) {
 		var unzonedRange = new UnzonedRange(this.view.activeRange.start, this.view.activeRange.end);
-		var id, eventRangeGroup;
+		var id, eventInstanceGroup;
 		var eventRenderRanges;
 		var eventFootprints;
 		var eventSegs;
@@ -25,13 +25,13 @@ Grid.mixin({
 		var fgSegs = [];
 
 		for (id in eventsPayload) {
-			eventRangeGroup = eventsPayload[id];
+			eventInstanceGroup = eventsPayload[id];
 
-			eventRenderRanges = eventRangeGroup.sliceRenderRanges(unzonedRange);
+			eventRenderRanges = eventInstanceGroup.sliceRenderRanges(unzonedRange);
 			eventFootprints = this.eventRangesToEventFootprints(eventRenderRanges);
 			eventSegs = this.eventFootprintsToSegs(eventFootprints);
 
-			if (eventRangeGroup.getEventDef().hasBgRendering()) {
+			if (eventInstanceGroup.getEventDef().hasBgRendering()) {
 				bgSegs.push.apply(bgSegs, // append
 					eventSegs
 				);
@@ -142,7 +142,7 @@ Grid.mixin({
 	// FOR RENDERING
 	buildBusinessHourRanges: function(wholeDay, businessHours) {
 		var calendar = this.view.calendar;
-		var eventRangeGroup;
+		var eventInstanceGroup;
 
 		if (businessHours == null) {
 			// fallback
@@ -150,15 +150,15 @@ Grid.mixin({
 			businessHours = calendar.opt('businessHours');
 		}
 
-		eventRangeGroup = calendar.buildBusinessRangeGroup(
+		eventInstanceGroup = calendar.buildBusinessInstanceGroup(
 			wholeDay,
 			businessHours,
 			this.start,
 			this.end
 		);
 
-		if (eventRangeGroup) {
-			return eventRangeGroup.sliceRenderRanges(
+		if (eventInstanceGroup) {
+			return eventInstanceGroup.sliceRenderRanges(
 				new UnzonedRange(this.start, this.end),
 				calendar
 			);
@@ -357,7 +357,7 @@ Grid.mixin({
 				var isAllowed = true;
 				var origFootprint;
 				var footprint;
-				var mutatedEventRangeGroup;
+				var mutatedEventInstanceGroup;
 				var dragHelperEls;
 
 				// starting hit could be forced (DayGrid.limit)
@@ -373,15 +373,13 @@ Grid.mixin({
 					eventDefMutation = _this.computeEventDropMutation(origFootprint, footprint);
 
 					if (eventDefMutation) {
-						mutatedEventRangeGroup = new EventRangeGroup(
-							eventInstancesToEventRanges(
-								eventManager.buildMutatedEventInstances(
-									eventManager.getEventDefByUid(event._id).id,
-									eventDefMutation
-								)
+						mutatedEventInstanceGroup = new EventInstanceGroup(
+							eventManager.buildMutatedEventInstances( // TODO: buildMutatedEventInstanceGroup?
+								eventManager.getEventDefByUid(event._id).id,
+								eventDefMutation
 							)
 						);
-						isAllowed = _this.isEventRangeGroupAllowed(mutatedEventRangeGroup);
+						isAllowed = _this.isEventInstanceGroupAllowed(mutatedEventInstanceGroup);
 					}
 					else {
 						isAllowed = false;
@@ -400,7 +398,7 @@ Grid.mixin({
 				if (
 					eventDefMutation &&
 					(dragHelperEls = view.renderDrag(
-						mutatedEventRangeGroup.sliceRenderRanges(
+						mutatedEventInstanceGroup.sliceRenderRanges(
 							new UnzonedRange(_this.start, _this.end),
 							calendar
 						),
@@ -586,20 +584,18 @@ Grid.mixin({
 			hitOver: function(hit) {
 				var isAllowed = true;
 				var hitFootprint = hit.component.getSafeHitFootprint(hit); // hit might not belong to this grid
-				var mutatedEventRangeGroup;
+				var mutatedEventInstanceGroup;
 
 				if (hitFootprint) {
 					singleEventDef = _this.computeExternalDrop(hitFootprint, meta);
 
 					if (singleEventDef) {
-						mutatedEventRangeGroup = new EventRangeGroup(
-							eventInstancesToEventRanges(
-								singleEventDef.buildInstances()
-							)
+						mutatedEventInstanceGroup = new EventInstanceGroup(
+							singleEventDef.buildInstances()
 						);
 						isAllowed = meta.eventProps ? // isEvent?
-							_this.isEventRangeGroupAllowed(mutatedEventRangeGroup) :
-							_this.isExternalRangeGroupAllowed(mutatedEventRangeGroup);
+							_this.isEventInstanceGroupAllowed(mutatedEventInstanceGroup) :
+							_this.isExternalInstanceGroupAllowed(mutatedEventInstanceGroup);
 					}
 					else {
 						isAllowed = false;
@@ -616,7 +612,7 @@ Grid.mixin({
 
 				if (singleEventDef) {
 					_this.renderDrag( // called without a seg parameter
-						mutatedEventRangeGroup.sliceRenderRanges(
+						mutatedEventInstanceGroup.sliceRenderRanges(
 							new UnzonedRange(_this.start, _this.end),
 							view.calendar
 						)
@@ -756,7 +752,7 @@ Grid.mixin({
 				var isAllowed = true;
 				var origHitFootprint = _this.getSafeHitFootprint(origHit);
 				var hitFootprint = _this.getSafeHitFootprint(hit);
-				var mutatedEventRangeGroup;
+				var mutatedEventInstanceGroup;
 
 				if (origHitFootprint && hitFootprint) {
 					resizeMutation = isStart ?
@@ -764,15 +760,13 @@ Grid.mixin({
 						_this.computeEventEndResizeMutation(origHitFootprint, hitFootprint, event);
 
 					if (resizeMutation) {
-						mutatedEventRangeGroup = new EventRangeGroup(
-							eventInstancesToEventRanges(
-								eventManager.buildMutatedEventInstances(
-									eventManager.getEventDefByUid(event._id).id,
-									resizeMutation
-								)
+						mutatedEventInstanceGroup = new EventInstanceGroup(
+							eventManager.buildMutatedEventInstances(
+								eventManager.getEventDefByUid(event._id).id,
+								resizeMutation
 							)
 						);
-						isAllowed = _this.isEventRangeGroupAllowed(mutatedEventRangeGroup);
+						isAllowed = _this.isEventInstanceGroupAllowed(mutatedEventInstanceGroup);
 					}
 					else {
 						isAllowed = false;
@@ -795,7 +789,7 @@ Grid.mixin({
 					view.hideEvent(event);
 
 					_this.renderEventResize(
-						mutatedEventRangeGroup.sliceRenderRanges(
+						mutatedEventInstanceGroup.sliceRenderRanges(
 							new UnzonedRange(_this.start, _this.end),
 							calendar
 						),
@@ -1042,8 +1036,8 @@ Grid.mixin({
 	------------------------------------------------------------------------------------------------------------------*/
 
 
-	isEventRangeGroupAllowed: function(eventRangeGroup) {
-		var eventFootprints = this.eventRangesToEventFootprints(eventRangeGroup.eventRanges);
+	isEventInstanceGroupAllowed: function(eventInstanceGroup) {
+		var eventFootprints = this.eventRangesToEventFootprints(eventInstanceGroup.getAllEventRanges());
 		var i;
 
 		for (i = 0; i < eventFootprints.length; i++) {
@@ -1057,14 +1051,14 @@ Grid.mixin({
 			}
 		}
 
-		return this.view.calendar.isEventRangeGroupAllowed(eventRangeGroup);
+		return this.view.calendar.isEventInstanceGroupAllowed(eventInstanceGroup);
 	},
 
 
 	// when it's a completely anonymous external drag, no event.
-	isExternalRangeGroupAllowed: function(eventRangeGroup) {
+	isExternalInstanceGroupAllowed: function(eventInstanceGroup) {
 		var calendar = this.view.calendar;
-		var eventFootprints = this.eventRangesToEventFootprints(eventRangeGroup.eventRanges);
+		var eventFootprints = this.eventRangesToEventFootprints(eventInstanceGroup.getAllEventRanges());
 		var i;
 
 		for (i = 0; i < eventFootprints.length; i++) {

src/common/View.js

@@ -725,7 +725,7 @@ var View = FC.View = ChronoComponent.extend({
 		);
 
 		this.triggerEventDrop(
-			eventManager.getEventInstancesById(eventDef.id)[0].toLegacy(),
+			eventManager.getEventInstancesWithId(eventDef.id)[0].toLegacy(),
 			eventMutation.dateMutation.dateDelta,
 			undoFunc,
 			el, ev
@@ -788,7 +788,7 @@ var View = FC.View = ChronoComponent.extend({
 		);
 
 		this.triggerEventResize(
-			eventManager.getEventInstancesById(eventDef.id)[0].toLegacy(),
+			eventManager.getEventInstancesWithId(eventDef.id)[0].toLegacy(),
 			eventMutation.dateMutation.endDelta,
 			undoFunc,
 			el, ev
@@ -987,16 +987,16 @@ View.watch('displayingEvents', [ 'displayingDates', 'hasEvents' ], function() {
 function convertEventsPayloadToLegacyArray(eventsPayload) {
 	var legacyEvents = [];
 	var id;
-	var eventRanges;
+	var eventInstances;
 	var i;
 
 	for (id in eventsPayload) {
 
-		eventRanges = eventsPayload[id].eventRanges;
+		eventInstances = eventsPayload[id].eventInstances;
 
-		for (i = 0; i < eventRanges.length; i++) {
+		for (i = 0; i < eventInstances.length; i++) {
 			legacyEvents.push(
-				eventRanges[i].eventInstance.toLegacy()
+				eventInstances[i].toLegacy()
 			);
 		}
 	}

src/models/EventManager.js

@@ -182,8 +182,8 @@ var EventManager = Class.extend(EmitterMixin, ListenerMixin, {
 
 
 	bindPeriod: function(eventPeriod) {
-		this.listenTo(eventPeriod, 'release', function(eventRangeGroups) {
-			this.trigger('release', eventRangeGroups);
+		this.listenTo(eventPeriod, 'release', function(eventsPayload) {
+			this.trigger('release', eventsPayload);
 		});
 	},
 
@@ -318,10 +318,8 @@ var EventManager = Class.extend(EmitterMixin, ListenerMixin, {
 [
 	'getEventDefsById',
 	'getEventInstances',
-	'getEventInstancesById',
-	'getEventRanges',
-	'getEventRangesWithId',
-	'getEventRangesWithoutId'
+	'getEventInstancesWithId',
+	'getEventInstancesWithoutId'
 ].forEach(function(methodName) {
 
 	EventManager.prototype[methodName] = function() {

src/models/EventPeriod.js

@@ -14,8 +14,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 
 	eventDefsByUid: null,
 	eventDefsById: null,
-	eventInstancesById: null,
-	eventRangeGroupsById: null,
+	eventInstanceGroupsById: null,
 
 
 	constructor: function(start, end, timezone) {
@@ -25,8 +24,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 		this.requestsByUid = {};
 		this.eventDefsByUid = {};
 		this.eventDefsById = {};
-		this.eventInstancesById = {};
-		this.eventRangeGroupsById = {};
+		this.eventInstanceGroupsById = {};
 	},
 
 
@@ -179,8 +177,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 
 		this.eventDefsByUid = {};
 		this.eventDefsById = {};
-		this.eventInstancesById = {};
-		this.eventRangeGroupsById = {};
+		this.eventInstanceGroupsById = {};
 
 		if (!isEmpty) {
 			this.tryRelease();
@@ -211,130 +208,71 @@ var EventPeriod = Class.extend(EmitterMixin, {
 
 
 	getEventInstances: function() { // TODO: consider iterator
-		var eventInstancesById = this.eventInstancesById;
-		var allInstances = [];
+		var eventInstanceGroupsById = this.eventInstanceGroupsById;
+		var eventInstances = [];
 		var id;
 
-		for (id in eventInstancesById) {
-			allInstances.push.apply(allInstances, // append
-				eventInstancesById[id]
+		for (id in eventInstanceGroupsById) {
+			eventInstances.push.apply(eventInstances, // append
+				eventInstanceGroupsById[id].eventInstances
 			);
 		}
 
-		return allInstances;
+		return eventInstances;
 	},
 
 
-	getEventInstancesById: function(eventDefId) {
-		var eventInstances = this.eventInstancesById[eventDefId];
+	getEventInstancesWithId: function(eventDefId) {
+		var eventInstanceGroup = this.eventInstanceGroupsById[eventDefId];
 
-		if (eventInstances) {
-			return eventInstances.slice(); // clone
+		if (eventInstanceGroup) {
+			return eventInstanceGroup.eventInstances.slice(); // clone
 		}
 
 		return [];
 	},
 
 
-	addEventInstance: function(eventInstance, eventDefId) {
-		var eventInstancesById = this.eventInstancesById;
-		var eventInstances = eventInstancesById[eventDefId] ||
-			(eventInstancesById[eventDefId] = []);
-
-		eventInstances.push(eventInstance);
-
-		this.addEventRange(eventInstance.buildEventRange(), eventDefId);
-	},
-
-
-	removeEventInstancesForDef: function(eventDef) {
-		var eventInstancesById = this.eventInstancesById;
-		var eventInstances = eventInstancesById[eventDef.id];
-
-		if (eventInstances) {
-			removeMatching(eventInstances, function(currentEventInstance) {
-				return currentEventInstance.def === eventDef;
-			});
-
-			if (!eventInstances.length) {
-				delete eventInstancesById[eventDef.id];
-			}
-
-			this.removeEventRangesForDef(eventDef);
-		}
-	},
-
-
-	// Event Ranges
-	// -----------------------------------------------------------------------------------------------------------------
-
-
-	getEventRanges: function() { // TODO: consider iterator
-		var eventRangeGroupsById = this.eventRangeGroupsById;
-		var allRanges = [];
+	getEventInstancesWithoutId: function(eventDefId) { // TODO: consider iterator
+		var eventInstanceGroupsById = this.eventInstanceGroupsById;
+		var matchingInstances = [];
 		var id;
 
-		for (id in eventRangeGroupsById) {
-			allRanges.push.apply(allRanges, // append
-				eventRangeGroupsById[id].eventRanges
-			);
-		}
-
-		return allRanges;
-	},
-
-
-	getEventRangesWithId: function(eventDefId) {
-		var eventRangeGroup = this.eventRangeGroupsById[eventDefId];
-
-		if (eventRangeGroup) {
-			return eventRangeGroup.eventRanges.slice(); // clone
-		}
-
-		return [];
-	},
-
-
-	getEventRangesWithoutId: function(eventDefId) { // TODO: consider iterator
-		var eventRangeGroupsById = this.eventRangeGroupsById;
-		var matchingRanges = [];
-		var id;
-
-		for (id in eventRangeGroupsById) {
+		for (id in eventInstanceGroupsById) {
 			if (id !== eventDefId) {
-				matchingRanges.push.apply(matchingRanges, // append
-					eventRangeGroupsById[id].eventRanges
+				matchingInstances.push.apply(matchingInstances, // append
+					eventInstanceGroupsById[id].eventInstances
 				);
 			}
 		}
 
-		return matchingRanges;
+		return matchingInstances;
 	},
 
 
-	addEventRange: function(eventRange, eventDefId) {
-		var eventRangeGroupsById = this.eventRangeGroupsById;
-		var eventRangeGroup = eventRangeGroupsById[eventDefId] ||
-			(eventRangeGroupsById[eventDefId] = new EventRangeGroup());
+	addEventInstance: function(eventInstance, eventDefId) {
+		var eventInstanceGroupsById = this.eventInstanceGroupsById;
+		var eventInstanceGroup = eventInstanceGroupsById[eventDefId] ||
+			(eventInstanceGroupsById[eventDefId] = new EventInstanceGroup());
 
-		eventRangeGroup.eventRanges.push(eventRange);
+		eventInstanceGroup.eventInstances.push(eventInstance);
 
 		this.tryRelease();
 	},
 
 
-	removeEventRangesForDef: function(eventDef) {
-		var eventRangeGroupsById = this.eventRangeGroupsById;
-		var eventRangeGroup = eventRangeGroupsById[eventDef.id];
+	removeEventInstancesForDef: function(eventDef) {
+		var eventInstanceGroupsById = this.eventInstanceGroupsById;
+		var eventInstanceGroup = eventInstanceGroupsById[eventDef.id];
 		var removeCnt;
 
-		if (eventRangeGroup) {
-			removeCnt = removeMatching(eventRangeGroup.eventRanges, function(currentEventRange) {
-				return currentEventRange.eventInstance.def === eventDef;
+		if (eventInstanceGroup) {
+			removeCnt = removeMatching(eventInstanceGroup.eventInstances, function(currentEventInstance) {
+				return currentEventInstance.def === eventDef;
 			});
 
-			if (!eventRangeGroup.eventRanges.length) {
-				delete eventRangeGroupsById[eventDef.id];
+			if (!eventInstanceGroup.eventInstances.length) {
+				delete eventInstanceGroupsById[eventDef.id];
 			}
 
 			if (removeCnt) {
@@ -362,7 +300,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 
 	release: function() {
 		this.releaseCnt++;
-		this.trigger('release', this.eventRangeGroupsById);
+		this.trigger('release', this.eventInstanceGroupsById);
 	},
 
 
@@ -370,7 +308,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 		var _this = this;
 
 		if (this.releaseCnt) {
-			return Promise.resolve(this.eventRangeGroupsById);
+			return Promise.resolve(this.eventInstanceGroupsById);
 		}
 		else {
 			return Promise.construct(function(onResolve) {

src/models/event/EventInstance.js

@@ -3,30 +3,27 @@ var EventInstance = Class.extend({
 
 	def: null, // EventDef
 	dateProfile: null, // EventDateProfile
+	dateRange: null, // UnzonedRange
 
 
 	constructor: function(def, dateProfile) {
 		this.def = def;
 		this.dateProfile = dateProfile;
+		this.dateRange = dateProfile.buildRange(
+			def.source.calendar
+		);
 	},
 
 
 	buildEventRange: function() { // EventRange
 		return new EventRange(
-			this.buildDateRange(),
+			this.dateRange,
 			this.def,
 			this
 		);
 	},
 
 
-	buildDateRange: function() { // UnzonedRange
-		return this.dateProfile.buildRange(
-			this.def.source.calendar
-		);
-	},
-
-
 	toLegacy: function() {
 		var dateProfile = this.dateProfile;
 		var obj = this.def.toLegacy();

src/models/event/EventRangeGroup.js → src/models/event/EventInstanceGroup.js

@@ -1,16 +1,17 @@
 
-/*
-It's expected that there will be at least one EventRange,
-OR that an explicitEventDef is assigned.
-*/
-var EventRangeGroup = Class.extend({
+var EventInstanceGroup = Class.extend({
 
-	eventRanges: null,
+	eventInstances: null,
 	explicitEventDef: null, // optional
 
 
-	constructor: function(eventRanges) {
-		this.eventRanges = eventRanges || [];
+	constructor: function(eventInstances) {
+		this.eventInstances = eventInstances || [];
+	},
+
+
+	getAllEventRanges: function() {
+		return eventInstancesToEventRanges(this.eventInstances);
 	},
 
 
@@ -25,22 +26,22 @@ var EventRangeGroup = Class.extend({
 
 
 	sliceNormalRenderRanges: function(constraintRange) {
-		var wholeEventRanges = this.eventRanges;
-		var i, eventRange;
+		var eventInstances = this.eventInstances;
+		var i, eventInstance;
 		var slicedDateRange;
 		var slicedEventRanges = [];
 
-		for (i = 0; i < wholeEventRanges.length; i++) {
-			eventRange = wholeEventRanges[i];
+		for (i = 0; i < eventInstances.length; i++) {
+			eventInstance = eventInstances[i];
 
-			slicedDateRange = eventRange.dateRange.constrainTo(constraintRange);
+			slicedDateRange = eventInstance.dateRange.constrainTo(constraintRange);
 
 			if (slicedDateRange) {
 				slicedEventRanges.push(
 					new EventRange(
 						slicedDateRange,
-						eventRange.eventDef,
-						eventRange.eventInstance
+						eventInstance.def,
+						eventInstance
 					)
 				);
 			}
@@ -51,7 +52,7 @@ var EventRangeGroup = Class.extend({
 
 
 	sliceInverseRenderRanges: function(constraintRange) {
-		var dateRanges = collectDateRangesFromEventRanges(this.eventRanges);
+		var dateRanges = eventInstancesToDateRanges(this.eventInstances);
 		var ownerDef = this.getEventDef();
 
 		dateRanges = invertDateRanges(dateRanges, constraintRange);
@@ -68,7 +69,7 @@ var EventRangeGroup = Class.extend({
 
 
 	getEventDef: function() {
-		return this.explicitEventDef || this.eventRanges[0].eventDef;
+		return this.explicitEventDef || this.eventInstances[0].def;
 	}
 
 });

src/models/event/util.js

@@ -20,9 +20,9 @@ function eventInstancesToEventRanges(eventInstances) {
 }
 
 
-function collectDateRangesFromEventRanges(eventRanges) {
-	return eventRanges.map(function(eventRange) {
-		return eventRange.dateRange;
+function eventInstancesToDateRanges(eventInstances) {
+	return eventInstances.map(function(eventInstance) {
+		return eventInstance.dateRange;
 	});
 }