return slug => {
const path = `posts/${slug}.md`;
const markdown = loadFront(options.fromPublic(path), 'content');
const content = removeNewLines(marked(markdown.content, markedOptions));
const synopsis = markdown.synopsis ? marked(markdown.synopsis, markedOptions) : undefined;
return new Promise(resolve => {
getCommits({ user, repo, path: `public/${path}` }).then(commits => {
const firstCommit = commits[commits.length - 1];
const lastCommit = commits[0];
const userId = Number(firstCommit.author.id);
const author = firstCommit.author.login;
const createdDate = moment(firstCommit.commit.author.date).unix() * 1000;
const modifiedDate = moment(lastCommit.commit.author.date).unix() * 1000;
resolve({ ...markdown, userId, createdDate, modifiedDate, author, content, synopsis, slug });
});
});
};
nabu.files[folder] = files.filter(function(file, index) {
// The first three conditionals try to detirmine as much as possible
// from the filename, thus reducing the amount of heavy lifting later
// when it needs to load the file to check for yaml front matter
// Is the file in any of the above folders?
if (file.indexOf('_'+folder) !== -1) {
delete files[index];
return true;
}
// Is this a template file?
if (folder === 'templates' && path.extname(file) === '.'+nabu.site.template_engine) {
delete files[index];
return true;
}
// Are we in the assets loop and are any of the files non-text?
if (folder === 'assets' && mime.lookup(file).split('/')[0] !== 'text') {
delete files[index];
return true;
}
// Are we in the pages loop and do any remaining files have YAML front matter?
// console.log(file);
if (folder === 'pages' && yamlfm.loadFront(fs.readFileSync(file))) {
delete files[index];
return true;
}
// Assume everything left is a static asset
if (folder === 'assets') {
delete files[index];
return true;
}
});
var parseFile = function(file) {
// Parse front matter
var metadata = parseFrontMatter(file.raw);
// Parse markdown
var parsed = commonmarkParser.parse(metadata.__content); // parsed is a Node tree
// Copy attributes
delete metadata.__content;
_.assign(file, metadata);
// Guess title
if (!file.title) {
// Try using h1 in Markdown
var h1 = parsed._firstChild;
if (h1 && h1.level === 1 && h1.type === "Header") {
file.title = h1._firstChild && h1._firstChild._literal;
h1.unlink(); // delete the <h1>
}
if (!file.title) {
// Then try using title from path
file.title = path.basename(file.path, path.extname(file.path));
}
}
// Render HTML
file.html = commonmarkRender.render(parsed);
return file;
};
files.forEach(file => {
if(!file.match(/\.md$/)) {
return;
}
const contents = fs.readFileSync(path.join(dirpath, file));
const results = yamlFront.loadFront(contents);
const post = Object.assign(results, { content: results.__content });
const m = post.content.match(/^\s*# ([^\n]*)\n\n/m);
if(m) {
post.title = m[1];
post.content = post.content.slice(m[0].length);
}
// Infer the URL from the filename
post.shorturl = file.match(/(.*)\.md$/)[1];
if(post.date) {
if(post.date instanceof Date) {
post.date = moment.utc(post.date).valueOf();
}
else if(post.date.toString().match(/\d{8}/)) {
post.date = moment.utc(post.date, "YYYYMMDD").valueOf();
}
else if(post.date.match(/\w+ \d{1,2}, \d{4}/)) {
post.date = moment.utc(post.date, "MMMM D, YYYY").valueOf();
}
}
_postIndex[post.shorturl] = post;
_allPosts.push(post);
});
var _pageFactory = function (file) {
try {
stats = fs.lstatSync(file);
// TODO: this seems overly complicated, could probably clean this up
if (!stats.isDirectory()) {
var page = {
name: path.basename(file, path.extname(file)),
type: path.extname(file).replace('.',''),
raw: fs.readFileSync(file,'utf8')
};
var basedir = path.join(spearmint.options.paths.base, spearmint.options.paths.pages) + path.sep;
page.relative = file.replace(basedir, '').split(path.sep);
page.relative[page.relative.length-1] = page.name + '.html';
page.url = page.relative.join('/');
page.data = yaml.loadFront(page.raw);
if (page.data) {
page.data.url = page.url;
page.data.name = page.name;
page.data.type = page.type;
page.data.content = marked(page.data.__content);
} else {
page.raw = fs.readFileSync(file);
}
return page;
}
} catch (e) {
console.log(e);
}
};
function processFile(filename, width, content)
{
var _basename = path.basename(filename, path.extname(filename));
var _metadata = yaml.loadFront(filename);
if (_metadata)
{
// Max of 50 chars, snapped to word boundaries, and trim leading whitespace
_metadata.preview = _metadata['__content'].truncate(width).replace(/^\s+/,'');
// Rename to content
_metadata['content'] = _metadata['__content'];
// If the command line option isn't provided use preview only
if (typeof(content) == "undefined")
{
delete _metadata['content'];
}
// map user-entered date to a better one using moment's great parser
if (_metadata.date) {
_metadata.iso8601Date = moment(_metadata.date).format();
}
_metadata.basename = _basename;
}
return {
metadata: _metadata,
basename: _basename
};
}
function callback (abspath, rootdir, subdir, filename) {
results = yamlFront.loadFront('./' + abspath);
var tags = results.tags;
if (tags && tags.length) {
processTags(tags);
}
}
function bufferContents(file) {
if (file.isNull()) return; // ignore
if (file.isStream()) return this.emit('error', new PluginError('gulp-markdown-docs', 'Streaming not supported'));
var markdown, meta, html;
if (!firstFile) firstFile = file;
try {
if (options.yamlMeta) {
var parsedText = yamlFront.loadFront(file.contents.toString());
collectedDocs.push({
meta: _.omit(parsedText, '__content'),
html: parseMarkdown(parsedText.__content)
});
} else {
collectedDocs.push({
html: parseMarkdown(file.contents.toString())
});
}
} catch (err) {
gutil.log(gutil.colors.red('ERROR failed to parse api doc ' + file.path + '\n'), err);
}
}
function processFile(filename, width)
{
var _basename = path.basename(filename, path.extname(filename));
var _metadata = yaml.loadFront(filename);
if (_metadata)
{
// Max of 50 chars, snapped to word boundaries, and trim leading whitespace
_metadata.preview = _metadata['__content'].truncate(width).replace(/^\s+/,'');
// yaml-front-matter adds all the content; we'll just use our preview
delete _metadata['__content'];
// map user-entered date to a better one using moment's great parser
if (_metadata.date) {
_metadata.iso8601Date = moment(_metadata.date).format();
}
_metadata.basename = _basename;
}
return {
metadata: _metadata,
basename: _basename
};
}
constructor(file) {
const raw = fs.readFileSync(path.join(DIR, file), 'utf8');
const front = yamlFront.loadFront(raw);
this.slug = file.replace(/\.md$/, '');
this.title = front.title;
this.date = new Date(front.date);
this.html = md.render(front.__content);
this.scripts = front.scripts;
}
function getFrontMatter(filename){
// return front matter of file, its filename and link
var content = fs.readFileSync(filename);
var frontMatter = yaml.loadFront(content);
frontMatter = _.omit(frontMatter, '__content');
frontMatter.filename = filename;
frontMatter.link = getLink(this.root, filename);
return frontMatter;
}
Fs.readFile(filePath, 'utf8', function(err, data) {
if (err) throw err;
var md5 = Crypto.createHash('md5').update(data).digest('hex');
var doc = FrontMatter.loadFront(data);
var docPath = path.replace(Path.extname(path), '');
doc.content = marked(doc.__content);
doc.path = Url.resolve('/', docPath);
doc.readonly = true;
doc.md5 = md5;
resolve(doc);
});
// Takes in a assignments and returns
function makeAssignment (filePath) {
var assignment = yamlFront.loadFront(filePath, 'content');
assignment.dirname = path.dirname(filePath);
assignment.slug = path.basename(assignment.dirname);
// Merge in the model definition
assignment = _.assign(
assignment,
require(path.join(assignment.dirname, 'model.js'))
);
return assignment;
}
function parseString(text) {
if (text.indexOf('---') !== 0) {
text = makeBackwardsCompatible(text)
}
var parsedYaml = yaml.loadFront(text)
var output = {
content: parsedYaml.__content.trim()
}
delete parsedYaml.__content
output.metadata = parsedYaml
return output
}
function getFileContents(filePath) {
var extension = path.extname(filePath);
var relativePath = path.relative(args.markdown, filePath)
.replace(new RegExp(extension+'$'), '');
var contents = fs.readFileSync(filePath, 'utf-8');
var stats = fs.statSync(filePath);
var data = yaml.loadFront(contents, 'markdown');
data.markdown = data.markdown.replace(REGEX_NEWLINES, '');
data.path = relativePath;
data.updatedAt = stats.mtime;
data.createdAt = stats.birthtime;
return data;
}
var processFile = function(file, next, noSave, pageData) {
if(!next) { next = function() {} };
var page = createPage();
page.set('paths', getPagePaths(file.path));
page.parseMarkdownFile = processFile;
if(pageData) {
for(var prop in pageData) {
page.set(prop, pageData[prop]);
}
}
var fileRoot = path.dirname(file.path),
endFile = '',
ext = file.path.split('.').pop().toLowerCase();
infoPass = false,
noMarkdown = false,
noLayout = false;
if(ext == 'md') {
endFile = path.basename(file.path).replace('.md', '.html');
} else {
noMarkdown = noLayout = true;
endFile = path.basename(file.path).replace('.' + ext, '');
}
var yamlConfig = yamlFront.loadFront(fs.readFileSync(file.path).toString('utf8'));
applyYamlConfig(page, yamlConfig);
var content = page.parser(yamlConfig.__content, infoPass, noMarkdown).build(noLayout);
if(!noSave && page.get('noSave') !== true) {
if(!api.config.actAsGulpPlugin) {
fs.writeFileSync(fileRoot + '/' + endFile, content, {encoding: 'utf8'});
!api.config.noLogging ? console.log('+ ' + file.path.replace(api.root, '').replace(".md", ".html").green + ' file generated') : null;
return next();
} else {
file.contents = new Buffer(content);
file.path = fileRoot + '/' + endFile;
this.push(file);
return next();
}
} else {
next();
return content;
}
}
module.exports = path => {
const content = readFileSync(path);
const meta = loadFront(content);
const {
updatedAt, createdAt, author,
} = meta
const fileInfo = statSync(path)
path = path.replace(/posts/, '')
return Object.assign({}, meta, {
createdAt: createdAt || fileInfo.birthtime.toISOString(),
uodatedAt: updatedAt || fileInfo.mtime.toISOString(),
author: author || 'Jun Yanada',
path: `/blog${path.replace(/\.md$/, '')}`,
})
}
var processPost = function(post) {
if (!post) {
return;
}
// Posts are written in the jekyll style - in markdown, with YAML front matter
// http://jekyllrb.com/docs/frontmatter/
var file = Path.join(baseName, 'posts', post);
var metadata = YMF.loadFront(file);
metadata.filename = post;
metadata.__content = Marked(metadata.__content);
metadata.url = '/news/' + url(post);
metadata.date = date(post);
metadata.filename = metadata.url + '.html';
return metadata;
};
md_pages.forEach(function(filepath) {
var file = fs.readFileSync(markdown_pages_dir + filepath, 'utf8');
var properties = fm.loadFront(file);
var html = marked(properties.__content);
var output = html;
if (properties.template) {
var tmpl = fs.readFileSync(templates_dir + properties.template, 'utf8');
output = ejs.render(tmpl, {
page: properties,
content: html
});
}
var slug = properties.slug || 'untitled'; // todo
fs.outputFile(output_dir + slug + '/index.html', output);
});
function convert_data(basedir, file)
{
var source = `${basedir}/${file}`;
const str = fs.readFileSync(source, 'utf8');
var obj = yamlFront.loadFront(str);
if (!obj.type) {
obj.type = path.basename(basedir);
}
obj.filepath = source;
obj.body = md.render(obj.__content);
if (config.schemas[obj.type]) {
obj = config.schemas[obj.type].map(obj, config);
}
delete obj.__content;
return obj;
}
async.reduce(pages, collect, function(collect, page, next) {
var meta = Front.loadFront(page.source),
content = meta.__content;
delete(meta.__content);
_.extend(page, meta, {
content: content,
teaser: teaser(content),
date: new Date(meta.date)
});
meta = isPost(meta, page.source);
if (meta.category) {
collect.categories[meta.category] = category(target, collect, meta, page);
}
collect[meta.type + 's'].push(page);
next(null, collect);
}, done);
router.get('/:lang', function(req, res) {
var lang = req.params.lang,
markdownFile,
markdown;
try {
markdown = fs.readFileSync('./docs/' + lang + '.html.markdown');
} catch (err) {
return res.render('error', {
message: "No reference found for " + lang,
error: {}
});
}
markdownFile = parseFrontMatter(markdown);
res.render('doc', {
title: lang,
bodyHTML: marked(markdownFile.__content)
});
});
return new Promise(function(reject, resolve) {
for (i=0;i<l; i++) {
var postObject = frontMatter
.loadFront(fileList[i], 'markdownString');
postObject.markdownString = marked(postObject.markdownString);
postObject.basename = path.basename(fileList[i], '.md');
jadeLocals.post = postObject;
var htmlString = compileFunction(jadeLocals);
fs.writeFile(
'site-dist/' + postObject.basename + '.html',
htmlString,
{},
function(err) {
if (err) {
console.log(err);
}
});
}
resolve(true);
});
/**
* Processes passed data in to an object of data about the pattern
*
* @param {String} path - Path to the pattern's HTML
* the path data with
*
* @returns {object} Object of data about the processed pattern
*/
function processPatternData( path ){
var fileContents = grunt.file.read(path);
var frontMatter = yamlFrontMatter.loadFront(fileContents);
var initData = {
content: frontMatter.__content.trim(),
slug: getPatternSlug(path, frontMatter)
};
if(typeof frontMatter.title === 'undefined') {
grunt.log.warn('"' + path + '" doesn\'t have a title -- ignoring this file.');
return false;
}
var data = _.merge( initData, ( typeof arguments[2] !== "undefined" ) ? arguments[2] : {} );
delete frontMatter.slug;
delete frontMatter.__content;
// Carry the rest of the front matter data to the object
return _.defaults(data, frontMatter);
}
.pipe(through.obj(function (file, enc, callback) {
// Extract article data
file.articleData = frontMatter.loadFront(file.contents.toString());
files.push(file.articleData);
// Fall back to old behaviour
if (!file.articleData.title) {
var lines = file.articleData.__content.split('\n');
file.articleData.title = lines.splice(0, 1)[0].slice(2);
file.articleData.date = lines.splice(0, 1)[0].slice(2);
file.articleData.__content = lines.join('\n');
}
var date = moment(file.articleData.date, 'D MMMM, YYYY', 'en');
file.articleData.datetime = date.format('YYYY-MM-DD 00:00');
file.articleData.slug = file.path.slice(file.base.length, -3);
file.contents = new Buffer(file.articleData.__content);
callback(null, file);
}))
Handlebars.registerHelper('inline', function(path, options) {
var files = glob.sync(path);
var context = {
pages: []
};
var data = null;
var template = null;
var _i;
for(_i = 0; _i < files.length; _i++) {
data = yamlFront.loadFront(fs.readFileSync(files[_i]), 'page');
data.src = files[_i];
template = Handlebars.compile(data.page); // Compile the source
data.body = template(data); // render template
context.pages.push(data); // Add page to pages array in context
}
return options.fn(context);
});
nabu.processContent = function(sourcePath, type) {
var rawFile = fs.readFileSync(sourcePath, 'utf8');
var file = yamlfm.loadFront(rawFile, 'content_raw');
// Make sure the file
if (!nabu.files.layouts[file.layout]) {
throw new Error('There is now layout file by the name of ' + file.layout + ' specified in ' + sourcePath);
}
file.layoutPath = nabu.files.layouts[file.layout];
file.slug = _.slugify(file.title);
file.content = nabu.md(file.content_raw);
if (file.date) {
file.date = moment(file.date);
}
if (type === 'posts') {
//TODO: Actually obey permalink setting
file.permalink = file.slug + '/';
}
return nabu.processFile(file, sourcePath);
};
// Input file into template and create it
function(file, cb) {
var fileExtension = file.src[0].split('.');
fileExtension = fileExtension[fileExtension.length-1];
// If file is not markdown, just copy it as an asset
if (fileExtension != "md") {
grunt.file.copy(file.src[0], file.dest.replace(numberReplacePattern, '/'));
grunt.log.writeln('Asset "' + file.dest.replace(numberReplacePattern, '/') + '" created.');
return cb();
}
var markdownSource = file.src
.filter(function(filepath) {
if (!grunt.file.exists(filepath)) {
grunt.log.warn('Source file "' + filepath + '" not found.');
return false;
}
else return true;
})
.map(function(filepath) {
return grunt.file.read(filepath);
});
var page = frontMatter.loadFront(markdownSource),
pageHtml = marked(page.__content);
var html = indexTemplate(page);
html = html.replace('<#content>', pageHtml);
html = html.replace('<#navigation>', navigationHtml);
updateNaming(file, function(fileDestination){
grunt.file.write(fileDestination, html);
grunt.log.writeln('File "' + fileDestination + '" created.');
return cb();
});
},
const processFile = function(filename, width, content) {
const _basename = path.basename(filename, path.extname(filename));
const _metadata = yaml.loadFront(filename);
if (_metadata) {
// If width is truthy (is defined and and is not 0).
if (width) {
// Max of WIDTH chars snapped to word boundaries, trim whitespace
const truncateOptions = {
length: width,
separator: /\s/,
omission: ' …',
};
_metadata.preview = truncate(
_metadata['__content'].trim(), truncateOptions);
}
// If the option is provided keep the entire content in field 'content'
if (typeof(content) != 'undefined') {
_metadata['content'] = _metadata['__content'];
}
delete _metadata['__content'];
// map user-entered date to a better one using moment's great parser
if (_metadata.date) {
_metadata.iso8601Date = moment(_metadata.date).format();
}
_metadata.basename = _basename;
}
return {
metadata: _metadata,
basename: _basename,
};
};
var process = function(mdFiles) {
var processedFiles = [];
for(var i=0; i<mdFiles.length; i++) {
if(path.normalize(mdFiles[i].toString()).replace(/\\/g, '/').indexOf('/node_modules/') == -1) {
processedFiles.push(mdFiles[i]);
var yamlConfig = yamlFront.loadFront(fs.readFileSync(mdFiles[i]).toString('utf8'));
var mdContent = yamlConfig.__content;
var page = extend(Page(), api.masterConfig);
page.set('root', api.root);
page.set('rootTechy', api.rootTechy);
page.set('theme', api.theme);
page.set('themeDir', api.themeDir);
page.set('techyFiles', techyFiles);
page.set('paths', getPagePaths(mdFiles[i]));
page.set('infoPass', true);
applyYamlConfig(page, yamlConfig);
page.parser(mdContent, true);
info.pages.push(page);
} else {
// console.log('Skipped: ' + mdFiles[i]);
}
}
return processedFiles;
}