mirror of
https://github.com/TryGhost/Ghost.git
synced 2024-11-11 00:37:55 +03:00
714 lines
25 KiB
JavaScript
714 lines
25 KiB
JavaScript
var path = require('path'),
|
|
when = require('when'),
|
|
semver = require("semver"),
|
|
fs = require("fs"),
|
|
path = require("path"),
|
|
_ = require('underscore'),
|
|
spawn = require("child_process").spawn,
|
|
buildDirectory = path.resolve(process.cwd(), '.build'),
|
|
distDirectory = path.resolve(process.cwd(), '.dist'),
|
|
configLoader = require('./core/config-loader.js'),
|
|
|
|
configureGrunt = function (grunt) {
|
|
|
|
// load all grunt tasks
|
|
require('matchdep').filterDev('grunt-*').forEach(grunt.loadNpmTasks);
|
|
|
|
var cfg = {
|
|
// Common paths to be used by tasks
|
|
paths: {
|
|
adminAssets: './core/client/assets',
|
|
build: buildDirectory,
|
|
nightlyBuild: path.join(buildDirectory, 'nightly'),
|
|
weeklyBuild: path.join(buildDirectory, 'weekly'),
|
|
buildBuild: path.join(buildDirectory, 'build'),
|
|
dist: distDirectory,
|
|
nightlyDist: path.join(distDirectory, 'nightly'),
|
|
weeklyDist: path.join(distDirectory, 'weekly'),
|
|
buildDist: path.join(distDirectory, 'build')
|
|
},
|
|
buildType: 'Build',
|
|
pkg: grunt.file.readJSON('package.json'),
|
|
|
|
// Watch files and livereload in the browser during development
|
|
watch: {
|
|
handlebars: {
|
|
files: ['core/client/tpl/**/*.hbs'],
|
|
tasks: ['handlebars']
|
|
},
|
|
sass: {
|
|
files: ['<%= paths.adminAssets %>/sass/**/*'],
|
|
tasks: ['sass:admin']
|
|
},
|
|
livereload: {
|
|
files: [
|
|
// Theme CSS
|
|
'content/themes/casper/css/*.css',
|
|
// Theme JS
|
|
'content/themes/casper/js/*.js',
|
|
// Admin CSS
|
|
'<%= paths.adminAssets %>/css/*.css',
|
|
// Admin JS
|
|
'core/client/*.js',
|
|
'core/client/helpers/*.js',
|
|
'core/client/models/*.js',
|
|
'core/client/tpl/*.js',
|
|
'core/client/views/*.js'
|
|
],
|
|
options: {
|
|
livereload: true
|
|
}
|
|
},
|
|
express: {
|
|
// Restart any time client or server js files change
|
|
files: ['core/server/**/*.js'],
|
|
tasks: ['express:dev'],
|
|
options: {
|
|
//Without this option specified express won't be reloaded
|
|
nospawn: true
|
|
}
|
|
}
|
|
},
|
|
|
|
// Start our server in development
|
|
express: {
|
|
options: {
|
|
script: "index.js"
|
|
},
|
|
|
|
dev: {
|
|
options: {
|
|
//output: "Express server listening on address:.*$"
|
|
}
|
|
},
|
|
test: {
|
|
options: {
|
|
node_env: 'testing'
|
|
}
|
|
}
|
|
},
|
|
|
|
// Open the site in a browser
|
|
open: {
|
|
server: {
|
|
// TODO: Load this port from config?
|
|
path: 'http://127.0.0.1:2368'
|
|
}
|
|
},
|
|
|
|
// JSLint all the things!
|
|
jslint: {
|
|
server: {
|
|
directives: {
|
|
// node environment
|
|
node: true,
|
|
// browser environment
|
|
browser: false,
|
|
// allow dangling underscores in var names
|
|
nomen: true,
|
|
// allow to do statements
|
|
todo: true,
|
|
// allow unused parameters
|
|
unparam: true,
|
|
// don't require use strict pragma
|
|
sloppy: true
|
|
},
|
|
files: {
|
|
src: [
|
|
"*.js",
|
|
"core/*.js",
|
|
"core/server/**/*.js"
|
|
]
|
|
}
|
|
},
|
|
client: {
|
|
directives: {
|
|
// node environment
|
|
node: false,
|
|
// browser environment
|
|
browser: true,
|
|
// allow dangling underscores in var names
|
|
nomen: true,
|
|
// allow to do statements
|
|
todo: true,
|
|
// allow unused parameters
|
|
unparam: true
|
|
},
|
|
files: {
|
|
src: "core/client/**/*.js"
|
|
},
|
|
exclude: [
|
|
"core/client/assets/**/*.js",
|
|
"core/client/tpl/**/*.js"
|
|
]
|
|
},
|
|
shared: {
|
|
directives: {
|
|
// node environment
|
|
node: true,
|
|
// browser environment
|
|
browser: false,
|
|
// allow dangling underscores in var names
|
|
nomen: true,
|
|
// allow to do statements
|
|
todo: true,
|
|
// allow unused parameters
|
|
unparam: true,
|
|
// don't require use strict pragma
|
|
sloppy: true
|
|
},
|
|
files: {
|
|
src: [
|
|
"core/shared/**/*.js"
|
|
]
|
|
},
|
|
exclude: [
|
|
"core/shared/vendor/**/*.js"
|
|
]
|
|
}
|
|
},
|
|
|
|
mochacli: {
|
|
options: {
|
|
ui: "bdd",
|
|
reporter: "spec"
|
|
},
|
|
|
|
all: {
|
|
src: ['core/test/unit/**/*_spec.js']
|
|
},
|
|
|
|
api: {
|
|
src: ['core/test/unit/**/api*_spec.js']
|
|
},
|
|
|
|
client: {
|
|
src: ['core/test/unit/**/client*_spec.js']
|
|
},
|
|
|
|
server: {
|
|
src: ['core/test/unit/**/server*_spec.js']
|
|
},
|
|
|
|
shared: {
|
|
src: ['core/test/unit/**/shared*_spec.js']
|
|
},
|
|
|
|
perm: {
|
|
src: ['core/test/unit/**/permissions_spec.js']
|
|
},
|
|
|
|
migrate: {
|
|
src: [
|
|
'core/test/unit/**/export_spec.js',
|
|
'core/test/unit/**/import_spec.js'
|
|
]
|
|
}
|
|
},
|
|
|
|
// Compile all the SASS!
|
|
sass: {
|
|
admin: {
|
|
files: {
|
|
'<%= paths.adminAssets %>/css/screen.css': '<%= paths.adminAssets %>/sass/screen.scss'
|
|
}
|
|
}
|
|
},
|
|
|
|
shell: {
|
|
bourbon: {
|
|
command: 'bourbon install --path <%= paths.adminAssets %>/sass/modules/'
|
|
}
|
|
},
|
|
|
|
handlebars: {
|
|
core: {
|
|
options: {
|
|
namespace: "JST",
|
|
processName: function (filename) {
|
|
filename = filename.replace('core/client/tpl/', '');
|
|
return filename.replace('.hbs', '');
|
|
}
|
|
},
|
|
files: {
|
|
"core/client/tpl/hbs-tpl.js": "core/client/tpl/**/*.hbs"
|
|
}
|
|
}
|
|
},
|
|
|
|
groc: {
|
|
docs: {
|
|
options: {
|
|
"out": "./docs/",
|
|
"glob": [
|
|
"README.md",
|
|
"config.js",
|
|
"index.js",
|
|
"core/ghost.js",
|
|
"core/server/**/*.js",
|
|
"core/shared/**/*.js",
|
|
"core/client/**/*.js"
|
|
],
|
|
"except": [
|
|
"!core/**/vendor/**/*.js",
|
|
"!core/client/tpl/**/*.js"
|
|
]
|
|
}
|
|
}
|
|
},
|
|
|
|
copy: {
|
|
nightly: {
|
|
files: [{
|
|
expand: true,
|
|
src: [
|
|
'**',
|
|
'!node_modules/**',
|
|
'!core/server/data/*.db',
|
|
'!.sass*',
|
|
'!.af*',
|
|
'!.git*',
|
|
'!.groc*',
|
|
'!.travis.yml'
|
|
],
|
|
dest: "<%= paths.nightlyBuild %>/<%= pkg.version %>/"
|
|
}]
|
|
},
|
|
weekly: {
|
|
files: [{
|
|
expand: true,
|
|
src: [
|
|
'**',
|
|
'!node_modules/**',
|
|
'!core/server/data/*.db',
|
|
'!.sass*',
|
|
'!.af*',
|
|
'!.git*',
|
|
'!.groc*',
|
|
'!.travis.yml'
|
|
],
|
|
dest: "<%= paths.weeklyBuild %>/<%= pkg.version %>/"
|
|
}]
|
|
},
|
|
build: {
|
|
files: [{
|
|
expand: true,
|
|
src: [
|
|
'**',
|
|
'!node_modules/**',
|
|
'!core/server/data/*.db',
|
|
'!.sass*',
|
|
'!.af*',
|
|
'!.git*',
|
|
'!.groc*',
|
|
'!.iml*',
|
|
'!.travis.yml'
|
|
],
|
|
dest: "<%= paths.buildBuild %>/"
|
|
}]
|
|
}
|
|
},
|
|
|
|
compress: {
|
|
nightly: {
|
|
options: {
|
|
archive: "<%= paths.nightlyDist %>/Ghost-Nightly-<%= pkg.version %>.zip"
|
|
},
|
|
expand: true,
|
|
cwd: "<%= paths.nightlyBuild %>/<%= pkg.version %>/",
|
|
src: ["**"]
|
|
},
|
|
weekly: {
|
|
options: {
|
|
archive: "<%= paths.weeklyDist %>/Ghost-Weekly-<%= pkg.version %>.zip"
|
|
},
|
|
expand: true,
|
|
cwd: "<%= paths.weeklyBuild %>/<%= pkg.version %>/",
|
|
src: ["**"]
|
|
},
|
|
build: {
|
|
options: {
|
|
archive: "<%= paths.buildDist %>/Ghost-Build.zip"
|
|
},
|
|
expand: true,
|
|
cwd: "<%= paths.buildBuild %>/",
|
|
src: ["**"]
|
|
}
|
|
},
|
|
|
|
bump: {
|
|
options: {
|
|
tagName: '%VERSION%',
|
|
commitMessage: '<%= buildType %> Release %VERSION%',
|
|
tagMessage: '<%= buildType %> Release %VERSION%',
|
|
pushTo: "origin build"
|
|
}
|
|
}
|
|
};
|
|
|
|
grunt.initConfig(cfg);
|
|
|
|
grunt.registerTask('setTestEnv', function () {
|
|
// Use 'testing' Ghost config; unless we are running on travis (then show queries for debugging)
|
|
process.env.NODE_ENV = process.env.TRAVIS ? 'travis' : 'testing';
|
|
});
|
|
|
|
grunt.registerTask('loadConfig', function () {
|
|
var done = this.async();
|
|
configLoader.loadConfig().then(function () {
|
|
done();
|
|
});
|
|
});
|
|
|
|
// Update the package information after changes
|
|
grunt.registerTask('updateCurrentPackageInfo', function () {
|
|
cfg.pkg = grunt.file.readJSON('package.json');
|
|
});
|
|
|
|
grunt.registerTask('setCurrentBuildType', function (type) {
|
|
cfg.buildType = type;
|
|
});
|
|
|
|
grunt.registerTask('spawn-casperjs', function () {
|
|
var done = this.async(),
|
|
options = ['host', 'noPort', 'port', 'email', 'password'],
|
|
args = ['test', 'admin/', 'frontend/', '--includes=base.js', '--direct', '--log-level=debug', '--port=2369'];
|
|
|
|
// Forward parameters from grunt to casperjs
|
|
_.each(options, function processOption(option) {
|
|
if (grunt.option(option)) {
|
|
args.push('--' + option + '=' + grunt.option(option));
|
|
}
|
|
});
|
|
|
|
grunt.util.spawn({
|
|
cmd: 'casperjs',
|
|
args: args,
|
|
opts: {
|
|
cwd: path.resolve('core/test/functional'),
|
|
stdio: 'inherit'
|
|
}
|
|
}, function (error, result, code) {
|
|
if (error) {
|
|
grunt.fail.fatal(result.stdout);
|
|
}
|
|
grunt.log.writeln(result.stdout);
|
|
done();
|
|
});
|
|
});
|
|
|
|
/* Generate Changelog
|
|
* - Pulls changelog from git, excluding merges.
|
|
* - Uses first line of commit message. Includes committer name.
|
|
*/
|
|
grunt.registerTask("changelog", "Generate changelog from Git", function () {
|
|
// TODO: Break the contents of this task out into a separate module,
|
|
// put on npm. (@cgiffard)
|
|
|
|
var done = this.async();
|
|
|
|
function git(args, callback, depth) {
|
|
depth = depth || 0;
|
|
|
|
if (!depth) {
|
|
grunt.log.writeln("git " + args.join(" "));
|
|
}
|
|
|
|
var buffer = [];
|
|
spawn("git", args, {
|
|
// We can reasonably assume the gruntfile will be in the root of the repo.
|
|
cwd : __dirname,
|
|
|
|
stdio : ["ignore", "pipe", process.stderr]
|
|
|
|
}).on("exit", function (code) {
|
|
|
|
// Process exited correctly but we got no output.
|
|
// Spawn again, but make sure we don't spiral out of control.
|
|
// Hack to work around an apparent node bug.
|
|
//
|
|
// Frustratingly, it's impossible to distinguish this
|
|
// bug from a genuine empty log.
|
|
|
|
if (!buffer.length && code === 0 && depth < 20) {
|
|
return setImmediate(function () {
|
|
git(args, callback, depth ? depth + 1 : 1);
|
|
});
|
|
}
|
|
|
|
if (code === 0) {
|
|
return callback(buffer.join(""));
|
|
}
|
|
|
|
// We failed. Git returned a non-standard exit code.
|
|
grunt.log.error('Git returned a non-zero exit code.');
|
|
done(false);
|
|
|
|
// Push returned data into the buffer
|
|
}).stdout.on("data", buffer.push.bind(buffer));
|
|
}
|
|
|
|
// Crazy function for getting around inconsistencies in tagging
|
|
function sortTags(a, b) {
|
|
a = a.tag;
|
|
b = b.tag;
|
|
|
|
// NOTE: Accounting for different tagging method for
|
|
// 0.2.1 and up.
|
|
|
|
// If we didn't have this issue I'd just pass rcompare
|
|
// into sort directly. Could be something to think about
|
|
// in future.
|
|
|
|
if (semver.rcompare(a, "0.2.0") < 0 ||
|
|
semver.rcompare(b, "0.2.0") < 0) {
|
|
|
|
return semver.rcompare(a, b);
|
|
}
|
|
|
|
a = a.split("-");
|
|
b = b.split("-");
|
|
|
|
if (semver.rcompare(a[0], b[0]) !== 0) {
|
|
return semver.rcompare(a[0], b[0]);
|
|
}
|
|
|
|
// Using this janky looking integerising-method
|
|
// because it's faster and doesn't result in NaN, which
|
|
// breaks sorting
|
|
/*jslint bitwise: true */
|
|
return (+b[1] | 0) - (+a[1] | 0);
|
|
}
|
|
|
|
// Gets tags in master branch, sorts them with semver,
|
|
function getTags(callback) {
|
|
git(["show-ref", "--tags"], function (results) {
|
|
results = results
|
|
.split(/\n+/)
|
|
.filter(function (tag) {
|
|
return tag.length && tag.match(/\/\d+\.\d+/);
|
|
})
|
|
.map(function (tag) {
|
|
return {
|
|
"tag": tag.split(/tags\//).pop().trim(),
|
|
"ref": tag.split(/\s+/).shift().trim()
|
|
};
|
|
})
|
|
.sort(sortTags);
|
|
|
|
callback(results);
|
|
});
|
|
}
|
|
|
|
// Parses log to extract commit data.
|
|
function parseLog(data) {
|
|
var commits = [],
|
|
commitRegex =
|
|
new RegExp(
|
|
"\\n*[|\\*\\s]*commit\\s+([a-f0-9]+)" +
|
|
"\\n[|\\*\\s]*Author:\\s+([^<\\n]+)<([^>\\n]+)>" +
|
|
"\\n[|\\*\\s]*Date:\\s+([^\\n]+)" +
|
|
"\\n+[|\\*\\s]*[ ]{4}([^\\n]+)",
|
|
"ig"
|
|
);
|
|
|
|
// Using String.prototype.replace as a kind of poor-man's substitute
|
|
// for a streaming parser.
|
|
data.replace(
|
|
commitRegex,
|
|
function (wholeCommit, hash, author, email, date, message) {
|
|
|
|
// The author name and commit message may have trailing space.
|
|
author = author.trim();
|
|
message = message.trim();
|
|
|
|
// Reformat date to make it parse-able by JS
|
|
date =
|
|
date.replace(
|
|
/^(\w+)\s(\w+)\s(\d+)\s([\d\:]+)\s(\d+)\s([\+\-\d]+)$/,
|
|
"$1, $2 $3 $5 $4 $6"
|
|
);
|
|
|
|
commits.push({
|
|
"hash": hash,
|
|
"author": author,
|
|
"email": email,
|
|
"date": date,
|
|
"parsedDate": new Date(Date.parse(date)),
|
|
"message": message
|
|
});
|
|
|
|
return null;
|
|
}
|
|
);
|
|
|
|
return commits;
|
|
}
|
|
|
|
// Gets git log for specified range.
|
|
function getLog(to, from, callback) {
|
|
var range = from && to ? from + ".." + to : "",
|
|
args = [ "log", "master", "--no-color", "--no-merges", "--graph" ];
|
|
|
|
if (range) {
|
|
args.push(range);
|
|
}
|
|
|
|
git(args, function (data) {
|
|
callback(parseLog(data));
|
|
});
|
|
}
|
|
|
|
// Run the job
|
|
getTags(function (tags) {
|
|
var logPath = path.join(__dirname, "CHANGELOG.md"),
|
|
log = fs.createWriteStream(logPath),
|
|
commitCache = {};
|
|
|
|
function processTag(tag, callback) {
|
|
var buffer = "",
|
|
peek = tag[1];
|
|
|
|
tag = tag[0];
|
|
|
|
getLog(tag.tag, peek.tag, function (commits) {
|
|
|
|
// Use the comparison with HEAD to remove commits which
|
|
// haven't been included in a build/release yet.
|
|
|
|
if (tag.tag === "HEAD") {
|
|
commits.forEach(function (commit) {
|
|
commitCache[commit.hash] = true;
|
|
});
|
|
|
|
return callback("");
|
|
}
|
|
|
|
buffer += "## Release " + tag.tag + "\n";
|
|
|
|
commits = commits
|
|
.filter(function (commit) {
|
|
|
|
// Get rid of jenkins' release tagging commits
|
|
// Remove commits we've already spat out
|
|
return (
|
|
commit.author !== "TryGhost-Jenkins" &&
|
|
!commitCache[commit.hash]
|
|
);
|
|
})
|
|
.map(function (commit) {
|
|
buffer += "\n* " + commit.message + " (_" + commit.author + "_)";
|
|
commitCache[commit.hash] = true;
|
|
});
|
|
|
|
if (!commits.length) {
|
|
buffer += "\nNo changes were made in this build.\n";
|
|
}
|
|
|
|
callback(buffer + "\n");
|
|
});
|
|
}
|
|
|
|
// Get two weeks' worth of tags
|
|
tags.unshift({"tag": "HEAD"});
|
|
|
|
tags =
|
|
tags
|
|
.slice(0, 14)
|
|
.map(function (tag, index) {
|
|
return [
|
|
tag,
|
|
tags[index + 1] || tags[index]
|
|
];
|
|
});
|
|
|
|
log.write("# Ghost Changelog\n\n");
|
|
log.write("_Showing " + tags.length + " releases._\n");
|
|
|
|
when.reduce(tags,
|
|
function (prev, tag, idx) {
|
|
return when.promise(function (resolve) {
|
|
processTag(tag, function (releaseData) {
|
|
resolve(prev + "\n" + releaseData);
|
|
});
|
|
});
|
|
}, "")
|
|
.then(function (reducedChangelog) {
|
|
log.write(reducedChangelog);
|
|
log.close();
|
|
done(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
/* Nightly builds
|
|
* - Do our standard build steps (sass, handlebars, etc)
|
|
* - Bump patch version in package.json, commit, tag and push
|
|
* - Generate changelog for the past 14 releases
|
|
* - Copy files to build-folder/#/#{version} directory
|
|
* - Clean out unnecessary files (travis, .git*, .af*, .groc*)
|
|
* - Zip files in build folder to dist-folder/#{version} directory
|
|
*/
|
|
grunt.registerTask("nightly", [
|
|
"setCurrentBuildType:Nightly",
|
|
"shell:bourbon",
|
|
"sass:admin",
|
|
"handlebars",
|
|
"bump:build",
|
|
"updateCurrentPackageInfo",
|
|
"changelog",
|
|
"copy:nightly",
|
|
"compress:nightly"
|
|
]);
|
|
|
|
grunt.registerTask("weekly", [
|
|
"setCurrentBuildType:Weekly",
|
|
"shell:bourbon",
|
|
"sass:admin",
|
|
"handlebars",
|
|
"bump:build",
|
|
"updateCurrentPackageInfo",
|
|
"changelog",
|
|
"copy:weekly",
|
|
"compress:weekly"
|
|
]);
|
|
|
|
grunt.registerTask("build", [
|
|
"shell:bourbon",
|
|
"sass:admin",
|
|
"handlebars",
|
|
"changelog",
|
|
"copy:build",
|
|
"compress:build"
|
|
]);
|
|
|
|
// Dev Mode; watch files and restart server on changes
|
|
grunt.registerTask("dev", [
|
|
"default",
|
|
"express:dev",
|
|
"open",
|
|
"watch"
|
|
]);
|
|
|
|
// Prepare the project for development
|
|
// TODO: Git submodule init/update (https://github.com/jaubourg/grunt-update-submodules)?
|
|
grunt.registerTask("init", ["shell:bourbon", "sass:admin", 'handlebars']);
|
|
|
|
// Run unit tests
|
|
grunt.registerTask("test-unit", ['setTestEnv', 'loadConfig', "mochacli:all"]);
|
|
|
|
// Run casperjs tests only
|
|
grunt.registerTask('test-functional', ['setTestEnv', 'express:test', 'spawn-casperjs']);
|
|
|
|
// Run tests and lint code
|
|
grunt.registerTask("validate", ["jslint", "test-unit", "test-functional"]);
|
|
|
|
// Generate Docs
|
|
grunt.registerTask("docs", ["groc"]);
|
|
|
|
// When you just say "grunt"
|
|
grunt.registerTask("default", ['sass:admin', 'handlebars']);
|
|
};
|
|
|
|
module.exports = configureGrunt;
|