function assertDirEqual(one, two){
var ones = readdir(one);
var twos = readdir(two);
assert.deepEqual(ones, twos);
ones.forEach(function(rel){
var file = read(resolve(one, rel));
var other = read(resolve(two, rel));
if (utf8(file) && utf8(other)) {
assert.equal(file.toString(), other.toString());
} else {
assert(equal(file, other));
}
});
}
Object.keys(template).forEach((key) => {
const dist = mustache.render(template[key], result);
const distDir = path.dirname(dist);
if (fs.statSync(key).isFile()) {
fse.ensureDirSync(distDir);
fs.writeFileSync(
dist,
mustache.render(
fs.readFileSync(key, 'utf-8'),
result
)
);
} else {
fse.ensureDirSync(distDir);
fse.copySync(key, dist);
readRecursive(dist).forEach((file) => {
const modFile = path.join(dist, file);
fs.writeFileSync(
mustache.render(modFile, result),
mustache.render(
fs.readFileSync(modFile, 'utf-8'),
result
),
'utf-8'
);
});
}
});
findJsFile() {
const files = readdir(this.options.root, (name, index, dir) => {
const fullname = path.join(dir, name);
// ignore all node_modules
if (fullname.indexOf('/node_modules/') >= 0) return false;
// ignore specified exclude directories or files
if (this._contains(fullname, this.options.exclude)) return false;
if (fs.statSync(fullname).isDirectory()) return true;
const extname = path.extname(name);
if (extname !== '.js' && extname !== '.jsx') return false;
return true;
});
const jsFiles = [];
const jsTestFiles = [];
files.forEach(file => {
file = path.join(this.options.root, file);
if (this._contains(file, this.options.test)) jsTestFiles.push(file);
else jsFiles.push(file);
});
debug('findJsFile jsFiles(%j), jsTestFiles(%j)', jsFiles, jsTestFiles);
return {
jsFiles, jsTestFiles,
};
}
processDynamicTemplates : function (callback) {
var _this = this,
dynamicTemplates = readdirSyncRecursive(Vars.paths.templates + 'dynamic/');
if(dynamicTemplates){
async.map(
dynamicTemplates,
function (filename, callback) {
File.mustacheReplacer(
Vars.paths.templates + 'dynamic/',
filename,
_this.paths.absolute,
null,
_this.component,
callback
);
},
function(err){
if(err){
return console.error(err);
}
callback();
}
);
}
},
return new Promise(async resolve => {
let files = read(path);
console.log('Loading data from: ', files);
this.data = [];
files.forEach(file => {
if(~file.indexOf('.js') || ~file.indexOf('.json')) {
this.data.push(require(path + '/' + file));
}
});
console.log('Populating collections: ', this.data.map(collection => collection.model));
for(var collection of this.data) {
let Model = mongoose.model(collection.model);
const documents = await Model.count({});
if(options.populateExisting || (!options.populateExisting && !documents)) {
console.log('Populating ' + collection.model + ' with ' + collection.data.length + ' entries');
for(let entry of collection.data) {
await Model.create(entry);
};
} else {
console.log('Model ' + collection.model + ' has ' + documents + ' existing entries, not populating');
}
};
console.log('Population Done!')
resolve();
});
.then(inputStat => {
isDir = inputStat.isDirectory();
if (isDir) {
return readdirRecursive(inputPath, onlyIDL).map(relativePath => path.resolve(inputPath, relativePath));
}
return [inputPath]; // get dir name
})
function findModules() {
// Find all of the JS files and strip the .js extension
return readdir(APP_DIRECTORY).filter(function(name) {
return name.substring(name.length - 3) === '.js';
}).map(function(name) {
return name.substring(0, name.length - 3);
});
}
const readDir = function(loc, filter) {
const files = {};
if (fs.existsSync(loc)) {
readdir(loc, filter).forEach(function(filename) {
files[filename] = helper.readFile(path.join(loc, filename));
});
}
return files;
};
function getJSFilesRecursively(dir) {
//console.log(readdirRecursive(dir));
return readdirRecursive(dir)
.filter(function (file) {
return file.endsWith('.spec.js');
});
}
const filesArray = (Array.isArray(files) ? files : [files]).map(filename => {
if (fs.lstatSync(filename).isDirectory()) {
return read(filename)
.filter(file => path.extname(file) === '.js')
.map(file => path.join(filename, file));
}
return filename;
});
let readDir = function (loc) {
let files = {};
if (fs.existsSync(loc)) {
_.each(readdir(loc), function (filename) {
files[filename] = helper.readFile(path.join(loc, filename));
});
}
return files;
};
var readDir = function (loc) {
var files = {};
if (fs.existsSync(loc)) {
_.each(readdir(loc), function (filename) {
var contents = readFile(loc + "/" + filename);
files[filename] = contents;
});
}
return files;
};
__getData = function() {
var fileList = scanDir(path.join(__dirname, '/../uploads/thumb')),
deferreds = [];
_.each(fileList, function(filename, index) {
deferreds.push(__getCoords('uploads/original/' + filename));
});
return when.all(deferreds);
}
processOptionalTemplates : function (callback) {
var _this = this,
dynamicTemplates = readdirSyncRecursive(Vars.paths.templates + 'optional/');
async.parallel(
[
function (callback) {
if(_this.component.jsName){
File.mustacheReplacer(
Vars.paths.templates + 'optional/',
'module.js',
_this.paths.absolute,
_this.component.jsName + '.js',
_this.component,
callback
);
}else{
callback();
}
},
function (callback) {
if (_this.component.phpName) {
File.mustacheReplacer(
Vars.paths.templates + 'optional/',
'generator.php',
_this.paths.absolute,
_this.component.phpName + '.php',
_this.component,
callback
);
} else {
callback();
}
}
],
function (err) {
if (err) {
return console.error(err);
}
callback();
}
);
},
loadModels(path) {
let files = read(path);
this.models = []
files.forEach(file => {
if(~file.indexOf('.js')) {
let model = require(path + '/' + file);
this.models.push((model.default || model).modelName);
}
});
console.log('Loaded models:', this.models);
}
export function readdir(
dirname: string,
includeDotfiles: boolean,
filter: ReaddirFilter,
) {
return readdirRecursive(
dirname,
filename =>
(includeDotfiles || filename[0] !== ".") && (!filter || filter(filename)),
);
}
return function (filePath, alias) {
return fsdr(filePath ? path.join(baseDir, filePath) : baseDir).reduce(function getCurrentDirectoryContents(arr, item) {
return item.indexOf(ext) >= 0 ?
arr.concat({
alias: slash(alias ? path.join(alias, item.substring(0, item.indexOf(ext))) : item.substring(0, item.indexOf(ext))),
path: slash(filePath ? path.join(filePath, item.substring(0, item.indexOf(ext))) : item.substring(0, item.indexOf(ext)))
})
: arr;
}, []);
}
function getModels (options) {
if (!options.driver) {
console.warn('DB_DRIVER environment variable not set, no database connection');
return {};
}
var basename = path.basename(module.filename);
var sequelize = new Sequelize(options.name, options.user, options.pass,{
host: options.host,
dialect: options.driver,
port: options.port,
define: {
createdAt: 'created_date',
updatedAt: 'updated_date',
underscored: true
},
logging: false
});
var db = {};
rread(__dirname)
.filter(function(file) {
file = path.basename(file);
return (file.slice(-3) === '.js') && (file !== basename);
})
.forEach(function(file) {
var model = sequelize['import'](file);
db[model.name] = model;
});
Object.keys(db).forEach(function(modelName) {
if (db[modelName].associate) {
db[modelName].associate(db);
}
});
db.sync = function (cb) {
db.sequelize.sync()
.then(function () {
cb(null);
})
.catch(cb);
};
db.sequelize = sequelize;
db.Sequelize = Sequelize;
return db;
}
it("validates all the libs", () => {
const loaderPath = "lib/loaders"
const loaderPaths = readDirRecursive(loaderPath)
const skipPrefix = "api/"
const loaders = loaderPaths
.filter(l => !l.startsWith("__"))
.filter(l => !l.startsWith(skipPrefix))
loaders.forEach(path => {
const value = require("../../../" + loaderPath + "/" + path)
expect([path, value.default]).toEqual([path, expect.any(Function)])
})
})
function getModulesNames() {
return readdir(PATH_TO_JS).filter(function(name) {
// if (name.indexOf('scripts/') === 0) {
// return false;
// }
//
// return name.substring(name.length - 3) === '.js';
return name.substring(name.length - 6) === 'app.js';
}).map(function(name) {
return name.substring(0, name.length - 3);
});
}
function getScriptNames() {
return readdir(PATH_TO_JS + '/scripts', function(name) {
return name.substring(name.length - 3) === '.js';
}).sort(function(a, b) {
if (a === 'config.js') {
return -1;
} else if (b === 'config.js') {
return 1;
} else {
return 0;
}
});
}
function getFilesRecursively (files, rootFile) {
if (fs.lstatSync(rootFile).isDirectory()) {
var nestedFiles = rfs(rootFile, function (file) {
return file !== 'node_modules'
})
nestedFiles = _.filter(nestedFiles, mdFilter)
nestedFiles = _.map(nestedFiles, function (file) {
return rootFile + '/' + file
})
return files.concat(nestedFiles)
} else {
return files.concat(rootFile)
}
}
extensionTypesDirs.forEach((extensionTypeDir) => {
var extTemplates = readDirRecursive(path.resolve(__dirname, `${templatesDir}/${extensionTypeDir}`));
extTemplates.forEach((extTemplate) => {
var srcFile = path.resolve(__dirname, `${extensionTypeDir}/${extTemplate}`);
var srcDir = path.dirname(srcFile);
var item = {
src: srcDir,
dist: path.basename(srcDir),
};
pkgEntries.push(item);
});
});
export function readdir(
dirname: string,
includeDotfiles: boolean,
filter: ReaddirFilter,
) {
return readdirRecursive(dirname, (filename, _index, currentDirectory) => {
const stat = fs.statSync(path.join(currentDirectory, filename));
if (stat.isDirectory()) return true;
return (
(includeDotfiles || filename[0] !== ".") && (!filter || filter(filename))
);
});
}
allExtensionTypes.forEach((extensionType) => {
var extTplDir = path.resolve(__dirname, `${tplDirectory}/${extensionType}`);
var templates = readDirRecursive(path.resolve(__dirname, `${tplDirectory}/${extensionType}`));
templates.forEach((file) => {
var dest = path.resolve(__dirname, `${extensionType}/${file}`);
var item = {
context: extTplDir,
from: file,
to: dest,
transform: tagTransformation,
};
renderTpls.push(item);
});
});
function _copyDir() {
let rawCopy = T.Path.resolve(tempPath, 'template');
T.fsa.mkdirSync(to);
T.fsa.copySync(rawCopy, to);
// 更新项目名称
_updateName(to);
let files = fsrr(rawCopy, f => f);
Array.isArray(files) &&
files.forEach(file => {
T.log.green(`√ '${T.Path.resolve(to, file)}' is Created`);
});
if (!isAutoInstall) return process.exit(1);
autoInstallPackages();
}
function config_loader(config_dir) {
var config = _.merge.apply({},
_.map(read_dir(config_dir), function(file) {
var y = yaml.safeLoad(
fs.readFileSync(
path.join(config_dir, file), 'utf-8'
)
);
if (typeof y !== 'object') {
raise_error("YAML in file " + config_dir + "/" + file + " is invalid");
}
return y;
})
);
return assert_lunchmenu_is_valid(config);
}
_findTemplates: function (templateDirectory) {
var findFiles = Promise.resolve(readDir(templateDirectory));
return findFiles
.then(function (files) {
return files.filter(this._isTemplateFile);
}.bind(this))
.then(function (templates) {
var sourceToDestination = {};
var subDirectory = this._getTemplateSubDirectory(templateDirectory);
for (var i = 0; i < templates.length; i++) {
/* @type {String} fileName */
var template = templates[i];
var source = this.templatePath(path.join(subDirectory, template));
sourceToDestination[source] = this.destinationPath(this._toDestinationPath(template));
}
return sourceToDestination;
}.bind(this));
},
function generatePackage() {
var pkgEntries = [];
// Include all files from the package directory
var pkgFiles = readDirRecursive(packageDirAbs);
pkgFiles.forEach((file) => {
var packageFile = path.resolve(packageDirAbs, file);
var item = {
src: packageFile,
};
pkgEntries.push(item);
});
// Add all extension types directories into the package
extensionTypesDirs.forEach((extensionTypeDir) => {
var extTemplates = readDirRecursive(path.resolve(__dirname, `${templatesDir}/${extensionTypeDir}`));
extTemplates.forEach((extTemplate) => {
var srcFile = path.resolve(__dirname, `${extensionTypeDir}/${extTemplate}`);
var srcDir = path.dirname(srcFile);
var item = {
src: srcDir,
dist: path.basename(srcDir),
};
pkgEntries.push(item);
});
});
// Complete the definition of the zip file
var outputFile = path.resolve(__dirname, `${releaseDir}/pkg_${definitions.EXTENSION_ALIAS}_v${definitions.RELEASE_VERSION}`);
var zipFile = {
entries: pkgEntries,
output: outputFile,
format: 'zip',
};
return new ZipFilesPlugin(zipFile);
}
extensionTypesDirs.forEach((extensionType) => {
var extZipDir = path.resolve(__dirname, `${tplDirectory}/${extensionType}`);
var templates = readDirRecursive(path.resolve(__dirname, `${tplDirectory}/${extensionType}`));
templates.forEach((tplFile) => {
var srcFile = path.resolve(__dirname, `${extensionType}/${tplFile}`);
var srcDir = path.dirname(srcFile);
var extname = path.extname(srcFile);
if (extname !== '.xml') return;
var manifestTplFile = `${extZipDir}/${tplFile}`;
var extensionTplDir = path.dirname(manifestTplFile);
var parts = extensionTplDir.split('/');
var extElement = parts.pop();
var renamedExtElement = extElement;
if (renamedExtElement === 'component') {
renamedExtElement = definitions.EXTENSION_ALIAS;
} else if (renamedExtElement === 'file') {
renamedExtElement = 'cli';
}
var outputFile = path.resolve(__dirname, `${releaseDir}/${renamedExtElement}_v${definitions.RELEASE_VERSION}`);
var zipFile = {
entries: [
{
src: srcDir,
dist: extElement,
},
],
output: outputFile,
format: 'zip',
};
var itemZip = new ZipFilesPlugin(zipFile);
zipPlugins.push(itemZip);
});
});