function parseFiles(file, loopCb) {
let fileContents = fs.readFileSync(file, 'utf8')
let cleaned = stripMarkdownMetadata(fileContents)
// parse it for metadata
let parsed = metaMarked(fileContents)
// flatten silly nesting structure
let result = parsed.meta
let url = '/blog/' + parsed.meta.slug
result.url = url
result.startingFilename = file
result.markdown = cleaned
result.outputFile = url + '.html'
result.date = new Date(result.date)
// smart links in headers
let lexed = marked.lexer(cleaned)
let html = marked.parser(lexed, {renderer: renderer})
let minimize = new Minimize()
minimize.parse(html, function (err, data) {
if (err) throw err
result.html = data
loopCb(null, result)
})
}
fs.readFile(file.source.path, 'utf8', function (err,data) {
if (err) {
return console.log(err);
}
minimize.parse(data , function (error, data) {
file.min.size = data.length;
fs.writeFile(file.min.path, data, callback);
});
});
.pipe(es.map(function(file){
var source = fs.readFileSync(filename),
minimize = new Minimize();
minimize.parse(source.toString(), function (err, data) {
if (err) throw err;
var expected = data;
expect(expected).to.be.equal(file.contents.toString());
done();
});
}));
processOutput: function(data, onSuccess, onError) {
data = data.replace(/"/g, '"');
var Minimize = require('minimize');
var minimize = new Minimize({quotes: true});
minimize.parse(data, function(error, result) {
if (error) {
onError(error);
} else {
onSuccess(result);
}
});
}
eachAsync(this.files, function (el, i, next) {
var minimize = new Minimize(options);
var src = el.src[0];
minimize.parse(grunt.file.read(src), function (err, data) {
if (err) {
grunt.warn(err);
next(err);
return;
}
grunt.file.write(el.dest, data);
next();
});
}, this.async());
postProcessHtml: function(html) {
// Minimize the generated html and return the promise with the result
var Minimize = require('minimize');
var minimize = new Minimize({quotes: true});
var deferred = Q.defer();
minimize.parse(html, function(error, result) {
if (error) {
deferred.reject(new Error(error));
} else {
deferred.resolve(result);
}
});
return deferred.promise;
}
fs.readFile('modal.html', 'utf8', function(err, html) {
html_mini.parse(html, function(err, html) {
fs.readFile('send-btc.js.in', 'utf8', function(err, js) {
fs.writeFile('send-btc.js', head_msg + js.replace('@MODAL_HTML@', html),
function(err) {
new node_minify.minify({
type: 'yui-js',
fileIn: 'send-btc.js',
fileOut: 'send-btc.min.js',
callback: function(err, min) {
console.log(err);
}
});
});
});
});
});
function minimize (file, encoding, callback) {
if (file.isNull()) {
this.push(file);
return callback();
}
if (file.isStream()) {
return callback(new gutil.PluginError('gulp-minify-html', 'doesn\'t support Streams'));
}
var minimize = new Minimize(opt || {} );
minimize.parse(String(file.contents), function (err, data) {
if (err) return callback(new gutil.PluginError('gulp-minify-html', err));
file.contents = new Buffer(data);
this.push(file);
callback();
}.bind(this));
}
// HTMLMinifier
function minifyHtml(body) {
var deferred = Q.defer();
var minimize = new Minimize({
empty: true, // KEEP empty attributes
conditionals: true, // KEEP conditional internet explorer comments
spare: true // KEEP redundant attributes
});
minimize.parse(body, function (error, data) {
if (error) {
deferred.reject(error);
} else {
deferred.resolve(data);
}
});
return deferred.promise;
}
function extract(body, callback) {
var replacement = String.fromCharCode(160);
replacement += String.fromCharCode(161);
replacement += String.fromCharCode(162);
replacement += String.fromCharCode(163);
var pattern = new RegExp(replacement, 'g');
minimize.parse(body, function(err, data) {
data = data.replace(/\n/g, replacement);
var article = data.match(/<article.*>.+<\/article>/)[0];
var title = data.match(/<h1.*>(.+)<\/h1>/)[1];
title = title.replace(pattern, '');
article = article.replace(/<h1.*>.+<\/h1>/, '');
article = article.replace(pattern, '\n');
callback && callback(null, {
title: title,
article: article
});
});
}