redo reserved props for eventdef parsing

src/common/Grid.events.js

@@ -16,7 +16,7 @@ Grid.mixin({
 
 
 	renderEvents: function(eventsPayload) {
-		var unzonedRange = new UnzonedRange(this.start, this.end);
+		var unzonedRange = new UnzonedRange(this.view.activeRange.start, this.view.activeRange.end);
 		var id, eventRangeGroup;
 		var eventRenderRanges;
 		var eventFootprints;

src/list/ListView.js

@@ -91,7 +91,7 @@ var ListViewGrid = Grid.extend({
 			// detect when footprint won't go fully into the next day,
 			// and mutate the latest seg to the be the end.
 			if (
-				seg && !seg.isEnd && footprint.isAllDay &&
+				seg && !seg.isEnd && !footprint.isAllDay &&
 				footprint.dateRange.getEnd() < dayStart.clone().add(view.nextDayThreshold)
 			) {
 				seg.end = footprint.dateRange.getEnd();

src/models/EventPeriod.js

@@ -124,7 +124,13 @@ var EventPeriod = Class.extend(EmitterMixin, {
 
 
 	getEventDefsById: function(eventDefId) {
-		return this.eventDefsById[eventDefId] || [];
+		var a = this.eventDefsById[eventDefId];
+
+		if (a) {
+			return a.slice(); // clone
+		}
+
+		return [];
 	},
 
 
@@ -280,7 +286,7 @@ var EventPeriod = Class.extend(EmitterMixin, {
 		var eventRangeGroup = this.eventRangeGroupsById[eventDefId];
 
 		if (eventRangeGroup) {
-			return eventRangeGroup.eventRanges;
+			return eventRangeGroup.eventRanges.slice(); // clone
 		}
 
 		return [];

src/models/event-source/EventSource.js

@@ -109,14 +109,17 @@ EventSource.parseAndPluck = function(rawProps, calendar) {
 		'eventDataTransform'
 	]);
 
-	// post-process some soon-to-be member variables
+	// post-process some soon-to-be member variables...
+
+	members.id = EventSource.normalizeId(members.id);
+
+	// can make DRY with EventDef
 	if (typeof members.className === 'string') {
 		members.className = members.className.split(/\s+/);
 	}
-	else if (!members.className) {
+	else if (!$.isArray(members.className)) {
 		delete members.className; // don't overwrite the empty array
 	}
-	members.id = EventSource.normalizeId(members.id);
 
 	// apply the member variables
 	$.extend(source, members);

src/models/event/EventDef.js

@@ -8,15 +8,26 @@ var EventDef = Class.extend({
 	uid: null, // internal ID. new ID for every definition
 
 	title: null,
+	url: null,
 	rendering: null,
 	constraint: null,
 	overlap: null,
+	editable: null,
+	startEditable: null,
+	durationEditable: null,
+	resourceEditable: null,
+	color: null,
+	backgroundColor: null,
+	borderColor: null,
+	textColor: null,
+
 	className: null, // an array. TODO: rename to className*s* (API breakage)
 	miscProps: null,
 
 
 	constructor: function(source) {
 		this.source = source;
+		this.className = [];
 		this.miscProps = {};
 	},
 
@@ -38,10 +49,9 @@ var EventDef = Class.extend({
 		copy.rawId = this.rawId;
 		copy.uid = this.uid; // not really unique anymore :(
 
-		copy.title = this.title;
-		copy.rendering = this.rendering;
-		copy.constraint = this.constraint;
-		copy.overlap = this.overlap;
+		EventDef.copyVerbatimProps(this, copy);
+
+		copy.className = this.className; // should clone?
 		copy.miscProps = $.extend({}, this.miscProps);
 
 		return copy;
@@ -96,23 +106,18 @@ var EventDef = Class.extend({
 
 
 	toLegacy: function() {
-		var obj = {
-			_id: this.uid,
-			source: this.source,
-			className: this.className // should clone?
-		};
+		var obj = $.extend({}, this.miscProps);
+
+		obj._id = this.uid;
+		obj.source = this.source;
+		obj.className = this.className; // should clone?
+		obj.allDay = this.isAllDay();
 
 		if (this.rawId != null) {
 			obj.id = this.rawId;
 		}
 
-		if (this.title != null) {
-			obj.title = this.title;
-		}
-
-		if (this.rendering != null) {
-			obj.rendering = this.rendering;
-		}
+		EventDef.copyVerbatimProps(this, obj);
 
 		return obj;
 	}
@@ -123,80 +128,79 @@ var EventDef = Class.extend({
 EventDef.uuid = 0;
 
 
-// Reserved Properties
+// Verbatim Properties
 // ---------------------------------------------------------------------------------------------------------------------
 
 
-EventDef.reservedPropMap = {};
-
-
-EventDef.addReservedProps = function(propNames) {
-	var map = {};
-	var i;
+EventDef.VERBATIM_PROPS = [
+	'title', 'url', 'rendering', 'constraint', 'overlap',
+	'editable', 'startEditable', 'durationEditable', 'resourceEditable',
+	'color', 'backgroundColor', 'borderColor', 'textColor'
+];
 
-	for (i = 0; i < propNames.length; i++) {
-		map[propNames[i]] = true;
-	}
-
-	// won't modify original object. don't want side-effects on superclasses
-	this.reservedPropMap = $.extend({}, this.reservedPropMap, map);
-};
 
-
-EventDef.isReservedProp = function(propName) {
-	return this.reservedPropMap[propName] || false;
+EventDef.copyVerbatimProps = function(src, dest) {
+	this.VERBATIM_PROPS.forEach(function(propName) {
+		if (src[propName] != null) {
+			dest[propName] = src[propName];
+		}
+	});
 };
 
 
-EventDef.addReservedProps([ 'id', 'title', 'rendering', 'constraint', 'overlap' ]);
-
-
 // Parsing
 // ---------------------------------------------------------------------------------------------------------------------
 
 
-EventDef.parse = function(rawProps, source) {
-	var def = new this(source);
-	var className; // an array
-	var propName;
-	var miscProps = {};
-
+EventDef.parse = function(rawInput, source) {
 	var calendarTransform = source.calendar.opt('eventDataTransform');
 	var sourceTransform = source.eventDataTransform;
 
 	if (calendarTransform) {
-		rawProps = calendarTransform(rawProps);
+		rawInput = calendarTransform(rawInput);
 	}
 	if (sourceTransform) {
-		rawProps = sourceTransform(rawProps);
+		rawInput = sourceTransform(rawInput);
 	}
 
-	className = rawProps.className || [];
-	if (typeof className === 'string') {
-		className = className.split(/\s+/);
-	}
+	return this.pluckAndParse($.extend({}, rawInput), source);
+};
+
+
+EventDef.pluckAndParse = function(rawProps, source) {
+	// pluck
+	var rawId = pluckProp(rawProps, 'id');
+	var className = pluckProp(rawProps, 'className');
+
+	// instantiate and parse...
+	var def = new this(source);
+
+	def.uid = String(EventDef.uuid++);
 
-	if (rawProps.id != null) {
-		def.id = EventDef.normalizeId((def.rawId = rawProps.id));
+	if (rawId == null) {
+		def.id = EventDef.generateId();
 	}
 	else {
-		def.id = EventDef.generateId();
+		def.id = EventDef.normalizeId((def.rawId = rawId));
 	}
 
-	def.uid = String(EventDef.uuid++);
-	def.title = rawProps.title || '';
-	def.rendering = rawProps.rendering || null;
-	def.constraint = rawProps.constraint || null;
-	def.overlap = rawProps.overlap || null;
-	def.className = className;
-
-	for (propName in rawProps) {
-		if (!this.isReservedProp(propName)) {
-			miscProps[propName] = rawProps[propName];
-		}
+	// can make DRY with EventSource
+	if (typeof className === 'string') {
+		def.className = className.split(/\s+/);
+	}
+	else if ($.isArray(className)) {
+		def.className = className;
 	}
 
-	def.miscProps = miscProps;
+	// raw input object might have specified
+	// intercepted earlier
+	delete rawProps.source;
+
+	// transfer all other simple props
+	$.extend(def, pluckProps(rawProps, EventDef.VERBATIM_PROPS));
+
+	// leftovers are misc props
+	def.miscProps = rawProps;
 
 	return def;
 };

src/models/event/EventInstance.js

@@ -33,7 +33,6 @@ var EventInstance = Class.extend({
 
 		obj.start = dateProfile.start.clone();
 		obj.end = dateProfile.end ? dateProfile.end.clone() : null;
-		obj.allDay = dateProfile.isAllDay();
 
 		return obj;
 	}

src/models/event/RecurringEventDef.js

@@ -83,26 +83,29 @@ var RecurringEventDef = EventDef.extend({
 });
 
 
-RecurringEventDef.addReservedProps([ 'start', 'end', 'dow' ]);
-
-
 // Parsing
 // ---------------------------------------------------------------------------------------------------------------------
 
 
-RecurringEventDef.parse = function(rawProps) {
-	var def = EventDef.parse.apply(this, arguments); // a RecurringEventDef
+RecurringEventDef.pluckAndParse = function(rawProps, source) {
+	// pluck from rawProps before sending to super-method
+	var startInput = pluckProp(rawProps, 'start');
+	var endInput = pluckProp(rawProps, 'end');
+	var dow = pluckProp(rawProps, 'dow');
+
+	// instantiate and parse...
+	var def = EventDef.pluckAndParse.call(this, rawProps, source); // a RecurringEventDef
 
-	if (rawProps.start) {
-		def.startTime = moment.duration(rawProps.start);
+	if (startInput) {
+		def.startTime = moment.duration(startInput);
 	}
 
-	if (rawProps.end) {
-		def.endTime = moment.duration(rawProps.end);
+	if (endInput) {
+		def.endTime = moment.duration(endInput);
 	}
 
-	if (rawProps.dow) {
-		def.setDow(rawProps.dow);
+	if (dow) {
+		def.setDow(dow);
 	}
 
 	return def;

src/models/event/SingleEventDef.js

@@ -41,19 +41,23 @@ var SingleEventDef = EventDef.extend(EventStartEndMixin, {
 });
 
 
-SingleEventDef.addReservedProps([ 'start', 'end', 'date' ]);
-
-
 // Parsing
 // ---------------------------------------------------------------------------------------------------------------------
 
 
-SingleEventDef.parse = function(rawProps, source) {
-	var def = EventDef.parse.apply(this, arguments); // a SingleEventDef
+SingleEventDef.pluckAndParse = function(rawProps, source) {
+	// pluck from rawProps before sending to super-method
+	var startInput = pluckProp(rawProps, 'start');
+	var dateInput = pluckProp(rawProps, 'date'); // 'date' is an alias for start
+	var endInput = pluckProp(rawProps, 'end');
+	var forcedAllDay = pluckProp(rawProps, 'allDay');
+
+	// instantiate and parse...
+	var def = EventDef.pluckAndParse.call(this, rawProps, source); // a SingleEventDef
+
 	var calendar = source.calendar;
-	var start = calendar.moment(rawProps.start || rawProps.date); // 'date' is an alias
-	var end = rawProps.end ? calendar.moment(rawProps.end) : null;
-	var forcedAllDay;
+	var start = calendar.moment(startInput || dateInput);
+	var end = endInput ? calendar.moment(endInput) : null;
 	var forceEventDuration;
 
 	if (!start.isValid()) {
@@ -64,7 +68,6 @@ SingleEventDef.parse = function(rawProps, source) {
 		end = null;
 	}
 
-	forcedAllDay = rawProps.allDay;
 	if (forcedAllDay == null) {
 		forcedAllDay = source.allDayDefault;
 		if (forcedAllDay == null) {