依赖文件
This commit is contained in:
浅念
+426
@@ -0,0 +1,426 @@
|
||||
/**
|
||||
Licensed to the Apache Software Foundation (ASF) under one
|
||||
or more contributor license agreements. See the NOTICE file
|
||||
distributed with this work for additional information
|
||||
regarding copyright ownership. The ASF licenses this file
|
||||
to you under the Apache License, Version 2.0 (the
|
||||
"License"); you may not use this file except in compliance
|
||||
with the License. You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing,
|
||||
software distributed under the License is distributed on an
|
||||
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
KIND, either express or implied. See the License for the
|
||||
specific language governing permissions and limitations
|
||||
under the License.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This module deals with shared configuration / dependency "stuff". That is:
|
||||
* - XML configuration files such as config.xml, AndroidManifest.xml or WMAppManifest.xml.
|
||||
* - plist files in iOS
|
||||
* Essentially, any type of shared resources that we need to handle with awareness
|
||||
* of how potentially multiple plugins depend on a single shared resource, should be
|
||||
* handled in this module.
|
||||
*
|
||||
* The implementation uses an object as a hash table, with "leaves" of the table tracking
|
||||
* reference counts.
|
||||
*/
|
||||
|
||||
var path = require('path');
|
||||
var et = require('elementtree');
|
||||
var ConfigKeeper = require('./ConfigKeeper');
|
||||
var events = require('../events');
|
||||
|
||||
var mungeutil = require('./munge-util');
|
||||
var xml_helpers = require('../util/xml-helpers');
|
||||
|
||||
exports.PlatformMunger = PlatformMunger;
|
||||
|
||||
exports.process = function (plugins_dir, project_dir, platform, platformJson, pluginInfoProvider) {
|
||||
var munger = new PlatformMunger(platform, project_dir, platformJson, pluginInfoProvider);
|
||||
munger.process(plugins_dir);
|
||||
munger.save_all();
|
||||
};
|
||||
|
||||
/******************************************************************************
|
||||
* PlatformMunger class
|
||||
*
|
||||
* Can deal with config file of a single project.
|
||||
* Parsed config files are cached in a ConfigKeeper object.
|
||||
******************************************************************************/
|
||||
function PlatformMunger (platform, project_dir, platformJson, pluginInfoProvider) {
|
||||
this.platform = platform;
|
||||
this.project_dir = project_dir;
|
||||
this.config_keeper = new ConfigKeeper(project_dir);
|
||||
this.platformJson = platformJson;
|
||||
this.pluginInfoProvider = pluginInfoProvider;
|
||||
}
|
||||
|
||||
// Write out all unsaved files.
|
||||
PlatformMunger.prototype.save_all = PlatformMunger_save_all;
|
||||
function PlatformMunger_save_all () {
|
||||
this.config_keeper.save_all();
|
||||
this.platformJson.save();
|
||||
}
|
||||
|
||||
// Apply a munge object to a single config file.
|
||||
// The remove parameter tells whether to add the change or remove it.
|
||||
PlatformMunger.prototype.apply_file_munge = PlatformMunger_apply_file_munge;
|
||||
function PlatformMunger_apply_file_munge (file, munge, remove) {
|
||||
var self = this;
|
||||
|
||||
for (var selector in munge.parents) {
|
||||
for (var xml_child in munge.parents[selector]) {
|
||||
// this xml child is new, graft it (only if config file exists)
|
||||
var config_file = self.config_keeper.get(self.project_dir, self.platform, file);
|
||||
if (config_file.exists) {
|
||||
if (remove) config_file.prune_child(selector, munge.parents[selector][xml_child]);
|
||||
else config_file.graft_child(selector, munge.parents[selector][xml_child]);
|
||||
} else {
|
||||
events.emit('warn', 'config file ' + file + ' requested for changes not found at ' + config_file.filepath + ', ignoring');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
PlatformMunger.prototype.remove_plugin_changes = remove_plugin_changes;
|
||||
function remove_plugin_changes (pluginInfo, is_top_level) {
|
||||
var self = this;
|
||||
var platform_config = self.platformJson.root;
|
||||
var plugin_vars = is_top_level
|
||||
? platform_config.installed_plugins[pluginInfo.id]
|
||||
: platform_config.dependent_plugins[pluginInfo.id];
|
||||
var edit_config_changes = null;
|
||||
if (pluginInfo.getEditConfigs) {
|
||||
edit_config_changes = pluginInfo.getEditConfigs(self.platform);
|
||||
}
|
||||
|
||||
// get config munge, aka how did this plugin change various config files
|
||||
var config_munge = self.generate_plugin_config_munge(pluginInfo, plugin_vars, edit_config_changes);
|
||||
// global munge looks at all plugins' changes to config files
|
||||
var global_munge = platform_config.config_munge;
|
||||
var munge = mungeutil.decrement_munge(global_munge, config_munge);
|
||||
|
||||
for (var file in munge.files) {
|
||||
self.apply_file_munge(file, munge.files[file], /* remove = */ true);
|
||||
}
|
||||
|
||||
// Remove from installed_plugins
|
||||
self.platformJson.removePlugin(pluginInfo.id, is_top_level);
|
||||
return self;
|
||||
}
|
||||
|
||||
PlatformMunger.prototype.add_plugin_changes = add_plugin_changes;
|
||||
function add_plugin_changes (pluginInfo, plugin_vars, is_top_level, should_increment, plugin_force) {
|
||||
var self = this;
|
||||
var platform_config = self.platformJson.root;
|
||||
|
||||
var edit_config_changes = null;
|
||||
if (pluginInfo.getEditConfigs) {
|
||||
edit_config_changes = pluginInfo.getEditConfigs(self.platform);
|
||||
}
|
||||
|
||||
var config_munge;
|
||||
|
||||
if (!edit_config_changes || edit_config_changes.length === 0) {
|
||||
// get config munge, aka how should this plugin change various config files
|
||||
config_munge = self.generate_plugin_config_munge(pluginInfo, plugin_vars);
|
||||
} else {
|
||||
var isConflictingInfo = is_conflicting(edit_config_changes, platform_config.config_munge, self, plugin_force);
|
||||
|
||||
if (isConflictingInfo.conflictWithConfigxml) {
|
||||
throw new Error(pluginInfo.id +
|
||||
' cannot be added. <edit-config> changes in this plugin conflicts with <edit-config> changes in config.xml. Conflicts must be resolved before plugin can be added.');
|
||||
}
|
||||
if (plugin_force) {
|
||||
events.emit('warn', '--force is used. edit-config will overwrite conflicts if any. Conflicting plugins may not work as expected.');
|
||||
|
||||
// remove conflicting munges
|
||||
var conflict_munge = mungeutil.decrement_munge(platform_config.config_munge, isConflictingInfo.conflictingMunge);
|
||||
for (var conflict_file in conflict_munge.files) {
|
||||
self.apply_file_munge(conflict_file, conflict_munge.files[conflict_file], /* remove = */ true);
|
||||
}
|
||||
|
||||
// force add new munges
|
||||
config_munge = self.generate_plugin_config_munge(pluginInfo, plugin_vars, edit_config_changes);
|
||||
} else if (isConflictingInfo.conflictFound) {
|
||||
throw new Error('There was a conflict trying to modify attributes with <edit-config> in plugin ' + pluginInfo.id +
|
||||
'. The conflicting plugin, ' + isConflictingInfo.conflictingPlugin + ', already modified the same attributes. The conflict must be resolved before ' +
|
||||
pluginInfo.id + ' can be added. You may use --force to add the plugin and overwrite the conflicting attributes.');
|
||||
} else {
|
||||
// no conflicts, will handle edit-config
|
||||
config_munge = self.generate_plugin_config_munge(pluginInfo, plugin_vars, edit_config_changes);
|
||||
}
|
||||
}
|
||||
|
||||
self = munge_helper(should_increment, self, platform_config, config_munge);
|
||||
|
||||
// Move to installed/dependent_plugins
|
||||
self.platformJson.addPlugin(pluginInfo.id, plugin_vars || {}, is_top_level);
|
||||
return self;
|
||||
}
|
||||
|
||||
// Handle edit-config changes from config.xml
|
||||
PlatformMunger.prototype.add_config_changes = add_config_changes;
|
||||
function add_config_changes (config, should_increment) {
|
||||
var self = this;
|
||||
var platform_config = self.platformJson.root;
|
||||
|
||||
var config_munge;
|
||||
var changes = [];
|
||||
|
||||
if (config.getEditConfigs) {
|
||||
var edit_config_changes = config.getEditConfigs(self.platform);
|
||||
if (edit_config_changes) {
|
||||
changes = changes.concat(edit_config_changes);
|
||||
}
|
||||
}
|
||||
|
||||
if (config.getConfigFiles) {
|
||||
var config_files_changes = config.getConfigFiles(self.platform);
|
||||
if (config_files_changes) {
|
||||
changes = changes.concat(config_files_changes);
|
||||
}
|
||||
}
|
||||
|
||||
if (changes && changes.length > 0) {
|
||||
var isConflictingInfo = is_conflicting(changes, platform_config.config_munge, self, true /* always force overwrite other edit-config */);
|
||||
if (isConflictingInfo.conflictFound) {
|
||||
var conflict_munge;
|
||||
var conflict_file;
|
||||
|
||||
if (Object.keys(isConflictingInfo.configxmlMunge.files).length !== 0) {
|
||||
// silently remove conflicting config.xml munges so new munges can be added
|
||||
conflict_munge = mungeutil.decrement_munge(platform_config.config_munge, isConflictingInfo.configxmlMunge);
|
||||
for (conflict_file in conflict_munge.files) {
|
||||
self.apply_file_munge(conflict_file, conflict_munge.files[conflict_file], /* remove = */ true);
|
||||
}
|
||||
}
|
||||
if (Object.keys(isConflictingInfo.conflictingMunge.files).length !== 0) {
|
||||
events.emit('warn', 'Conflict found, edit-config changes from config.xml will overwrite plugin.xml changes');
|
||||
|
||||
// remove conflicting plugin.xml munges
|
||||
conflict_munge = mungeutil.decrement_munge(platform_config.config_munge, isConflictingInfo.conflictingMunge);
|
||||
for (conflict_file in conflict_munge.files) {
|
||||
self.apply_file_munge(conflict_file, conflict_munge.files[conflict_file], /* remove = */ true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add config.xml edit-config and config-file munges
|
||||
config_munge = self.generate_config_xml_munge(config, changes, 'config.xml');
|
||||
self = munge_helper(should_increment, self, platform_config, config_munge);
|
||||
|
||||
// Move to installed/dependent_plugins
|
||||
return self;
|
||||
}
|
||||
|
||||
function munge_helper (should_increment, self, platform_config, config_munge) {
|
||||
// global munge looks at all changes to config files
|
||||
|
||||
// TODO: The should_increment param is only used by cordova-cli and is going away soon.
|
||||
// If should_increment is set to false, avoid modifying the global_munge (use clone)
|
||||
// and apply the entire config_munge because it's already a proper subset of the global_munge.
|
||||
var munge, global_munge;
|
||||
if (should_increment) {
|
||||
global_munge = platform_config.config_munge;
|
||||
munge = mungeutil.increment_munge(global_munge, config_munge);
|
||||
} else {
|
||||
global_munge = mungeutil.clone_munge(platform_config.config_munge);
|
||||
munge = config_munge;
|
||||
}
|
||||
|
||||
for (var file in munge.files) {
|
||||
self.apply_file_munge(file, munge.files[file]);
|
||||
}
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
// Load the global munge from platform json and apply all of it.
|
||||
// Used by cordova prepare to re-generate some config file from platform
|
||||
// defaults and the global munge.
|
||||
PlatformMunger.prototype.reapply_global_munge = reapply_global_munge;
|
||||
function reapply_global_munge () {
|
||||
var self = this;
|
||||
|
||||
var platform_config = self.platformJson.root;
|
||||
var global_munge = platform_config.config_munge;
|
||||
for (var file in global_munge.files) {
|
||||
self.apply_file_munge(file, global_munge.files[file]);
|
||||
}
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
// generate_plugin_config_munge
|
||||
// Generate the munge object from config.xml
|
||||
PlatformMunger.prototype.generate_config_xml_munge = generate_config_xml_munge;
|
||||
function generate_config_xml_munge (config, config_changes, type) {
|
||||
var munge = { files: {} };
|
||||
var id;
|
||||
|
||||
if (!config_changes) {
|
||||
return munge;
|
||||
}
|
||||
|
||||
if (type === 'config.xml') {
|
||||
id = type;
|
||||
} else {
|
||||
id = config.id;
|
||||
}
|
||||
|
||||
config_changes.forEach(function (change) {
|
||||
change.xmls.forEach(function (xml) {
|
||||
// 1. stringify each xml
|
||||
var stringified = (new et.ElementTree(xml)).write({ xml_declaration: false });
|
||||
// 2. add into munge
|
||||
if (change.mode) {
|
||||
mungeutil.deep_add(munge, change.file, change.target, { xml: stringified, count: 1, mode: change.mode, id: id });
|
||||
} else {
|
||||
mungeutil.deep_add(munge, change.target, change.parent, { xml: stringified, count: 1, after: change.after });
|
||||
}
|
||||
});
|
||||
});
|
||||
return munge;
|
||||
}
|
||||
|
||||
// generate_plugin_config_munge
|
||||
// Generate the munge object from plugin.xml + vars
|
||||
PlatformMunger.prototype.generate_plugin_config_munge = generate_plugin_config_munge;
|
||||
function generate_plugin_config_munge (pluginInfo, vars, edit_config_changes) {
|
||||
var self = this;
|
||||
|
||||
vars = vars || {};
|
||||
var munge = { files: {} };
|
||||
var changes = pluginInfo.getConfigFiles(self.platform);
|
||||
|
||||
if (edit_config_changes) {
|
||||
Array.prototype.push.apply(changes, edit_config_changes);
|
||||
}
|
||||
|
||||
changes.forEach(function (change) {
|
||||
change.xmls.forEach(function (xml) {
|
||||
// 1. stringify each xml
|
||||
var stringified = (new et.ElementTree(xml)).write({ xml_declaration: false });
|
||||
// interp vars
|
||||
if (vars) {
|
||||
Object.keys(vars).forEach(function (key) {
|
||||
var regExp = new RegExp('\\$' + key, 'g');
|
||||
stringified = stringified.replace(regExp, vars[key]);
|
||||
});
|
||||
}
|
||||
// 2. add into munge
|
||||
if (change.mode) {
|
||||
if (change.mode !== 'remove') {
|
||||
mungeutil.deep_add(munge, change.file, change.target, { xml: stringified, count: 1, mode: change.mode, plugin: pluginInfo.id });
|
||||
}
|
||||
} else {
|
||||
mungeutil.deep_add(munge, change.target, change.parent, { xml: stringified, count: 1, after: change.after });
|
||||
}
|
||||
});
|
||||
});
|
||||
return munge;
|
||||
}
|
||||
|
||||
function is_conflicting (editchanges, config_munge, self, force) {
|
||||
var files = config_munge.files;
|
||||
var conflictFound = false;
|
||||
var conflictWithConfigxml = false;
|
||||
var conflictingMunge = { files: {} };
|
||||
var configxmlMunge = { files: {} };
|
||||
var conflictingParent;
|
||||
var conflictingPlugin;
|
||||
|
||||
editchanges.forEach(function (editchange) {
|
||||
if (files[editchange.file]) {
|
||||
var parents = files[editchange.file].parents;
|
||||
var target = parents[editchange.target];
|
||||
|
||||
// Check if the edit target will resolve to an existing target
|
||||
if (!target || target.length === 0) {
|
||||
var file_xml = self.config_keeper.get(self.project_dir, self.platform, editchange.file).data;
|
||||
var resolveEditTarget = xml_helpers.resolveParent(file_xml, editchange.target);
|
||||
var resolveTarget;
|
||||
|
||||
if (resolveEditTarget) {
|
||||
for (var parent in parents) {
|
||||
resolveTarget = xml_helpers.resolveParent(file_xml, parent);
|
||||
if (resolveEditTarget === resolveTarget) {
|
||||
conflictingParent = parent;
|
||||
target = parents[parent];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
conflictingParent = editchange.target;
|
||||
}
|
||||
|
||||
if (target && target.length !== 0) {
|
||||
// conflict has been found
|
||||
conflictFound = true;
|
||||
|
||||
if (editchange.id === 'config.xml') {
|
||||
if (target[0].id === 'config.xml') {
|
||||
// Keep track of config.xml/config.xml edit-config conflicts
|
||||
mungeutil.deep_add(configxmlMunge, editchange.file, conflictingParent, target[0]);
|
||||
} else {
|
||||
// Keep track of config.xml x plugin.xml edit-config conflicts
|
||||
mungeutil.deep_add(conflictingMunge, editchange.file, conflictingParent, target[0]);
|
||||
}
|
||||
} else {
|
||||
if (target[0].id === 'config.xml') {
|
||||
// plugin.xml cannot overwrite config.xml changes even if --force is used
|
||||
conflictWithConfigxml = true;
|
||||
return;
|
||||
}
|
||||
|
||||
if (force) {
|
||||
// Need to find all conflicts when --force is used, track conflicting munges
|
||||
mungeutil.deep_add(conflictingMunge, editchange.file, conflictingParent, target[0]);
|
||||
} else {
|
||||
// plugin cannot overwrite other plugin changes without --force
|
||||
conflictingPlugin = target[0].plugin;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return { conflictFound: conflictFound,
|
||||
conflictingPlugin: conflictingPlugin,
|
||||
conflictingMunge: conflictingMunge,
|
||||
configxmlMunge: configxmlMunge,
|
||||
conflictWithConfigxml: conflictWithConfigxml
|
||||
};
|
||||
}
|
||||
|
||||
// Go over the prepare queue and apply the config munges for each plugin
|
||||
// that has been (un)installed.
|
||||
PlatformMunger.prototype.process = PlatformMunger_process;
|
||||
function PlatformMunger_process (plugins_dir) {
|
||||
var self = this;
|
||||
var platform_config = self.platformJson.root;
|
||||
|
||||
// Uninstallation first
|
||||
platform_config.prepare_queue.uninstalled.forEach(function (u) {
|
||||
var pluginInfo = self.pluginInfoProvider.get(path.join(plugins_dir, u.plugin));
|
||||
self.remove_plugin_changes(pluginInfo, u.topLevel);
|
||||
});
|
||||
|
||||
// Now handle installation
|
||||
platform_config.prepare_queue.installed.forEach(function (u) {
|
||||
var pluginInfo = self.pluginInfoProvider.get(path.join(plugins_dir, u.plugin));
|
||||
self.add_plugin_changes(pluginInfo, u.vars, u.topLevel, true, u.force);
|
||||
});
|
||||
|
||||
// Empty out installed/ uninstalled queues.
|
||||
platform_config.prepare_queue.uninstalled = [];
|
||||
platform_config.prepare_queue.installed = [];
|
||||
}
|
||||
/** ** END of PlatformMunger ****/
|
||||
+265
@@ -0,0 +1,265 @@
|
||||
/*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
var fs = require('fs-extra');
|
||||
var path = require('path');
|
||||
|
||||
var modules = {};
|
||||
var addProperty = require('../util/addProperty');
|
||||
|
||||
// Use delay loading to ensure plist and other node modules to not get loaded
|
||||
// on Android, Windows platforms
|
||||
addProperty(module, 'bplist', 'bplist-parser', modules);
|
||||
addProperty(module, 'et', 'elementtree', modules);
|
||||
addProperty(module, 'glob', 'glob', modules);
|
||||
addProperty(module, 'plist', 'plist', modules);
|
||||
addProperty(module, 'plist_helpers', '../util/plist-helpers', modules);
|
||||
addProperty(module, 'xml_helpers', '../util/xml-helpers', modules);
|
||||
|
||||
/******************************************************************************
|
||||
* ConfigFile class
|
||||
*
|
||||
* Can load and keep various types of config files. Provides some functionality
|
||||
* specific to some file types such as grafting XML children. In most cases it
|
||||
* should be instantiated by ConfigKeeper.
|
||||
*
|
||||
* For plugin.xml files use as:
|
||||
* plugin_config = self.config_keeper.get(plugin_dir, '', 'plugin.xml');
|
||||
*
|
||||
* TODO: Consider moving it out to a separate file and maybe partially with
|
||||
* overrides in platform handlers.
|
||||
******************************************************************************/
|
||||
function ConfigFile (project_dir, platform, file_tag) {
|
||||
this.project_dir = project_dir;
|
||||
this.platform = platform;
|
||||
this.file_tag = file_tag;
|
||||
this.is_changed = false;
|
||||
|
||||
this.load();
|
||||
}
|
||||
|
||||
// ConfigFile.load()
|
||||
ConfigFile.prototype.load = ConfigFile_load;
|
||||
function ConfigFile_load () {
|
||||
var self = this;
|
||||
|
||||
// config file may be in a place not exactly specified in the target
|
||||
var filepath = self.filepath = resolveConfigFilePath(self.project_dir, self.platform, self.file_tag);
|
||||
|
||||
if (!filepath || !fs.existsSync(filepath)) {
|
||||
self.exists = false;
|
||||
return;
|
||||
}
|
||||
self.exists = true;
|
||||
self.mtime = fs.statSync(self.filepath).mtime;
|
||||
|
||||
var ext = path.extname(filepath);
|
||||
// Windows8 uses an appxmanifest, and wp8 will likely use
|
||||
// the same in a future release
|
||||
if (ext === '.xml' || ext === '.appxmanifest' || ext === '.storyboard' || ext === '.jsproj') {
|
||||
self.type = 'xml';
|
||||
self.data = modules.xml_helpers.parseElementtreeSync(filepath);
|
||||
} else {
|
||||
// plist file
|
||||
self.type = 'plist';
|
||||
// TODO: isBinaryPlist() reads the file and then parse re-reads it again.
|
||||
// We always write out text plist, not binary.
|
||||
// Do we still need to support binary plist?
|
||||
// If yes, use plist.parseStringSync() and read the file once.
|
||||
self.data = isBinaryPlist(filepath)
|
||||
? modules.bplist.parseBuffer(fs.readFileSync(filepath))[0]
|
||||
: modules.plist.parse(fs.readFileSync(filepath, 'utf8'));
|
||||
}
|
||||
}
|
||||
|
||||
ConfigFile.prototype.save = function ConfigFile_save () {
|
||||
var self = this;
|
||||
if (self.type === 'xml') {
|
||||
fs.writeFileSync(self.filepath, self.data.write({ indent: 4 }), 'utf-8');
|
||||
} else {
|
||||
// plist
|
||||
var regExp = /<string>[ \t\r\n]+?<\/string>/g;
|
||||
fs.writeFileSync(self.filepath, modules.plist.build(self.data, { indent: '\t', offset: -1 }).replace(regExp, '<string></string>'));
|
||||
}
|
||||
self.is_changed = false;
|
||||
};
|
||||
|
||||
ConfigFile.prototype.graft_child = function ConfigFile_graft_child (selector, xml_child) {
|
||||
var self = this;
|
||||
var filepath = self.filepath;
|
||||
var result;
|
||||
if (self.type === 'xml') {
|
||||
var xml_to_graft = [modules.et.XML(xml_child.xml)];
|
||||
switch (xml_child.mode) {
|
||||
case 'merge':
|
||||
result = modules.xml_helpers.graftXMLMerge(self.data, xml_to_graft, selector, xml_child);
|
||||
break;
|
||||
case 'overwrite':
|
||||
result = modules.xml_helpers.graftXMLOverwrite(self.data, xml_to_graft, selector, xml_child);
|
||||
break;
|
||||
case 'remove':
|
||||
result = modules.xml_helpers.pruneXMLRemove(self.data, selector, xml_to_graft);
|
||||
break;
|
||||
default:
|
||||
result = modules.xml_helpers.graftXML(self.data, xml_to_graft, selector, xml_child.after);
|
||||
}
|
||||
if (!result) {
|
||||
throw new Error('Unable to graft xml at selector "' + selector + '" from "' + filepath + '" during config install');
|
||||
}
|
||||
} else {
|
||||
// plist file
|
||||
result = modules.plist_helpers.graftPLIST(self.data, xml_child.xml, selector);
|
||||
if (!result) {
|
||||
throw new Error('Unable to graft plist "' + filepath + '" during config install');
|
||||
}
|
||||
}
|
||||
self.is_changed = true;
|
||||
};
|
||||
|
||||
ConfigFile.prototype.prune_child = function ConfigFile_prune_child (selector, xml_child) {
|
||||
var self = this;
|
||||
var filepath = self.filepath;
|
||||
var result;
|
||||
if (self.type === 'xml') {
|
||||
var xml_to_graft = [modules.et.XML(xml_child.xml)];
|
||||
switch (xml_child.mode) {
|
||||
case 'merge':
|
||||
case 'overwrite':
|
||||
result = modules.xml_helpers.pruneXMLRestore(self.data, selector, xml_child);
|
||||
break;
|
||||
case 'remove':
|
||||
result = modules.xml_helpers.pruneXMLRemove(self.data, selector, xml_to_graft);
|
||||
break;
|
||||
default:
|
||||
result = modules.xml_helpers.pruneXML(self.data, xml_to_graft, selector);
|
||||
}
|
||||
} else {
|
||||
// plist file
|
||||
result = modules.plist_helpers.prunePLIST(self.data, xml_child.xml, selector);
|
||||
}
|
||||
if (!result) {
|
||||
var err_msg = 'Pruning at selector "' + selector + '" from "' + filepath + '" went bad.';
|
||||
throw new Error(err_msg);
|
||||
}
|
||||
self.is_changed = true;
|
||||
};
|
||||
|
||||
// Some config-file target attributes are not qualified with a full leading directory, or contain wildcards.
|
||||
// Resolve to a real path in this function.
|
||||
// TODO: getIOSProjectname is slow because of glob, try to avoid calling it several times per project.
|
||||
function resolveConfigFilePath (project_dir, platform, file) {
|
||||
var filepath = path.join(project_dir, file);
|
||||
var matches;
|
||||
|
||||
file = path.normalize(file);
|
||||
|
||||
if (file.includes('*')) {
|
||||
// handle wildcards in targets using glob.
|
||||
matches = modules.glob.sync(path.join(project_dir, '**', file));
|
||||
if (matches.length) filepath = matches[0];
|
||||
|
||||
// [CB-5989] multiple Info.plist files may exist. default to $PROJECT_NAME-Info.plist
|
||||
if (matches.length > 1 && file.includes('-Info.plist')) {
|
||||
var plistName = getIOSProjectname(project_dir) + '-Info.plist';
|
||||
for (var i = 0; i < matches.length; i++) {
|
||||
if (matches[i].includes(plistName)) {
|
||||
filepath = matches[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return filepath;
|
||||
}
|
||||
|
||||
// XXX this checks for android studio projects
|
||||
// only if none of the options above are satisfied does this get called
|
||||
// TODO: Move this out of cordova-common and into the platforms somehow
|
||||
if (platform === 'android' && !fs.existsSync(filepath)) {
|
||||
var config_file;
|
||||
|
||||
if (file === 'AndroidManifest.xml') {
|
||||
filepath = path.join(project_dir, 'app', 'src', 'main', 'AndroidManifest.xml');
|
||||
} else if (file.endsWith('config.xml')) {
|
||||
filepath = path.join(project_dir, 'app', 'src', 'main', 'res', 'xml', 'config.xml');
|
||||
} else if (file.endsWith('strings.xml')) {
|
||||
// Plugins really shouldn't mess with strings.xml, since it's able to be localized
|
||||
filepath = path.join(project_dir, 'app', 'src', 'main', 'res', 'values', 'strings.xml');
|
||||
} else if (file.includes(path.join('res', 'values'))) {
|
||||
config_file = path.basename(file);
|
||||
filepath = path.join(project_dir, 'app', 'src', 'main', 'res', 'values', config_file);
|
||||
} else if (file.includes(path.join('res', 'xml'))) {
|
||||
// Catch-all for all other stored XML configuration in legacy plugins
|
||||
config_file = path.basename(file);
|
||||
filepath = path.join(project_dir, 'app', 'src', 'main', 'res', 'xml', config_file);
|
||||
}
|
||||
return filepath;
|
||||
}
|
||||
|
||||
// special-case config.xml target that is just "config.xml" for other platforms. This should
|
||||
// be resolved to the real location of the file.
|
||||
// TODO: Move this out of cordova-common into platforms
|
||||
if (file === 'config.xml') {
|
||||
if (platform === 'ubuntu') {
|
||||
filepath = path.join(project_dir, 'config.xml');
|
||||
} else if (platform === 'ios' || platform === 'osx') {
|
||||
filepath = path.join(
|
||||
project_dir,
|
||||
module.exports.getIOSProjectname(project_dir),
|
||||
'config.xml'
|
||||
);
|
||||
} else {
|
||||
matches = modules.glob.sync(path.join(project_dir, '**', 'config.xml'));
|
||||
if (matches.length) filepath = matches[0];
|
||||
}
|
||||
return filepath;
|
||||
}
|
||||
|
||||
// None of the special cases matched, returning project_dir/file.
|
||||
return filepath;
|
||||
}
|
||||
|
||||
// Find out the real name of an iOS or OSX project
|
||||
// TODO: glob is slow, need a better way or caching, or avoid using more than once.
|
||||
function getIOSProjectname (project_dir) {
|
||||
var matches = modules.glob.sync(path.join(project_dir, '*.xcodeproj'));
|
||||
var iospath;
|
||||
if (matches.length === 1) {
|
||||
iospath = path.basename(matches[0], '.xcodeproj');
|
||||
} else {
|
||||
var msg;
|
||||
if (matches.length === 0) {
|
||||
msg = 'Does not appear to be an xcode project, no xcode project file in ' + project_dir;
|
||||
} else {
|
||||
msg = 'There are multiple *.xcodeproj dirs in ' + project_dir;
|
||||
}
|
||||
throw new Error(msg);
|
||||
}
|
||||
return iospath;
|
||||
}
|
||||
|
||||
// determine if a plist file is binary
|
||||
function isBinaryPlist (filename) {
|
||||
// I wish there was a synchronous way to read only the first 6 bytes of a
|
||||
// file. This is wasteful :/
|
||||
var buf = '' + fs.readFileSync(filename, 'utf8');
|
||||
// binary plists start with a magic header, "bplist"
|
||||
return buf.substring(0, 6) === 'bplist';
|
||||
}
|
||||
|
||||
module.exports = ConfigFile;
|
||||
module.exports.isBinaryPlist = isBinaryPlist;
|
||||
module.exports.getIOSProjectname = getIOSProjectname;
|
||||
module.exports.resolveConfigFilePath = resolveConfigFilePath;
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
/*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*
|
||||
*/
|
||||
/* jshint sub:true */
|
||||
|
||||
var path = require('path');
|
||||
var ConfigFile = require('./ConfigFile');
|
||||
|
||||
/******************************************************************************
|
||||
* ConfigKeeper class
|
||||
*
|
||||
* Used to load and store config files to avoid re-parsing and writing them out
|
||||
* multiple times.
|
||||
*
|
||||
* The config files are referred to by a fake path constructed as
|
||||
* project_dir/platform/file
|
||||
* where file is the name used for the file in config munges.
|
||||
******************************************************************************/
|
||||
function ConfigKeeper (project_dir, plugins_dir) {
|
||||
this.project_dir = project_dir;
|
||||
this.plugins_dir = plugins_dir;
|
||||
this._cached = {};
|
||||
}
|
||||
|
||||
ConfigKeeper.prototype.get = function ConfigKeeper_get (project_dir, platform, file) {
|
||||
var self = this;
|
||||
|
||||
// This fixes a bug with older plugins - when specifying config xml instead of res/xml/config.xml
|
||||
// https://issues.apache.org/jira/browse/CB-6414
|
||||
if (file === 'config.xml' && platform === 'android') {
|
||||
file = 'res/xml/config.xml';
|
||||
}
|
||||
var fake_path = path.join(project_dir, platform, file);
|
||||
|
||||
if (self._cached[fake_path]) {
|
||||
return self._cached[fake_path];
|
||||
}
|
||||
// File was not cached, need to load.
|
||||
var config_file = new ConfigFile(project_dir, platform, file);
|
||||
self._cached[fake_path] = config_file;
|
||||
return config_file;
|
||||
};
|
||||
|
||||
ConfigKeeper.prototype.save_all = function ConfigKeeper_save_all () {
|
||||
var self = this;
|
||||
Object.keys(self._cached).forEach(function (fake_path) {
|
||||
var config_file = self._cached[fake_path];
|
||||
if (config_file.is_changed) config_file.save();
|
||||
});
|
||||
};
|
||||
|
||||
module.exports = ConfigKeeper;
|
||||
+162
@@ -0,0 +1,162 @@
|
||||
/*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*
|
||||
*/
|
||||
/* jshint sub:true */
|
||||
|
||||
var _ = require('underscore');
|
||||
|
||||
// add the count of [key1][key2]...[keyN] to obj
|
||||
// return true if it didn't exist before
|
||||
exports.deep_add = function deep_add (obj, keys /* or key1, key2 .... */) {
|
||||
if (!Array.isArray(keys)) {
|
||||
keys = Array.prototype.slice.call(arguments, 1);
|
||||
}
|
||||
|
||||
return exports.process_munge(obj, true/* createParents */, function (parentArray, k) {
|
||||
var found = _.find(parentArray, function (element) {
|
||||
return element.xml === k.xml;
|
||||
});
|
||||
if (found) {
|
||||
found.after = found.after || k.after;
|
||||
found.count += k.count;
|
||||
} else {
|
||||
parentArray.push(k);
|
||||
}
|
||||
return !found;
|
||||
}, keys);
|
||||
};
|
||||
|
||||
// decrement the count of [key1][key2]...[keyN] from obj and remove if it reaches 0
|
||||
// return true if it was removed or not found
|
||||
exports.deep_remove = function deep_remove (obj, keys /* or key1, key2 .... */) {
|
||||
if (!Array.isArray(keys)) {
|
||||
keys = Array.prototype.slice.call(arguments, 1);
|
||||
}
|
||||
|
||||
var result = exports.process_munge(obj, false/* createParents */, function (parentArray, k) {
|
||||
var index = -1;
|
||||
var found = _.find(parentArray, function (element) {
|
||||
index++;
|
||||
return element.xml === k.xml;
|
||||
});
|
||||
if (found) {
|
||||
if (parentArray[index].oldAttrib) {
|
||||
k.oldAttrib = _.extend({}, parentArray[index].oldAttrib);
|
||||
}
|
||||
found.count -= k.count;
|
||||
if (found.count > 0) {
|
||||
return false;
|
||||
} else {
|
||||
parentArray.splice(index, 1);
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}, keys);
|
||||
|
||||
return typeof result === 'undefined' ? true : result;
|
||||
};
|
||||
|
||||
// search for [key1][key2]...[keyN]
|
||||
// return the object or undefined if not found
|
||||
exports.deep_find = function deep_find (obj, keys /* or key1, key2 .... */) {
|
||||
if (!Array.isArray(keys)) {
|
||||
keys = Array.prototype.slice.call(arguments, 1);
|
||||
}
|
||||
|
||||
return exports.process_munge(obj, false/* createParents? */, function (parentArray, k) {
|
||||
return _.find(parentArray, function (element) {
|
||||
return element.xml === (k.xml || k);
|
||||
});
|
||||
}, keys);
|
||||
};
|
||||
|
||||
// Execute func passing it the parent array and the xmlChild key.
|
||||
// When createParents is true, add the file and parent items they are missing
|
||||
// When createParents is false, stop and return undefined if the file and/or parent items are missing
|
||||
|
||||
exports.process_munge = function process_munge (obj, createParents, func, keys /* or key1, key2 .... */) {
|
||||
if (!Array.isArray(keys)) {
|
||||
keys = Array.prototype.slice.call(arguments, 1);
|
||||
}
|
||||
var k = keys[0];
|
||||
if (keys.length === 1) {
|
||||
return func(obj, k);
|
||||
} else if (keys.length === 2) {
|
||||
if (!obj.parents[k] && !createParents) {
|
||||
return undefined;
|
||||
}
|
||||
obj.parents[k] = obj.parents[k] || [];
|
||||
return exports.process_munge(obj.parents[k], createParents, func, keys.slice(1));
|
||||
} else if (keys.length === 3) {
|
||||
if (!obj.files[k] && !createParents) {
|
||||
return undefined;
|
||||
}
|
||||
obj.files[k] = obj.files[k] || { parents: {} };
|
||||
return exports.process_munge(obj.files[k], createParents, func, keys.slice(1));
|
||||
} else {
|
||||
throw new Error('Invalid key format. Must contain at most 3 elements (file, parent, xmlChild).');
|
||||
}
|
||||
};
|
||||
|
||||
// All values from munge are added to base as
|
||||
// base[file][selector][child] += munge[file][selector][child]
|
||||
// Returns a munge object containing values that exist in munge
|
||||
// but not in base.
|
||||
exports.increment_munge = function increment_munge (base, munge) {
|
||||
var diff = { files: {} };
|
||||
|
||||
for (var file in munge.files) {
|
||||
for (var selector in munge.files[file].parents) {
|
||||
for (var xml_child in munge.files[file].parents[selector]) {
|
||||
var val = munge.files[file].parents[selector][xml_child];
|
||||
// if node not in base, add it to diff and base
|
||||
// else increment it's value in base without adding to diff
|
||||
var newlyAdded = exports.deep_add(base, [file, selector, val]);
|
||||
if (newlyAdded) {
|
||||
exports.deep_add(diff, file, selector, val);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return diff;
|
||||
};
|
||||
|
||||
// Update the base munge object as
|
||||
// base[file][selector][child] -= munge[file][selector][child]
|
||||
// nodes that reached zero value are removed from base and added to the returned munge
|
||||
// object.
|
||||
exports.decrement_munge = function decrement_munge (base, munge) {
|
||||
var zeroed = { files: {} };
|
||||
|
||||
for (var file in munge.files) {
|
||||
for (var selector in munge.files[file].parents) {
|
||||
for (var xml_child in munge.files[file].parents[selector]) {
|
||||
var val = munge.files[file].parents[selector][xml_child];
|
||||
// if node not in base, add it to diff and base
|
||||
// else increment it's value in base without adding to diff
|
||||
var removed = exports.deep_remove(base, [file, selector, val]);
|
||||
if (removed) {
|
||||
exports.deep_add(zeroed, file, selector, val);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return zeroed;
|
||||
};
|
||||
|
||||
// For better readability where used
|
||||
exports.clone_munge = function clone_munge (munge) {
|
||||
return exports.increment_munge({}, munge);
|
||||
};
|
||||
Reference in New Issue
Block a user