/**
* @private
*
* Updates extension and filename mappings from languages based on the current preferences values.
*
* The preferences look like this in a prefs file:
*
* Map *.foo to javascript, *.vm to html
*
* "language.fileExtensions": {
* "foo": "javascript",
* "vm": "html"
* }
*
* Map "Gemfile" to ruby:
*
* "language.fileNames": {
* "Gemfile": "ruby"
* }
*/
function _updateFromPrefs(pref) {
var newMapping = PreferencesManager.get(pref),
newNames = Object.keys(newMapping),
state = _prefState[pref],
last = state.last,
overridden = state.overridden;
// Look for added and changed names (extensions or filenames)
newNames.forEach(function (name) {
var language;
if (newMapping[name] !== last[name]) {
if (last[name]) {
language = getLanguage(last[name]);
if (language) {
language[state.remove](name);
// If this name that was previously mapped was overriding a default
// restore it now.
_restoreOverriddenDefault(name, state);
}
}
language = exports[state.get](name);
if (language) {
language[state.remove](name);
// We're removing a name that was defined in Brackets or an extension,
// so keep track of how it used to be mapped.
if (!overridden[name]) {
overridden[name] = language.getId();
}
}
language = getLanguage(newMapping[name]);
if (language) {
language[state.add](name);
}
}
});
// Look for removed names (extensions or filenames)
_.difference(Object.keys(last), newNames).forEach(function (name) {
var language = getLanguage(last[name]);
if (language) {
language[state.remove](name);
_restoreOverriddenDefault(name, state);
}
});
state.last = newMapping;
}
children = children.withMutations(function (children) {
// Loop through the directory entries
contents.forEach(function (entry) {
keysSeen.push(entry.name);
var match = children.get(entry.name);
if (match) {
// Confirm that a name that used to represent a file and now represents a
// directory (or vice versa) isn't what we've encountered here. If we have
// hit this situation, pretend the current child of treeData doesn't exist
// so we can replace it.
var matchIsFile = isFile(match);
if (matchIsFile !== entry.isFile) {
match = undefined;
}
}
// We've got a new entry that we need to add.
if (!match) {
if (entry.isFile) {
children.set(entry.name, Immutable.Map());
} else {
children.set(entry.name, Immutable.Map({
children: null
}));
}
}
});
// Look at the list of names that we currently have in the treeData that no longer
// appear in the directory and delete those.
var currentEntries = children.keySeq().toJS(),
deletedEntries = _.difference(currentEntries, keysSeen);
deletedEntries.forEach(function (name) {
children.delete(name);
});
});
self.updatePlayerState = function() {
if (self.state === 'abandoned' || self.state === 'aborting')
return;
var current_time = new Date().getTime();
self.updateAbandonmentState(current_time);
var present_uberids = self.getPresentUberIds();
if (self.state === 'empty' && present_uberids.length > 0) {
self.setState('waiting');
}
if (self.state === 'waiting') {
var missing_uberids = _.difference(_.keys(self.expectedPlayers), self.getPresentUberIds());
if (missing_uberids.length === 0) {
self.setState('loading');
} else {
var disconnected_players = _.filter(self.expectedPlayers, function(p) { return !p.isPresent(); });
if (disconnected_players.length > 0) {
var playerNearestTimeout = _.min(disconnected_players, function(p) { return p.getTimeoutRemaining(current_time); });
var recheckTime = playerNearestTimeout.getTimeoutRemaining(current_time) + 500;
debug_log("Setting player state recheck to " + recheckTime + "ms");
self.setTimer(self.updatePlayerState, recheckTime);
} else {
// This is a weird state -- we're missing a player, but they're supposedly all here.
console.error("Mismatch between server presence and our own: " + missing_uberids + " vs " + disconnected_players);
self.setTimer(self.updatePlayerState, 1000);
}
}
} else if (self.state === 'loading') {
var any_loading = _.some(self.lobbyModel.players, function (value) {
return !value.spectator && value.loading;
});
if (!any_loading) {
self.setState('countdown');
}
}
};