gulp.task('build', function (done) {
function isRaw(file, data) {
return data.raw;
}
function notRaw(file, data) {
return !data.raw;
}
Metalsmith(__dirname)
.source('src')
.destination('dist')
.clean(true)
.metadata({
site: siteInfo
})
.use(i18n({
ignore: '**/readme*.md',
locales: locales
}))
.use(raw())
.use(webpack(require('./webpack.config.js')))
.use(branch(isRaw)
.use(layouts({
engine: 'handlebars',
pattern: '**/*.html',
default: 'example.hbs',
directory: 'layouts/raw',
helpers: {
indent: helpers.indent
}
})))
.use(branch(notRaw)
.use(layouts({
engine: 'handlebars',
pattern: '**/*.html',
default: 'example.hbs',
directory: 'layouts',
partials: 'layouts/raw',
helpers: {
lunrIndex: helpers.lunrIndex,
indent: helpers.indent,
escape: helpers.escape
}
})))
.use(assets({
ignores: ['js', 'css'],
source: 'assets'
}))
.use(debug())
.build(function (err, files) {
if (err) {
done(err);
return;
}
connect.changed(Object.keys(files));
done();
});
});
// build command that runs metalsmith
function build(mode, callback) {
Metalsmith(__dirname)
.source('./content')
.destination('./build')
.use(json({
"source_path": "./json/"
}))
.use(collections({
"projects": {},
"updates": {},
}))
.use(permalinks({
pattern: ':title',
relative: false
}))
// .use(algolia())
.use(mingo())
.use(inplace('nunjucks'))
.use(layouts('nunjucks'))
.use(when((mode === 'dev'), // run the watch plugin only in dev mode
watch({
paths: {
"${source}/**/*.*": true,
"layouts/**/*": "**/*"
},
livereload: false,
})
))
.build(function(err){
if (err){
throw err;
}
callback();
});
}
gulp.task('smith', ['templates'], function smithTask(done) {
var filterRenderable = $.filter('*.md', { restore: true });
var templatePath = path.join(paths.output, 'templates');
gulp.src(path.join(paths.content, '**/*'))
.pipe($.plumber())
.pipe(filterRenderable)
.pipe($.frontMatter())
.pipe(through.obj(function (file, enc, callback) {
if (!file.frontMatter) {
callback();
}
_.assign(file, file.frontMatter);
delete file.frontMatter;
callback(null, file);
}))
.pipe($.marked({ gfm: true }))
.pipe(gulpsmith()
.use(layouts({
engine: 'handlebars',
directory: templatePath
}))
)
.pipe(filterRenderable.restore)
.pipe($.plumber.stop())
.pipe(gulp.dest(paths.output))
.on('finish', function cleanForge() {
gulp.src(templatePath, { read: false })
.pipe(vinylPaths(del));
done();
});
});
let createDocs = function(version) {
Metalsmith(path.join(__dirname, 'dcos-docs'))
.source(version)
.use(markdown({
smartypants: true,
gfm: true,
tables: true
}))
.use(nav)
.use(layouts({
pattern: '**/*.html',
engine: 'jade',
directory: path.join('..', 'layouts'),
default: 'docs.jade'
}))
.use(jade({
pretty: true
}))
.clean(false)
.use(each(updatePaths))
.destination(path.join('..', 'build', 'docs', version))
.build((err) => {
if (err) throw err
})
}
/*---------------------------------------------------------------------*/
/* Setup templating and tempating parts
/*---------------------------------------------------------------------*/
function templates(ms, options) {
ms.use(msLayouts({
engine: 'handlebars',
directory: "./src/layouts",
partials: "./src/layouts/partial"
}))
}
module.exports = function (locations) {
locations = locations || {}
locations.base = locations.base || __dirname
locations.source = locations.source || '../content/paginas'
locations.destination = locations.destination || '../site/'
return Metalsmith(locations.base)
.clean(true)
.source(locations.source)
.destination(locations.destination)
.concurrency(1000)
.metadata(META)
.use(ignore('.DS_Store'))
.use(includes({ prefix: '!! incluye' }))
.use(sections())
.use(markdown())
.use(directives(processors))
.use(partial({ directory: './templates/partials', engine: 'handlebars' }))
.use(layouts({
pattern: '**/*.html',
default: 'page.html', directory: 'templates', engine: 'handlebars' }))
.use(permalinks({ relative: false }))
.use(concat({ 'stylesheets/portada.css': { 'base': './stylesheets', 'files': ['portada.css', 'sections.css'] },
'stylesheets/all.css': { 'base': './stylesheets', 'files': ['reset.css', 'fonts.css', 'sections.css', 'page.css', 'article.css'] }
}))
.use(assets({ source: './assets', destination: '.' }))
.use(portada())
.use(redirects({ file: 'redirects.txt' }))
}
/**
* Build documentation pages through `metalsmith`
* @return {stream}
*/
export default function pages() {
return metalsmith(process.cwd())
.source('./src')
.clean(false)
.use(msIgnore(ignoreDirectories))
.use(msPermalinks())
.use(msMoveUp({
pattern: 'pages/**/*',
}))
.use(msRootpath())
.use(msInPlace({
engine: 'nunjucks',
}))
.use(msLayouts({
engine: 'nunjucks',
directory: './src/templates',
default: 'default.html',
}))
.destination('./docs')
.build((err) => {
if (err) {
throw err;
} else {
reload();
}
});
}
function buildCountryPages(questions, countries) {
/*
Use Metalsmith to build the country pages.
*/
const templatePath = path.join(__dirname, './views/')
const baseUrl = '/questionnaires/'
Metalsmith(__dirname) // eslint-disable-line new-cap
.metadata({
currentTime: Date.now(),
questions,
countries,
baseUrl
})
.source('./src')
.destination('../../_build-questionnaires')
.clean(true)
.use(jsonToFiles({ use_metadata: true }))
.use(layouts({
engine: 'handlebars',
directory: templatePath
}))
.build((err) => {
if (err) throw err
})
}
function main(callback) {
var smith = new Metalsmith('.')
.source(srcDir)
.destination(destDir)
.concurrency(25)
.metadata({
olVersion: pkg.version
})
.use(augmentExamples)
.use(createIndex)
.use(templates({
engine: 'handlebars',
directory: templatesDir,
helpers: {
md: function(str) {
return new handlebars.SafeString(marked(str));
},
indent: function(text, options) {
if (!text) {
return text;
}
var count = options.hash.spaces || 2;
var spaces = new Array(count + 1).join(' ');
return text.split('\n').map(function(line) {
return line ? spaces + line : '';
}).join('\n');
}
}
}))
.build(function(err) {
callback(err);
});
return smith;
}
exports.init = (args) => {
return Metalsmith(__dirname)
.metadata({
injectScript: args.injectScript || '',
googleAnalyticsKey: 'UA-58254103-1',
maquetteVersion: require('../package.json').version,
// defaults, can be overridden per page
liveEditors: false,
liveEditorsVelocity: false,
liveEditorsCss: false,
workbench: false
})
.source('source')
.destination('./build/website')
.clean(true)
.use(inPlace({
engineOptions: {
root: __dirname
}
}))
.use(markdown())
.use(layouts({
engine: 'ejs',
directory: 'layouts',
engineOptions: {
root: __dirname
}
}))
.use(postcss({
plugins: {
'precss': {}
}
}));
};
gulp.task('metalsmith', function() {
return gulp.src('content/**')
.pipe(metalsmith({
use: [layouts({engine: 'swig'}), testplugin],
json: true
}
))
.pipe(gulp.dest('build'));
});
gulp.task('content', function () {
console.log('... building content ...');
// TODO : could just source content here
return gulp.src(['./src/**', '!./src/io/**'])
//.pipe(f)
.pipe(metalsmith({
// set Metalsmith's root directory, for example for locating templates, defaults to CWD
root: __dirname,
// files to exclude from the build
ignore: [],
// read frontmatter, defaults to true
frontmatter: true,
// Metalsmith plugins to use
use: [
//lens(),
metadata({
site: 'meta.json',
settings: 'settings.json'
}),
date({key: 'dateBuilt'}),
//gulpIgnore.include(condition),
markdown(),
collections({
articles: {
pattern: './content/articles/*.md',
sortBy: 'date',
reverse: 'True'
}
, news: {
pattern: './content/news/*.md',
sortBy: 'date',
reverse: 'True'
}
, books: {
pattern: './content/books/*.md',
sortBy: 'date',
reverse: 'True'
}
}),
permalinks({
pattern: ':collections:title'
}),
feed({collection: 'articles'}),
layouts({
engine: 'jade',
moment: moment
}),
beautify()
],
// Initial Metalsmith metadata:
metadata: {
site_title: 'Sample static site'
}
}))
.pipe(gulp.dest(__.pub));
});
gulp.task('f', function () {
const f = filter(['*', '!src/content']);
return gulp
.src(__.sass_src)
.pipe(f)
.pipe(metalsmith({
// set Metalsmith's root directory, for example for locating templates, defaults to CWD
root: __dirname,
// files to exclude from the build
ignore: [
__.build_src + '/*.tmp',
'io/*'
],
// read frontmatter, defaults to true
frontmatter: true,
// Metalsmith plugins to use
use: [
metadata({
site: 'meta.json',
settings: 'settings.json'
}),
//gulpIgnore.include(condition),
markdown(),
collections({
articles: {
pattern: './content/articles/*.md',
sortBy: 'date',
reverse: 'True'
}
, news: {
pattern: './content/news/*.md',
sortBy: 'date',
reverse: 'True'
}
, books: {
pattern: './content/books/*.md',
sortBy: 'date',
reverse: 'True'
}
}),
permalinks({
pattern: ':collections:title'
}),
feed({collection: 'articles'}),
layouts({
engine: 'jade',
moment: moment
}),
beautify()
],
// Initial Metalsmith metadata:
metadata: {
site_title: 'Sample static site'
}
}))
.resume();
});
module.exports = () => {
Metalsmith(__dirname)
.metadata(metadata)
.source('./src')
.destination('./build')
.clean(false)
.ignore([
'.DS_Store'
])
.use(DateInFileName({
override: true
}))
.use(Shortcodes({
files: ['.html'],
shortcodes: require('./shortcodes')
}))
.use(Collections({
pattern: ['writing/*.html'],
settings: {
sortBy: 'date',
reverse: true
}
}))
.use(Moment(['date']))
.use(SyntaxHighlighting())
.use(Slug({
pattern: ['*.html'],
renameFiles: true,
lower: true
}))
.use(Feed({
collection: 'writing',
limit: false,
destination: 'feed.xml',
preprocess: file => ({
...file,
url: `${metadata.site.url}/${file.collection}/${file.slug}`
})
}))
.use(Layouts({
engine: 'ejs',
directory: 'layouts',
default: 'index.ejs',
pattern: ['**/*.html', '*.html']
}))
.use(Debug())
.build(err => {
if (err) {
console.log('❌ Build failed:', err)
}
else {
console.log('✅ Build complete.')
}
})
}
authors: function(done) {
if (lang === 'ja') {
done();
return;
}
metalsmith(__dirname + '/../')
.clean(false)
.source('./blog/authors/')
.metadata(require('../config.js')(lang, isStaging))
.destination('./out_en/blog/')
.use(require('./helpers')())
.use(branch('*.markdown')
.use(markdown({
gfm: true,
tables: true,
breaks: false,
pedantic: false,
sanitize: false,
smartLists: true,
smartypants: true
}))
.use(permalinks({
pattern: ':id'
}))
)
.use(function(files, metalsmith, done) {
for (var path in files) {
files[path].title = files[path].name;
}
done();
})
.use(layouts({
engine: 'eco',
directory: './src/layouts/',
default: 'author.html.eco'
}))
.build(function(error) {
if (error) {
gutil.log('ERROR: ' + error);
}
done();
});
},
gulp.task('metalsmith-docs', function() {
return gulp.src([
config.assets + 'components/**/*.swig',
config.assets + 'docs/**/*.md',
config.assets + 'data/**/*.json'
])
.pipe($.plumber({errorHandler: errorAlert}))
.pipe($.metalsmith({
use: [
markdown({ langPrefix: 'language-' }),
collections(config.metalsmith.plugins.collections),
function(files, metalsmith, done){
for (var file in files) {
if (files[file].collection == 'atoms' || files[file].collection == 'molecules' || files[file].collection == 'organisms') {
delete files[file];
}
if (path.extname(file) === '.json') {
var key = path.basename(file, '.json');
metadatas[key] = JSON.parse(files[file].contents.toString());
delete files[file];
}
}
done();
},
define({
data: metadatas
}),
contentful({
accessToken : contentful_key
}),
layouts(config.metalsmith.plugins.layouts),
function(files, metalsmith, done){
// Clean dirty front-matter comment
for (var file in files) {
files[file].contents = new Buffer(files[file].contents.toString().replace(/---[\s\S]*?---/g, ''));
}
done();
},
permalinks(config.metalsmith.plugins.permalinks),
sitemap('http://hopitalrivierachablais.ch')
]
}))
.pipe(gulp.dest(config.metalsmith.dist));
});
module.exports = function build(callback){
// read playlists upon every build
var playlists = {};
config.collections.forEach(function(collection){
// playlists
var collectionFolder = [config.lessonRoot, config.sourceFolder, collection].join("/");
playlists[collection] = getPlaylists(collectionFolder);
});
// make it available in layout
defineOptions.playlists = playlists;
// do the building
Metalsmith(config.lessonRoot)
.source(config.sourceFolder)
.clean(false) // do not delete files, allow gulp tasks in parallel
.use(ignore(ignoreOptions))
.use(ignoreIndexedFalse)
.use(paths())
// set layout for exercises
.use(setMetadata(metadataOptions))
// add relative(path) for use in layouts
.use(relative())
// create collections for index
.use(collections(collectionOptions))
// add file.link metadata (files are .md here)
.use(filepath())
// remove lessons *after* we have necessary metadata
.use(ignore(['**', '!**/index.md']))
.use(tools.removeExternal)
// convert markdown to html
.use(md)
// globals for use in layouts
.use(define(defineOptions))
// apply layouts
.use(layouts(layoutOptions))
//build
.destination('build')
.build(function(err){
if (err) console.log(err);
// callback when build is done
callback(err);
});
};
grunt.registerTask('metalsmith', 'Build site', function () {
const highlights = require('metalsmith-metallic');
const inPlace = require('metalsmith-in-place');
const layouts = require('metalsmith-layouts');
const markdown = require('metalsmith-markdown');
const metadata = require('metalsmith-metadata');
const Metalsmith = require('metalsmith');
const nodeVersion = process.version;
let done = this.async();
const m = Metalsmith(__dirname);
m.metadata({
nodeVersion
});
m.use(metadata({
plugins: 'plugins.json',
examples: 'examples.json'
}));
m.use(inPlace({
engine: 'swig',
pattern: '**/*.md'
}));
m.use(highlights());
m.use(markdown({
smartypants: true,
smartLists: true
}));
m.use(layouts({
engine: 'swig',
directory: process.cwd()
}));
m.build((err) => {
if (err) {
/* eslint no-console: 0 */
console.log('Error: ' + err);
return done(false);
}
return done();
});
});
function build(){
metal(__dirname)
.source('./src')
.use(markdown({
smartypants: true,
gfm: true,
tables: true,
highlight: highlighter()
}))
// .use(my_plugin({a:1,b:2}))
.use(inPlace({ engine: 'handlebars' }))
.use(layouts({
engine: 'handlebars',
directory: 'templates',
partials: 'partials'
}))
.destination('./build')
.build(function (e) {
if (e) console.log(e)
})
}
module.exports = function build (callback, options) {
options = options || {}
var forceBuild = options.force || false
// do the building
Metalsmith(config.lessonRoot)
.source(config.sourceFolder)
.use(lessonReadme())
.use(ignore(ignoreOptions))
.clean(false) // do not delete files, allow gulp tasks in parallel
.use(paths())
// set layout for exercises
.use(setMetadata(metadataOptions))
// add relative(path) for use in layouts
.use(relative())
// create collections
.use(collections(collectionOptions))
.use(changed({
force: forceBuild,
extnames: {
'.md': '.html'
}
}))
// convert markdown to html
.use(md)
// add file.link metadata (now files are .html)
.use(filepath())
// globals for use in layouts
.use(define(defineOptions))
// apply layouts
.use(layouts(layoutOptions))
// build
.destination('build')
.build(function (err) {
if (err) console.log(err)
// callback when build is done
callback(err)
})
}
return new Promise((resolve, reject) => {
Metalsmith(path.resolve(__dirname, '../'))
.source('site/pages')
.destination(DIST_DIR)
.use(layouts({
engine: 'handlebars',
default: 'main.hbs',
IS_PROD
}))
.use(permalinks({
pattern: ':title',
relative: false
}))
.use(msIf(IS_WATCH_ENABLED, watch()))
.build((error) => {
if (error) {
reject(error);
} else {
resolve();
}
});
});
Kapi.prototype.buildWebsite = function() {
winston.info('Building static website...');
Metalsmith(this._opts.destination)
.clean(true)
.use(sass({
outputDir: 'css/',
outputStyle: 'expanded'
}))
.use(json(this._onFileProcessing))
.use(markdown())
.use(layouts({
engine: 'handlebars',
partials: 'partials'
}))
.build(err => {
if(err)
throw err;
winston.info('Building finished!');
});
};
gulp.task('build-site-templates', () => {
return gulp.src(['src/*.jade', 'src/**/*.jade', 'src/*.md'])
.pipe($.changed(paths.build, { extension: '.html' }))
.pipe($.frontMatter().on('data', file => {
Object.assign(file, file.frontMatter)
delete file.frontMatter
}))
.pipe(
gulpsmith()
.use(addTimestampToMarkdownFiles)
.use(markdown({
smartypants: true,
gfm: true,
tables: true
}))
.use(jade({
locals: {
cssTimestamp,
events: addDateProps(sortEventsAscending(JSON.parse(fs.readFileSync('./src/events.json', 'utf8')))),
releases: addDateProps(sortEventsAscending(JSON.parse(fs.readFileSync('./src/releases.json', 'utf8'))))
},
pretty: true
}))
.use(define({
moment,
rootUrl: CONFIG.root_url
}))
.use(each(updatePaths))
.use(layouts({
pattern: '**/*.html',
engine: 'jade',
directory: path.join('layouts')
})))
.use(reloadInMetalsmithPipeline)
.pipe(gulp.dest(paths.build))
})
// This is the function where the actual magic happens. This contains the main
// Metalsmith build cycle used for building a locale subsite, such as the
// english one.
function buildLocale (source, locale) {
console.time(`[metalsmith] build/${locale} finished`)
const siteJSON = path.join(__dirname, 'locale', locale, 'site.json')
const metalsmith = Metalsmith(__dirname)
metalsmith
// Sets global metadata imported from the locale's respective site.json.
.metadata({
site: require(siteJSON),
project: source.project,
i18n: i18nJSON(locale)
})
// Sets the build source as the locale folder.
.source(path.join(__dirname, 'locale', locale))
// Extracts the main menu and sub-menu links form locale's site.json and
// adds them to the metadata. This data is used in the navigation template
.use(navigation(source.project.currentVersions))
// Defines the blog post/guide collections used to internally group them for
// easier future handling and feed generation.
.use(collections({
blog: {
pattern: 'blog/**/*.md',
sortBy: 'date',
reverse: true,
refer: false
},
blogAnnounce: {
pattern: 'blog/announcements/*.md',
sortBy: 'date',
reverse: true,
refer: false
},
blogReleases: {
pattern: 'blog/release/*.md',
sortBy: 'date',
reverse: true,
refer: false
},
blogVulnerability: {
pattern: 'blog/vulnerability/*.md',
sortBy: 'date',
reverse: true,
refer: false
},
lastWeekly: {
pattern: 'blog/weekly-updates/*.md',
sortBy: 'date',
reverse: true,
refer: false,
limit: 1
},
tscMinutes: {
pattern: 'foundation/tsc/minutes/*.md',
sortBy: 'date',
reverse: true,
refer: false
},
knowledgeBase: {
pattern: 'knowledge/**/*.md',
refer: false
},
guides: {
pattern: 'docs/guides/!(index).md',
refer: false
}
}))
.use(pagination({
path: 'blog/year',
iteratee: (post, idx) => ({
post,
displaySummary: idx < 10
})
}))
.use(markdown(markedOptions))
.use(githubLinks({ locale: locale }))
.use(prism())
// Deletes Stylus partials since they'll be included in the main CSS file
// anyways.
.use(filterStylusPartials())
.use(stylus({
compress: true,
paths: [path.join(__dirname, 'layouts', 'css')],
use: [autoprefixer()]
}))
// Set pretty permalinks, we don't want .html suffixes everywhere.
.use(permalinks({
relative: false
}))
// Generates the feed XML files from their respective collections which were
// defined earlier on.
.use(feed({
collection: 'blog',
destination: 'feed/blog.xml',
title: 'Node.js Blog'
}))
.use(feed({
collection: 'blogAnnounce',
destination: 'feed/announce.xml',
title: 'Node.js Announcements'
}))
.use(feed({
collection: 'blogReleases',
destination: 'feed/releases.xml',
title: 'Node.js Blog: Releases'
}))
.use(feed({
collection: 'blogVulnerability',
destination: 'feed/vulnerability.xml',
title: 'Node.js Blog: Vulnerability Reports'
}))
.use(feed({
collection: 'tscMinutes',
destination: 'feed/tsc-minutes.xml',
title: 'Node.js Technical Steering Committee meetings'
}))
// Finally, this compiles the rest of the layouts present in ./layouts.
// They're language-agnostic, but have to be regenerated for every locale
// anyways.
.use(layouts({
engine: 'handlebars',
pattern: '**/*.html',
partials: 'layouts/partials',
helpers: {
copyright: require('./scripts/helpers/copyright-year.js'),
equals: require('./scripts/helpers/equals.js'),
startswith: require('./scripts/helpers/startswith.js'),
i18n: require('./scripts/helpers/i18n.js'),
changeloglink: require('./scripts/helpers/changeloglink.js'),
strftime: require('./scripts/helpers/strftime.js'),
apidocslink: require('./scripts/helpers/apidocslink.js'),
majorapidocslink: require('./scripts/helpers/majorapidocslink.js'),
summary: require('./scripts/helpers/summary.js')
}
}))
// Pipes the generated files into their respective subdirectory in the build
// directory.
.destination(path.join(__dirname, 'build', locale))
// This actually executes the build and stops the internal timer after
// completion.
metalsmith.build((err) => {
if (err) { throw err }
console.timeEnd(`[metalsmith] build/${locale} finished`)
})
}
'collections.tutorials': {
perPage: 10,
layout: 'list.html',
first: 'list.html',
path: 'tutorials/:num/index.html',
pageMetadata: { category: 'tutorials' }
},
'collections.webDevelopment': {
perPage: 10,
layout: 'list.html',
first: 'list.html',
path: 'web-development/:num/index.html',
pageMetadata: { category: 'web-development' }
},
'collections.openSource': {
perPage: 10,
layout: 'list.html',
first: 'list.html',
path: 'open-source/:num/index.html',
pageMetadata: { category: 'open-source' }
}
}))
.use(category())
.use(layouts({
engine: 'ejs',
partials: 'partials'
}))
.use(sass({
outputDir: 'assets/css',
sourceMap: true
}));
module.exports = function (callback) {
var Metalsmith = require('metalsmith');
var collections = require('metalsmith-collections');
var gutil = require("gulp-util");
var markdown = require('metalsmith-markdown');
var layouts = require('metalsmith-layouts');
var permalinks = require('metalsmith-permalinks');
var drafts = require('metalsmith-drafts');
var excerpts = require('metalsmith-excerpts');
var archive = require('metalsmith-archive');
console.log('building...');
Metalsmith(__dirname)
.metadata({site_name: "My Site"})
.use(drafts())
.use(collections({
posts: {
pattern: 'posts/**/*.md',
sortBy: 'date',
reverse: true
}
}))
.use(markdown())
.use(excerpts())
.use(permalinks({
// original options would act as the keys of a `default` linkset,
// pattern: ':title',
// date: 'YYYY',
// each linkset defines a match, and any other desired option
linksets: [{
match: { collection: 'posts' },
pattern: ':title',
date: 'mmddyy'
},{
match: { collection: 'pages' },
pattern: 'pages/:title'
}]
}))
.use (function (files, metalsmith, done) {
metalsmith.metadata().collections.posts.forEach(function (p) {
//console.log(p);
});
done();
})
.use(layouts({
cache: false,
engine: 'swig',
'default': 'default.swig',
directory: './layouts'
}))
.build(function(err) {
if (err){
var gutil = require('gulp-util');
gutil.log( gutil.colors.magenta(err.message), err);
gutil.beep();
}
callback();
});
};
// HTML
.use(markdown({
html: true,
xhtmlOut: true,
typographer: true,
linkify: true
}))
.use(permalinks({
pattern: ':title',
relative: false
}))
.use(layouts({
engine: 'pug',
pretty: true,
moment: require('moment'),
contrast: require('get-contrast'),
directory: 'templates',
default: 'default.pug',
pattern: '**/*.html'
}))
.use(drafts())
if (process.env.NODE_ENV === 'production') {
siteBuild.use(minify())
}
siteBuild.build(function (err) {
if (err) {
console.log(err)
} else {
console.log('Metalsmith complete!\n')
sortBy: 'date',
reverse: true
}
}))
.use(slug())
.use(markdown({
langPrefix: 'language-'
}))
.use(prism())
.use(codewrap('<div class="code-block-container">'))
.use(excerpts())
.use(markdownFrontMatter('note'))
.use(humanizeDate())
.use(featured({
collection: 'posts'
}))
.use(index())
.use(layouts({ engine: 'pug', default: 'post.pug', pretty: true, md }))
.use(json(['title', 'excerpt', 'shareimg', 'contents']))
.use(watch({
paths: {
'${source}/**/*': true,
'layouts/*': '**/*'
}
}))
.build(function (err, files) {
if (err) return console.log(err)
console.log('Built:')
console.log(' ', Object.keys(files).join('\n '))
})
var Metalsmith = require('metalsmith');
var markdown = require('metalsmith-markdown');
var layouts = require('metalsmith-layouts');
var colors = require('colors');
var outputFolder = './build';
Metalsmith(__dirname)
.source('./src')
.destination(outputFolder)
.use(markdown())
.use(layouts({
engine: 'handlebars',
directory: 'templates'
}))
.build(buildCallback);
function buildCallback(err) {
var msg;
if(err) {
msg = '...There was a build error: ' + err;
console.log(msg .red);
}
msg = '...Your build was succesful - check the ' + outputFolder + ' directory';
console.log(msg .green);
}
site: function(done) {
metalsmith(__dirname + '/../')
.clean(false)
.source('./src/documents_' + lang)
.metadata(require('../config.js')(lang, isStaging))
.use(draft())
.use(require('./helpers')())
.use(require('./import-api-docs')(lang))
.use(require('./patterns-collection')(lang))
.use(collections({
components: {
sortBy: 'name'
},
objects: {
sortBy: 'name'
},
guides: {
sortBy: 'name'
}
}))
.use(function(files, metalsmith, done) {
setImmediate(done);
var dict = {};
for (var path in files) {
var file = files[path];
if (file.componentCategory) {
file.componentCategory.split(/, */).forEach(function(category) {
if (!dict[category]) {
dict[category] = [];
}
dict[category].push(file);
});
}
}
metalsmith.metadata().componentCategoryDict = sortObject(dict);
})
.use(templates({engine: 'eco', inPlace: true}))
.use(require('./autotoc')())
.use(function(files, metalsmith, done) {
setImmediate(done);
var cssFile = files['reference/css.html'];
var cssToc = cssFile.toc;
delete cssFile.toc;
metalsmith.metadata().cssToc = cssToc;
})
.use(currentPath())
.use(branch('!robots.txt')
.use(layouts({
engine: 'eco',
directory: './src/layouts/',
default: 'default.html.eco'
}))
)
.use(assets({source: './src/files'}))
.use(require('./css-transform')(lang))
.use(redirect({
'/components.html' : '/reference/javascript.html',
'/guide/components.html' : '/reference/javascript.html'
}))
.use(branch('*.html').use(currentPath()))
.use(function(files, metalsmith, done) {
setImmediate(done);
for (var file in files) {
if (file.match(/\.html$/)) {
files[file].path = file;
}
}
})
.use(branch('robots.txt').use(templates({
inPlace: true, engine: 'eco'
})))
.use(sitemap({
ignoreFiles: [/\.gitignore/],
output: 'sitemap.xml',
hostname: 'http://' + (isStaging ? 's.' : '') + (lang === 'ja' ? 'ja.' : '') + 'onsen.io',
defaults: {
priority: 0.5
}
}))
.destination('./out_' + lang)
.build(function(error) {
if (error) {
gutil.log('ERROR: ' + error);
if (error.stack) {
gutil.log(error.stack);
}
}
browserSync.reload();
gutil.log('Generated into \'./out_' + lang + '\'');
done();
});
},