PopPop is a static site and blog generator for Node.
112 |
113 | | |
| lib/cli_tools.js |
114 | |
115 | Module dependencies.
116 |
117 | |
118 |
119 | var yamlish = require('yamlish')
120 | , path = require('path')
121 | , fs = require('fs')
122 | , log = require(__dirname + '/log')
123 | , generators = require(__dirname + '/generators');
124 |
125 | module.exports = {
126 | |
127 |
128 |
129 | |
130 | Adds zero padding to single digit numbers.
131 |
132 |
133 |
134 |
135 | |
136 |
137 | datePad: function(num) {
138 | return num.toString().length === 1 ? '0' + num : num;
139 | },
140 | |
141 |
142 |
143 | |
144 | Makes a post file name (not URL) based on the config's permanlink format.
145 |
146 |
147 |
148 | param: String Permalink format param: Date Date for the file name param: String The title for the post param: String The file format (md or textile) return: String
149 | |
150 |
151 | getPostFileName: function(pf, date, title, format) {
152 | title = encodeURI(title.toLowerCase().replace(/\s+/g, '-'));
153 | return '_posts/' + pf.replace(':year', date.getFullYear())
154 | .replace(':month', this.datePad(date.getMonth() + 1))
155 | .replace(':day', this.datePad(date.getDate()))
156 | .replace(/^\//, '')
157 | .replace(/\//g, '-')
158 | .replace(':title', title + '.' + format);
159 | },
160 | |
161 |
162 |
163 | |
164 | Generates a stubbed post and writes it based on a file name.
165 |
166 |
167 |
168 |
169 | |
170 |
171 | makePost: function(config, title, fn) {
172 |
173 | var meta = {
174 | layout: 'post'
175 | , title: title
176 | , author: process.env.LOGNAME || ''
177 | , tags: ['tag_1', 'tag_2']
178 | }
179 | , url = ''
180 | , format = 'md'
181 | , date = new Date()
182 | , frontMatter = ''
183 | , fileName = this.getPostFileName(config.permalink, date, title, format);
184 |
185 | frontMatter = '---\n' + yamlish.encode(meta).replace(/^\s+/mg, '') + '\n---\n';
186 |
187 | fs.writeFile(path.join(config.root, fileName), frontMatter, function(err) {
188 | if (err) {
189 | log.error('Error writing file:', fileName);
190 | throw(err);
191 | }
192 | log.info('Post created:', fileName);
193 | fn();
194 | });
195 | },
196 | |
197 |
198 |
199 | |
200 | Default config settings, used by site generator.
201 |
202 |
203 |
204 |
205 | |
206 |
207 | defaultConfig: function() {
208 | return ''
209 | + '{ "url": "http://example.com"\n'
210 | + ' , "title": "Example"\n'
211 | + ' , "permalink": "/:year/:month/:day/:title"\n'
212 | + ' , "perPage": 10\n'
213 | + ' , "exclude": ["\\\\.swp"]\n'
214 | + ' , "autoGenerate": [{"feed": "feed.xml", "rss": "feed.rss"}] }\n'
215 | },
216 | |
217 |
218 |
219 | |
220 | Default index file, used by site generator.
221 |
222 |
223 |
224 |
225 | |
226 |
227 | defaultIndex: function() {
228 | return ''
229 | + '---\n'
230 | + 'layout: default\n'
231 | + 'title: My Site\n'
232 | + 'paginate: true\n'
233 | + '---\n\n'
234 | + '!{paginatedPosts()}\n'
235 | + '!{paginate}\n';
236 | },
237 | |
238 |
239 |
240 | |
241 | Default layout, used by site generator.
242 |
243 |
244 |
245 |
246 | |
247 |
248 | defaultLayout: function() {
249 | return fs.readFileSync(__dirname + '/assets/default.jade');
250 | },
251 | |
252 |
253 |
254 | |
255 | Default post layout, used by site generator.
256 |
257 |
258 |
259 |
260 | |
261 |
262 | defaultPostLayout: function() {
263 | return fs.readFileSync(__dirname + '/assets/post.jade');
264 | },
265 | |
266 |
267 |
268 | |
269 | Default client-side JavaScript.
270 |
271 |
272 |
273 |
274 | |
275 |
276 | defaultClientJavaScript: function() {
277 | return fs.readFileSync(__dirname + '/assets/site.js');
278 | },
279 | |
280 |
281 |
282 | |
283 | Default tags page.
284 |
285 |
286 |
287 |
288 | |
289 |
290 | defaultTags: function() {
291 | return fs.readFileSync(__dirname + '/assets/tags.jade');
292 | },
293 | |
294 |
295 |
296 | |
297 | Sample post, to get people started.
298 |
299 |
300 |
301 |
302 | |
303 |
304 | samplePost: function() {
305 | return ''
306 | + '---\n'
307 | + 'title: Example Post About Something\n'
308 | + 'author: Pop\n'
309 | + 'layout: post\n'
310 | + 'tags:\n'
311 | + '- tag1\n'
312 | + '- tag2\n'
313 | + '---\n'
314 | + 'Pop is a static site generator. It can be used to make blogs. I hope you enjoy it!\n';
315 | },
316 | |
317 |
318 |
319 | |
320 | Built-in stylesheet.
321 |
322 |
323 |
324 |
325 | |
326 |
327 | defaultStylus: function() {
328 | return fs.readFileSync(__dirname + '/assets/screen.styl');
329 | },
330 | |
331 |
332 |
333 | |
334 | Site generator. Will not create a site if pathName exists.
335 |
336 |
337 |
338 |
339 | |
340 |
341 | makeSite: function(args, fn) {
342 | var pathName
343 | , generator;
344 |
345 | if (args.length === 1) {
346 | pathName = args[0];
347 | generator = 'default';
348 | } else {
349 | pathName = args[1];
350 | generator = args[0];
351 | }
352 |
353 | if (generators.hasOwnProperty(generator)) {
354 | generators[generator].run(this, pathName, fn);
355 | } else {
356 | try {
357 | var pluginGenerator = require(generator);
358 | } catch (e) {
359 | log.error('Error: Unable to find the', generator, 'generator');
360 | return;
361 | }
362 |
363 | pluginGenerator.generator.run(this, pathName, fn);
364 | }
365 | },
366 | |
367 |
368 |
369 | |
370 | Renders files that match pattern.
371 |
372 |
373 |
374 |
375 | |
376 |
377 | renderFile: function(pop, config, pattern) {
378 | var fileMap = new pop.FileMap(config)
379 | , siteBuilder = new pop.SiteBuilder(config);
380 |
381 | fileMap.on('ready', function() {
382 | if (fileMap.files.length === 0) {
383 | fn();
384 | } else {
385 | siteBuilder.fileMap = fileMap;
386 | siteBuilder.build();
387 | siteBuilder.on('ready', function() {
388 | log.info('%d files rendered.', fileMap.files.length);
389 | });
390 | }
391 | });
392 |
393 | fileMap.search(pattern);
394 | }
395 | };
396 |
397 | |
398 |
| lib/config.js |
399 | |
400 | Config file reader.
401 |
402 |
403 |
404 |
405 | |
406 |
407 | function readConfigFile(file) {
408 | var defaults = {
409 | perPage: 20
410 | , port: 4000
411 | , output: '_site/'
412 | };
413 |
414 | function applyDefaults(config) {
415 | for (var key in defaults) {
416 | config[key] = config[key] || defaults[key];
417 | }
418 |
419 | if (config.url) config.url = config.url.replace(/\/$/, '');
420 |
421 | return config;
422 | }
423 |
424 | try {
425 | var data = fs.readFileSync(file).toString();
426 | return applyDefaults(JSON.parse(data));
427 | } catch(exception) {
428 | if (exception.code === 'EBADF') {
429 | log.error('No _config.json file in this directory. Is this a Pop site?');
430 | process.exit(1);
431 | } else {
432 | log.info('Error reading config:', exception.message);
433 | throw(exception);
434 | }
435 | }
436 | }
437 | |
438 |
439 |
440 | |
441 | Module dependencies and additional config variables.
442 |
443 | |
444 |
445 | var fs = require(__dirname + '/graceful')
446 | , log = require(__dirname + '/log');
447 |
448 | module.exports = readConfigFile;
449 |
450 | |
451 |
| lib/file_map.js |
452 | |
453 | Module dependencies.
454 |
455 | |
456 |
457 | var fs = require(__dirname + '/graceful')
458 | , path = require('path')
459 | , log = require(__dirname + '/pop').log
460 | , EventEmitter = require('events').EventEmitter;
461 | |
462 |
463 |
464 | |
465 | Initialize FileMap with a config object.
466 |
467 |
468 |
469 | param: Object options api: public
470 | |
471 |
472 | function FileMap(config) {
473 | this.config = config || {};
474 | this.config.exclude = config && config.exclude ? config.exclude : [];
475 | this.config.exclude.push('/_site');
476 | this.ignoreDotFiles = true;
477 | this.root = config.root;
478 | this.files = [];
479 | this.events = new EventEmitter();
480 | this.filesLeft = 0;
481 | this.dirsLeft = 1;
482 | }
483 | |
484 |
485 |
486 | |
487 | Determines file type based on file extension.
488 |
489 |
490 |
491 |
492 | |
493 |
494 | FileMap.prototype.fileType = function(fileName) {
495 | var extension = path.extname(fileName).substring(1);
496 |
497 | if (fileName.match(/\/_posts\
498 | return 'post ' + extension;
499 | } else if (fileName.match(/\/_layouts\
500 | return 'layout ' + extension;
501 | } else if (fileName.match(/\/_includes\
502 | return 'include ' + extension;
503 | } else if (['jade', 'ejs', 'styl'].indexOf(extension) !== -1) {
504 | return 'file ' + extension;
505 | } else {
506 | return 'file';
507 | }
508 | };
509 | |
510 |
511 |
512 | |
513 | Recursively iterates from an initial path.
514 |
515 |
516 |
517 |
518 | |
519 |
520 | FileMap.prototype.walk = function(dir) {
521 | if (!dir) dir = this.root;
522 |
523 | var self = this;
524 |
525 | fs.readdir(dir, function(err, files) {
526 | self.dirsLeft--;
527 | if (!files) return;
528 | files.forEach(function(file) {
529 | file = path.join(dir, file);
530 | self.filesLeft++;
531 | fs.stat(file, function(err, stats) {
532 | if (err) log.error('Error:', err);
533 | if (!stats) return;
534 | if (stats.isDirectory(file)) {
535 | self.filesLeft--;
536 | self.dirsLeft++;
537 | self.walk(file);
538 | self.addFile(file, 'dir');
539 | } else {
540 | self.filesLeft--;
541 | self.addFile(file, self.fileType(file));
542 | if (self.filesLeft === 0 && self.dirsLeft === 0) {
543 | process.nextTick(function() {
544 | self.events.emit('ready');
545 | });
546 | }
547 | }
548 | });
549 | });
550 | });
551 | };
552 | |
553 |
554 |
555 | |
556 | Searches for files that match pattern.
557 |
558 |
559 |
560 |
561 | |
562 |
563 | FileMap.prototype.search = function(pattern) {
564 | this.searchPattern = pattern;
565 | this.walk();
566 | };
567 | |
568 |
569 |
570 | |
571 | Checks to see if a file name matches the excluded patterns.
572 |
573 |
574 |
575 |
576 | |
577 |
578 | FileMap.prototype.isExcludedFile = function(file) {
579 | if (this.ignoreDotFiles)
580 | if (file.match(/\/\./)) return true;
581 |
582 | return this.config.exclude.some(function(pattern) {
583 | return file.match(pattern);
584 | });
585 | };
586 | |
587 |
588 |
589 | |
590 | Determines file type based on file extension.
591 |
592 |
593 |
594 | param: String File name param: String File type
595 | |
596 |
597 | FileMap.prototype.addFile = function(file, type) {
598 | if (this.isExcludedFile(file)) return;
599 | if (this.searchPattern && !file.match(this.searchPattern)) return;
600 |
601 | this.files.push({
602 | name: file,
603 | type: type,
604 | });
605 | };
606 | |
607 |
608 |
609 | |
610 | Bind an event to the internal EventEmitter.
611 |
612 |
613 |
614 | param: String Event name param: Function Handler
615 | |
616 |
617 | FileMap.prototype.on = function(eventName, fn) {
618 | this.events.on(eventName, fn);
619 | };
620 |
621 | module.exports = FileMap;
622 |
623 | |
624 |
| lib/filters.js |
625 | |
626 | module.exports = {
627 | |
628 |
629 | *
630 | * Replaces liquid tag highlight directives with prettyprint HTML tags.
631 | *
632 | * @param {String} The text for a post
633 | * @return {String}
634 |
635 | |
636 |
637 |
638 | |
639 | highlight: function(data) {
640 | data = data.replace(/{% highlight ([^ ]*) %}/g, '<pre class="prettyprint lang-$1">');
641 | data = data.replace(/{% endhighlight %}/g, '</pre>');
642 | return data;
643 | }
644 | };
645 | |
646 |
647 |
648 | |
649 |
| lib/generators.js |
650 | |
651 | module.exports = {
652 | 'default': require(__dirname + '/generators/default')
653 | };
654 | |
655 |
656 |
657 | |
658 |
| lib/graceful.js |
659 | |
660 | Module dependencies.
661 |
662 | |
663 |
664 | var fs = require('fs')
665 | , path = require('path')
666 | , defaultTimeout = 0
667 | , timeout = defaultTimeout;
668 | |
669 |
670 |
671 | |
672 | Offers functionality similar to mkdir -p, but is async.
673 |
674 |
675 |
676 |
677 | |
678 |
679 | function mkdir_p(dir, mode, callback, position) {
680 | mode = mode || process.umask();
681 | position = position || 0;
682 | parts = path.normalize(dir).split('/');
683 |
684 | if (position >= parts.length) {
685 | if (callback) {
686 | return callback();
687 | } else {
688 | return true;
689 | }
690 | }
691 |
692 | var directory = parts.slice(0, position + 1).join('/') || '/';
693 | fs.stat(directory, function(err) {
694 | if (err === null) {
695 | mkdir_p(dir, mode, callback, position + 1);
696 | } else {
697 | fs.mkdir(directory, mode, function(err) {
698 | if (err && err.errno != 17) {
699 | if (callback) {
700 | return callback(err);
701 | } else {
702 | throw err;
703 | }
704 | } else {
705 | mkdir_p(dir, mode, callback, position + 1);
706 | }
707 | });
708 | }
709 | });
710 | }
711 | |
712 |
713 |
714 | |
715 | Polymorphic approach to fs.mkdir()
716 |
717 |
718 |
719 |
720 | |
721 |
722 | fs.mkdir_p = function(dir, mode, callback) {
723 | mkdir_p(dir, mode, callback || process.noop);
724 | }
725 |
726 |
727 | Object.keys(fs)
728 | .forEach(function(i) {
729 | exports[i] = (typeof fs[i] !== 'function') ? fs[i]
730 | : (i.match(/^[A-Z]|^create|Sync$/)) ? function() {
731 | return fs[i].apply(fs, arguments);
732 | }
733 | : graceful(fs[i]);
734 | });
735 |
736 | function graceful(fn) { return function GRACEFUL() {
737 | var args = Array.prototype.slice.call(arguments)
738 | , cb_ = args.pop();
739 |
740 | args.push(cb);
741 |
742 | function cb(er) {
743 | if (er && er.message.match(/^EMFILE, Too many open files/)) {
744 | setTimeout(function() {
745 | GRACEFUL.apply(fs, args)
746 | }, timeout++);
747 | return;
748 | }
749 | timeout = defaultTimeout;
750 | cb_.apply(null, arguments);
751 | }
752 | fn.apply(fs, args)
753 | }};
754 |
755 | |
756 |
| lib/helpers.js |
757 | |
758 | Module dependencies and local variables.
759 |
760 | |
761 |
762 | var jade = require('jade')
763 | , fs = require('fs')
764 | , path = require('path')
765 | , cache = {}
766 | , _date = require('underscore.date')
767 | , helpers;
768 |
769 | helpers = {
770 | |
771 |
772 |
773 | |
774 | Pagination links.
775 |
776 |
777 |
778 |
779 | |
780 |
781 | paginate: function(paginator) {
782 | var template = '';
783 | template += '.pages\n';
784 | template += ' - if (paginator.previousPage)\n';
785 | template += ' span.prev_next\n';
786 | template += ' - if (paginator.previousPage === 1)\n';
787 | template += ' span ←\n';
788 | template += ' a.previous(href="/") Previous\n';
789 | template += ' - else\n';
790 | template += ' span ←\n';
791 | template += ' a.previous(href="/page" + paginator.previousPage + "/") Previous\n';
792 | template += ' - if (paginator.pages > 1)\n';
793 | template += ' span.prev_next\n';
794 | template += ' - for (var i = 1; i <= paginator.pages; i++)\n';
795 | template += ' - if (i === paginator.page)\n';
796 | template += ' strong.page #{i}\n';
797 | template += ' - else if (i !== 1)\n';
798 | template += ' a.page(href="/page" + i + "/") #{i}\n';
799 | template += ' - else\n';
800 | template += ' a.page(href="/") 1\n';
801 | template += ' - if (paginator.nextPage <= paginator.pages)\n';
802 | template += ' a.next(href="/page" + paginator.nextPage + "/") Next\n';
803 | template += ' span →\n';
804 | return jade.render(template, { locals: { paginator: paginator } });
805 | },
806 | |
807 |
808 |
809 | |
810 | Generates paginated blog posts, suitable for use on an index page.
811 |
812 |
813 |
814 |
815 | |
816 |
817 | paginatedPosts: function() {
818 | var template
819 | , site = this;
820 |
821 | template = ''
822 | + '- for (var i = 0; i < paginator.items.length; i++)\n'
823 | + ' !{hNews(paginator.items[i], true)}\n';
824 | return jade.render(template, { locals: site.applyHelpers({ paginator: site.paginator }) });
825 | },
826 | |
827 |
828 |
829 | |
830 | Atom Jade template.
831 |
832 |
833 |
834 |
835 | |
836 |
837 | atom: function(feed, summarise) {
838 | var template = ''
839 | , url = this.config.url
840 | , title = this.config.title
841 | , perPage = this.config.perPage
842 | , posts = this.posts.slice(-perPage).reverse()
843 | , site = this;
844 |
845 | summarise = typeof summarise === 'boolean' && summarise ? 3 : summarise;
846 | perPage = site.posts.length < perPage ? site.posts.length : perPage;
847 |
848 | template += '!!!xml\n';
849 | template += 'feed(xmlns="http://www.w3.org/2005/Atom")\n';
850 | template += ' title #{title}\n';
851 | template += ' link(href=feed, rel="self")\n';
852 | template += ' link(href=url)\n';
853 |
854 | if (posts.length > 0)
855 | template += ' updated #{dx(posts[0].date)}\n';
856 |
857 | template += ' id #{url}\n';
858 | template += ' author\n';
859 | template += ' name #{title}\n';
860 | template += ' - for (var i = 0, post = posts[i]; i < ' + perPage + '; i++, post = posts[i])\n';
861 | template += ' entry\n';
862 | template += ' title #{post.title}\n';
863 | template += ' link(href=url + post.url)\n';
864 | template += ' updated #{dx(post.date)}\n';
865 | template += ' id #{url.replace(/\\/$/, "")}#{post.url}\n';
866 |
867 | if (summarise)
868 | template += ' content(type="html") !{h(truncateParagraphs(post.content, summarise, ""))}\n';
869 | else
870 | template += ' content(type="html") !{h(post.content)}\n';
871 |
872 | return jade.render(template, { locals: site.applyHelpers({
873 | paginator: site.paginator
874 | , posts: posts
875 | , title: title
876 | , url: url
877 | , feed: feed
878 | , summarise: summarise
879 | })});
880 | },
881 | |
882 |
883 |
884 | |
885 | RSS Jade template.
886 |
887 |
888 |
889 |
890 | |
891 |
892 | rss: function(feed, summarise, description) {
893 | var template = ''
894 | , url = this.config.url
895 | , title = this.config.title
896 | , perPage = this.config.perPage
897 | , posts = this.posts.slice(-perPage).reverse()
898 | , site = this;
899 |
900 | description = description || title;
901 | summarise = typeof summarise === 'boolean' && summarise ? 3 : summarise;
902 | perPage = site.posts.length < perPage ? site.posts.length : perPage;
903 |
904 | template += '!!!xml\n';
905 | template += 'rss(version="2.0")\n';
906 | template += ' channel\n';
907 | template += ' title #{title}\n';
908 | template += ' link #{url}\n';
909 | template += ' description #{description}\n';
910 |
911 |
912 |
913 | if (posts.length > 0) {
914 | template += ' pubDate #{d822(posts[0].date)}\n';
915 | template += ' lastBuildDate #{d822(posts[0].date)}\n';
916 | }
917 |
918 | template += ' generator Pop\n';
919 | template += ' - for (var i = 0, post = posts[i]; i < ' + perPage + '; i++, post = posts[i])\n';
920 | template += ' item\n';
921 | template += ' title #{post.title}\n';
922 | template += ' link #{url + post.url}\n';
923 | template += ' pubDate #{d822(post.date)}\n';
924 | template += ' guid #{url.replace(/\\/$/, "")}#{post.url}\n';
925 |
926 | if (summarise)
927 | template += ' description !{h(truncateParagraphs(post.content, summarise, ""))}\n';
928 | else
929 | template += ' description !{h(post.content)}\n';
930 |
931 | return jade.render(template, { locals: site.applyHelpers({
932 | paginator: site.paginator
933 | , posts: posts
934 | , title: title
935 | , url: url
936 | , feed: feed
937 | , description: description
938 | , summarise: summarise
939 | })});
940 | },
941 | |
942 |
943 |
944 | |
945 | Returns unique sorted tags for every post.
946 |
947 |
948 |
949 |
950 | |
951 |
952 | allTags: function() {
953 | var allTags = [];
954 |
955 | for (var key in this.posts) {
956 | if (this.posts[key].tags) {
957 | for (var i = 0; i < this.posts[key].tags.length; i++) {
958 | var tag = this.posts[key].tags[i];
959 | if (allTags.indexOf(tag) === -1) allTags.push(tag);
960 | }
961 | }
962 | }
963 |
964 | allTags.sort(function(a, b) {
965 | a = a.toLowerCase();
966 | b = b.toLowerCase();
967 | if (a < b) return -1;
968 | if (a > b) return 1;
969 | return 0;
970 | });
971 |
972 | return allTags;
973 | },
974 | |
975 |
976 |
977 | |
978 | Get a set of posts for a tag.
979 |
980 |
981 |
982 | param: String Tag name return: Array
983 | |
984 |
985 | postsForTag: function(tag) {
986 | var posts = [];
987 | for (var key in this.posts) {
988 | if (this.posts[key].tags && this.posts[key].tags.indexOf(tag) !== -1) {
989 | posts.push(this.posts[key]);
990 | }
991 | }
992 | return posts;
993 | },
994 | |
995 |
996 |
997 | |
998 | Display a list of tags.
999 |
1000 | TODO Link options
1001 |
1002 |
1003 |
1004 | param: Array Tag names return: String
1005 | |
1006 |
1007 | tags: function(tags) {
1008 | return tags.map(function(tag) {
1009 | return '<a href="/tags.html#' + escape(tag) + '">' + tag + '</a>';
1010 | }).join(', ');
1011 | },
1012 | |
1013 |
1014 |
1015 | |
1016 | Renders a post using the hNews microformat, based on:
1017 |
1018 | http://www.readability.com/publishers/guidelines/#view-exampleGuidelines
1019 |
1020 |
1021 |
1022 |
1023 | |
1024 |
1025 | hNews: function(post, summary) {
1026 | var template = '';
1027 | template += 'article.hentry\n';
1028 | template += ' header\n';
1029 | template += ' h1.entry-title\n';
1030 | template += ' a(href=post.url) !{post.title}\n';
1031 | template += ' time.updated(datetime=dx(post.date), pubdate) #{ds(post.date)}\n';
1032 | if (post.author)
1033 | template += ' p.byline.author.vcard by <span class="fn">#{post.author}</span>\n';
1034 |
1035 | if (post.tags) template += ' div.tags !{tags(post.tags)}\n';
1036 |
1037 | if (summary) {
1038 | if (post.summary) {
1039 | template += ' !{post.summary + "<p><a class=\\"read-more\\" href=\\"' + post.url + '\\">Read More →</a></p>"}\n';
1040 | } else {
1041 | template += ' !{truncateParagraphs(post.content, 2, "<p><a class=\\"read-more\\" href=\\"' + post.url + '\\">Read More →</a></p>")}\n';
1042 | }
1043 | } else {
1044 | template += ' !{post.content}\n';
1045 | }
1046 | return jade.render(template, { locals: this.applyHelpers({ post: post }) });
1047 | },
1048 | |
1049 |
1050 |
1051 | |
1052 | Formats a date with date formatting rules according to underscore.date's rules.
1053 |
1054 |
1055 |
1056 |
1057 | |
1058 |
1059 | df: function(date, format) {
1060 | return _date(date).format(format);
1061 | },
1062 | |
1063 |
1064 |
1065 | |
1066 | Short date (01 January 2001).
1067 |
1068 |
1069 |
1070 |
1071 | |
1072 |
1073 | ds: function(date) {
1074 | return helpers.df(date, 'DD MMMM YYYY');
1075 | },
1076 | |
1077 |
1078 |
1079 | |
1080 | Atom date formatting.
1081 |
1082 |
1083 |
1084 |
1085 | |
1086 |
1087 | dx: function(date) {
1088 | return helpers.df(date, 'YYYY-MM-DDTHH:MM:ssZ');
1089 | },
1090 | |
1091 |
1092 |
1093 | |
1094 | RFC-822 dates.
1095 |
1096 |
1097 |
1098 |
1099 | |
1100 |
1101 | d822: function(date) {
1102 |
1103 | return helpers.df(date, 'ddd, DD MMM YYYY HH:MM:ss') + ' GMT';
1104 | },
1105 | |
1106 |
1107 |
1108 | |
1109 | Escapes brackets and ampersands.
1110 |
1111 |
1112 |
1113 |
1114 | |
1115 |
1116 | h: function(text) {
1117 | return text && text.replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
1118 | },
1119 | |
1120 |
1121 |
1122 | |
1123 | Truncates HTML based on paragraph counts.
1124 |
1125 |
1126 |
1127 | param: String Text to truncate param: Integer Number of paragraphs param: String Text to append when truncated return: String
1128 | |
1129 |
1130 | truncateParagraphs: function(text, length, moreText) {
1131 | var t = text.split('</p>');
1132 | return t.length < length ? text : t.slice(0, length).join('</p>') + '</p>' + moreText;
1133 | },
1134 | |
1135 |
1136 |
1137 | |
1138 | Truncates based on characters (not HTML safe, use with pre-formatted text).
1139 |
1140 |
1141 |
1142 |
1143 | |
1144 |
1145 | truncate: function(text, length, moreText) {
1146 | return text.length > length ? text.slice(0, length).trim() + moreText : text;
1147 | },
1148 | |
1149 |
1150 |
1151 | |
1152 | Truncates based on words (not HTML safe, use with pre-formatted text).
1153 |
1154 |
1155 |
1156 | param: String Text to truncate param: Integer Number of words param: String Text to append when truncated return: String
1157 | |
1158 |
1159 | truncateWords: function(text, length, moreText) {
1160 | var t = text.split(/\s/);
1161 | return t.length > length ? t.slice(0, length).join(' ') + moreText : text;
1162 | }
1163 | };
1164 |
1165 | module.exports = helpers;
1166 |
1167 | |
1168 |
| lib/log.js |
1169 | |
1170 | module.exports = {
1171 | enabled: true,
1172 |
1173 | info: function() {
1174 | if (this.enabled) console.log.apply(this, arguments);
1175 | },
1176 |
1177 | error: function() {
1178 | if (this.enabled) console.error.apply(this, arguments);
1179 | }
1180 | };
1181 | |
1182 |
1183 |
1184 | |
1185 |
| lib/paginator.js |
1186 | |
1187 | Initialize Paginator with the number of items per-page and a list of items.
1188 |
1189 |
1190 |
1191 |
1192 | |
1193 |
1194 | function Paginator(perPage, items) {
1195 | this.allItems = this.sort(items);
1196 | this.perPage = perPage;
1197 | this.items = this.allItems.slice(0, perPage);
1198 | this.previousPage = 0;
1199 | this.nextPage = 2;
1200 | this.page = 1;
1201 | this.pages = Math.round(this.allItems.length / this.perPage) + 1;
1202 | }
1203 | |
1204 |
1205 |
1206 | |
1207 | Moves to the next page.
1208 |
1209 |
1210 | |
1211 |
1212 | Paginator.prototype.advancePage = function() {
1213 | this.page++;
1214 | this.previousPage = this.page - 1;
1215 | this.nextPage = this.page + 1;
1216 |
1217 | var start = (this.page - 1) * this.perPage
1218 | , end = this.page * this.perPage;
1219 | this.items = this.allItems.slice(start, end);
1220 | };
1221 | |
1222 |
1223 |
1224 | |
1225 | Sort items according to date.
1226 |
1227 |
1228 |
1229 | param: Array Array of items return: Integer -1, 1, 0 according to the date comparison
1230 | |
1231 |
1232 | Paginator.prototype.sort = function(items) {
1233 | return items.sort(function(a, b) {
1234 | a = a.date.valueOf();
1235 | b = b.date.valueOf();
1236 | if (a > b)
1237 | return -1;
1238 | else if (a < b)
1239 | return 1;
1240 | return 0;
1241 | });
1242 | };
1243 |
1244 | module.exports = Paginator;
1245 |
1246 | |
1247 |
| lib/pop.js |
1248 | |
1249 | Module dependencies and local variables.
1250 |
1251 | |
1252 |
1253 | var path = require('path')
1254 | , fs = require(__dirname + '/../lib/graceful')
1255 | , FileMap = require(__dirname + '/file_map')
1256 | , SiteBuilder = require(__dirname + '/site_builder')
1257 | , cliTools = require(__dirname + '/cli_tools')
1258 | , readConfig = require(__dirname + '/config')
1259 | , log = require(__dirname + '/log');
1260 | |
1261 |
1262 |
1263 | |
1264 | Loads the config script and sets the local variable.
1265 |
1266 |
1267 |
1268 |
1269 | |
1270 |
1271 | function loadConfig() {
1272 | var root = process.cwd()
1273 | , config = readConfig(path.join(root, '_config.json'));
1274 | config.root = root;
1275 | return config;
1276 | }
1277 | |
1278 |
1279 |
1280 | |
1281 | Loads configuration then runs generateSite.
1282 |
1283 |
1284 |
1285 |
1286 | |
1287 |
1288 | function loadConfigAndGenerateSite(useServer, port) {
1289 | var config = loadConfig();
1290 | if (port) config.port = port;
1291 | generateSite(config, useServer);
1292 | }
1293 | |
1294 |
1295 |
1296 | |
1297 | Runs FileMap and SiteBuilder based on the config.
1298 |
1299 |
1300 |
1301 | params: Object Configuration options params: Boolean Use a HTTP sever? return: SiteBuilder A SiteBuilder instance
1302 | |
1303 |
1304 | function generateSite(config, useServer) {
1305 | var fileMap = new FileMap(config)
1306 | , siteBuilder = new SiteBuilder(config)
1307 | , server = require(__dirname + '/server')(siteBuilder);
1308 |
1309 | fileMap.walk();
1310 | fileMap.on('ready', function() {
1311 | siteBuilder.fileMap = fileMap;
1312 | siteBuilder.build();
1313 | });
1314 |
1315 | siteBuilder.once('ready', function() {
1316 | if (useServer) {
1317 | server.run();
1318 | server.watch();
1319 | }
1320 | });
1321 |
1322 | return siteBuilder;
1323 | }
1324 |
1325 | function build() {
1326 | var args = process.argv.slice(2)
1327 | , usage;
1328 | if (args.length === 0) return loadConfigAndGenerateSite();
1329 |
1330 | usage = 'pop is a static site builder.\n\n';
1331 | usage += 'Usage: pop [command] [options]\n';
1332 | usage += 'new path Generates a new site at path/\n';
1333 | usage += 'post "Post Title" Writes a new post file\n';
1334 | usage += 'render pattern Renders files that match "pattern"\n';
1335 | usage += 'server [port] Create a server on port (default: 4000) for _site/\n\n';
1336 | usage += '-v, --version Display version and exit\n';
1337 | usage += '-h, --help Shows this message\n';
1338 |
1339 | while (args.length) {
1340 | arg = args.shift();
1341 | switch (arg) {
1342 | case 'server':
1343 | loadConfigAndGenerateSite(true, args.shift());
1344 | break;
1345 | case 'post':
1346 | return cliTools.makePost(loadConfig(), args.shift(), function() { process.exit(0); });
1347 | break;
1348 | case 'new':
1349 | return cliTools.makeSite(args, function() { process.exit(0); });
1350 | break;
1351 | case 'render':
1352 | return cliTools.renderFile(module.exports, loadConfig(), args.shift());
1353 | break;
1354 | case '-v':
1355 | case '--version':
1356 | var version = JSON.parse(fs.readFileSync(__dirname + '/../package.json')).version;
1357 | log.info('pop version:', version);
1358 | process.exit(0);
1359 | break;
1360 | case '-h':
1361 | case '--help':
1362 | log.info(usage);
1363 | process.exit(1);
1364 | default:
1365 | loadConfigAndGenerateSite();
1366 | }
1367 | }
1368 | }
1369 |
1370 | module.exports = {
1371 | build: build
1372 | , SiteBuilder: SiteBuilder
1373 | , FileMap: FileMap
1374 | , generateSite: generateSite
1375 | , cliTools: cliTools
1376 | , log: log
1377 | };
1378 |
1379 | |
1380 |
| lib/server.js |
1381 | |
1382 | Module dependencies and local variables.
1383 |
1384 | |
1385 |
1386 | var path = require('path')
1387 | , watch = require('nodewatch')
1388 | , siteBuilder
1389 | , log = require(__dirname + '/log');
1390 | |
1391 |
1392 |
1393 | |
1394 | Instantiates and runs the Express server.
1395 |
1396 | |
1397 |
1398 | function server() {
1399 |
1400 | var express = require('express'),
1401 | app = express.createServer();
1402 |
1403 | app.configure(function() {
1404 | app.use(express.static(siteBuilder.outputRoot));
1405 | app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
1406 | });
1407 |
1408 |
1409 | app.get('*', function(req, res) {
1410 | var postPath = siteBuilder.outputRoot + req.url + '/';
1411 |
1412 | if (req.url.match(/[^/]$/) && path.existsSync(postPath)) {
1413 | res.redirect(req.url + '/');
1414 | } else {
1415 | res.send('404');
1416 | }
1417 | });
1418 |
1419 | app.listen(siteBuilder.config.port);
1420 | log.info('Listening on port', siteBuilder.config.port);
1421 | }
1422 | |
1423 |
1424 |
1425 | |
1426 | Watches for file changes and regenerates files as required.
1427 | ## TODO Work in progress
1428 |
1429 | |
1430 |
1431 | function watchChanges() {
1432 | function buildChange(file) {
1433 | log.info('File changed:', file);
1434 | try {
1435 | siteBuilder.buildChange(file);
1436 | } catch (e) {
1437 | log.error('Error building site:', e);
1438 | }
1439 | }
1440 |
1441 |
1442 | siteBuilder.fileMap.files.forEach(function(file) {
1443 | if (file.type === 'dir') {
1444 | watch.add(file.name).onChange(buildChange);
1445 | }
1446 | });
1447 | }
1448 |
1449 | module.exports = function(s) {
1450 | siteBuilder = s;
1451 | return {
1452 | run: server
1453 | , watch: watchChanges
1454 | };
1455 | };
1456 |
1457 |
1458 | |
1459 |
| lib/site_builder.js |
1460 | |
1461 | Module dependencies.
1462 |
1463 | |
1464 |
1465 | var textile = require('stextile')
1466 | , fs = require('./graceful')
1467 | , path = require('path')
1468 | , jade = require('jade')
1469 | , stylus = require('stylus')
1470 | , yamlish = require('yamlish')
1471 | , markdown = require('markdown-js')
1472 | , Paginator = require('./paginator')
1473 | , FileMap = require('./file_map.js').FileMap
1474 | , EventEmitter = require('events').EventEmitter
1475 | , filters = require('./filters')
1476 | , helpers = require('./helpers')
1477 | , userHelpers = {}
1478 | , userFilters = {}
1479 | , userPostFilters = {};
1480 | |
1481 |
1482 |
1483 | |
1484 | Initialize SiteBuilder with a config object and FileMap.
1485 |
1486 |
1487 |
1488 |
1489 | |
1490 |
1491 | function SiteBuilder(config, fileMap) {
1492 | this.config = config;
1493 | this.root = config.root;
1494 |
1495 | var helperFile = path.join(this.root, '_lib', 'helpers.js');
1496 | if (path.existsSync(helperFile)) {
1497 | userHelpers = require(helperFile);
1498 | }
1499 |
1500 | var filterFile = path.join(this.root, '_lib', 'filters.js');
1501 | if (path.existsSync(filterFile)) {
1502 | userFilters = require(filterFile);
1503 | }
1504 |
1505 | var postFilterFile = path.join(this.root, '_lib', 'post-filters.js');
1506 | if (path.existsSync(postFilterFile)) {
1507 | userPostFilters = require(postFilterFile);
1508 | }
1509 |
1510 | this.outputRoot = config.output;
1511 | this.fileMap = fileMap;
1512 | this.posts = [];
1513 | this.helpers = helpers;
1514 | this.events = new EventEmitter();
1515 | this.includes = {};
1516 |
1517 | this.loadPlugins();
1518 | }
1519 | |
1520 |
1521 |
1522 | |
1523 | Loads Pop plugins based on config.require.
1524 |
1525 | |
1526 |
1527 | SiteBuilder.prototype.loadPlugins = function() {
1528 | if (!this.config.require) return;
1529 | var self = this;
1530 |
1531 | this.config.require.forEach(function(name) {
1532 | try {
1533 | var plugin = require(name);
1534 | self.loadPlugin(name, plugin);
1535 | } catch (e) {
1536 | console.error('Unable to load plugin:', name, '-', e.message);
1537 | throw(e);
1538 | }
1539 | });
1540 | };
1541 | |
1542 |
1543 |
1544 | |
1545 | Applies helpers and "user helpers" to an object so it can be easily passed to Jade.
1546 |
1547 |
1548 |
1549 | param: String The name of the plugin param: Object The plugin's module. Properties loaded: helpers, filters, postFilters
1550 | |
1551 |
1552 | SiteBuilder.prototype.loadPlugin = function(name, plugin) {
1553 | if (!plugin) return;
1554 |
1555 | for (key in plugin.helpers) {
1556 | if (plugin.helpers.hasOwnProperty(key))
1557 | userHelpers[key] = this.bind(plugin.helpers[key]);
1558 | }
1559 |
1560 | for (key in plugin.filters) {
1561 | if (plugin.filters.hasOwnProperty(key))
1562 | userFilters[key] = this.bind(plugin.filters[key]);
1563 | }
1564 |
1565 | for (key in plugin.postFilters) {
1566 | if (plugin.postFilters.hasOwnProperty(key))
1567 | userPostFilters[key] = this.bind(plugin.postFilters[key]);
1568 | }
1569 | };
1570 | |
1571 |
1572 |
1573 | |
1574 | Applies helpers and "user helpers" to an object so it can be easily passed to Jade.
1575 |
1576 |
1577 |
1578 |
1579 | |
1580 |
1581 | SiteBuilder.prototype.applyHelpers = function(obj) {
1582 | var self = this
1583 | , key;
1584 |
1585 | for (key in this.helpers) {
1586 | obj[key] = this.bind(this.helpers[key]);
1587 | }
1588 |
1589 | for (key in userHelpers) {
1590 | obj[key] = this.bind(userHelpers[key]);
1591 | }
1592 |
1593 | obj.include = function(template) {
1594 | return self.includes[template];
1595 | };
1596 |
1597 |
1598 | if (obj.paginate && obj.paginator)
1599 | obj.paginate = obj.paginate(obj.paginator);
1600 |
1601 | obj.site = self;
1602 |
1603 | return obj;
1604 | };
1605 | |
1606 |
1607 |
1608 | |
1609 | Binds methods to this SiteBuilder.
1610 |
1611 |
1612 |
1613 |
1614 | |
1615 |
1616 | SiteBuilder.prototype.bind = function(fn) {
1617 | var self = this;
1618 | return function() {
1619 | return fn.apply(self, arguments);
1620 | };
1621 | };
1622 | |
1623 |
1624 |
1625 | |
1626 | Builds the site. This is asynchronous, so various counters
1627 | and events are used to track progress.
1628 |
1629 |
1630 | |
1631 |
1632 | SiteBuilder.prototype.build = function() {
1633 | var self = this;
1634 |
1635 | function build() {
1636 | var posts = self.findPosts()
1637 | , otherFiles = self.otherRenderedFiles()
1638 | , staticFiles = self.staticFiles()
1639 | , autoGen = self.autoGenerate();
1640 |
1641 | function renderPost() {
1642 | if (posts.length) {
1643 | var file = posts.pop();
1644 | self.renderPost(file, function() {
1645 | self.events.emit('render post');
1646 | });
1647 | } else {
1648 | self.events.emit('render autoGen');
1649 | }
1650 | }
1651 |
1652 | function renderAutoGen() {
1653 | if (autoGen.length) {
1654 | var file = autoGen.pop();
1655 | self.autoGenerateFile(file, function() {
1656 | self.events.emit('render autoGen');
1657 | });
1658 | } else {
1659 | self.events.emit('check finished');
1660 | }
1661 | }
1662 |
1663 | function renderOtherFile() {
1664 | if (otherFiles.length) {
1665 | var file = otherFiles.pop();
1666 | self.renderFile(file, function() {
1667 | self.events.emit('render otherFile');
1668 | });
1669 | } else {
1670 | self.events.emit('check finished');
1671 | }
1672 | }
1673 |
1674 | function renderStaticFile() {
1675 | if (staticFiles.length) {
1676 | var file = staticFiles.pop();
1677 | self.copyStatic(file, function() {
1678 | self.events.emit('render staticFile');
1679 | });
1680 | } else {
1681 | self.events.emit('check finished');
1682 | }
1683 | }
1684 |
1685 | function checkFinished() {
1686 | var filesLeft = posts.length + otherFiles.length + staticFiles.length + autoGen.length;
1687 | if (filesLeft === 0) {
1688 | self.events.emit('ready');
1689 | }
1690 | }
1691 |
1692 | self.events.on('render post', renderPost);
1693 | self.events.on('render autoGen', renderAutoGen);
1694 | self.events.on('render otherFile', renderOtherFile);
1695 | self.events.on('render staticFile', renderStaticFile);
1696 | self.events.on('check finished', checkFinished);
1697 |
1698 | self.events.emit('render post');
1699 | self.events.emit('render otherFile');
1700 | self.events.emit('render staticFile');
1701 | }
1702 |
1703 | this.events.once('cached includes', build);
1704 | this.cacheIncludes();
1705 | };
1706 | |
1707 |
1708 |
1709 | |
1710 | Returns any configured built-in pages,
1711 | or an empty array.
1712 |
1713 |
1714 |
1715 |
1716 | |
1717 |
1718 | SiteBuilder.prototype.autoGenerate = function() {
1719 | if (!this.config.autoGenerate) return [];
1720 | return this.config.autoGenerate;
1721 | };
1722 | |
1723 |
1724 |
1725 | |
1726 | Generates a built-in page. Only atom feeds and RSS
1727 | are currently available.
1728 |
1729 |
1730 |
1731 |
1732 | |
1733 |
1734 | SiteBuilder.prototype.autoGenerateFile = function(file, fn) {
1735 |
1736 | var self = this;
1737 |
1738 | if (file.feed) {
1739 | if (!this.config.url || !this.config.title) {
1740 | console.error('Error: Built-in feed generation requires config values for: url and title.');
1741 | } else {
1742 | var layoutData = "!{atom('" + this.config.url + '/' + file.feed + "')}"
1743 | , html = jade.render(layoutData, { locals: self.applyHelpers({ }) });
1744 | this.write(this.outFileName(file.feed), html);
1745 | fn();
1746 | }
1747 | }
1748 |
1749 | if (file.rss) {
1750 | if (!this.config.url || !this.config.title) {
1751 | console.error('Error: Built-in feed generation requires config values for: url and title.');
1752 | } else {
1753 | var layoutData = "!{rss('" + this.config.url + '/' + file.rss + "')}"
1754 | , html = jade.render(layoutData, { locals: self.applyHelpers({ }) });
1755 | this.write(this.outFileName(file.rss), html);
1756 | fn();
1757 | }
1758 | }
1759 | };
1760 | |
1761 |
1762 |
1763 | |
1764 | Determines if a file needs Jade or Stylus rendering.
1765 |
1766 |
1767 |
1768 |
1769 | |
1770 |
1771 | SiteBuilder.prototype.isRenderedFile = function(file) {
1772 | return file.type === 'file jade' || file.type === 'file styl';
1773 | };
1774 | |
1775 |
1776 |
1777 | |
1778 | Builds a single file.
1779 | ## TODO Work in progress.
1780 |
1781 |
1782 |
1783 |
1784 | |
1785 |
1786 | SiteBuilder.prototype.buildChange = function(file) {
1787 | if (this.fileMap.isExcludedFile(file)) return;
1788 |
1789 | file = {
1790 | type: this.fileMap.fileType(file)
1791 | , name: file
1792 | };
1793 |
1794 | if (file.type.indexOf('post') !== -1) {
1795 | this.renderPost(file);
1796 | } else if (this.isRenderedFile(file)) {
1797 | this.renderFile(file);
1798 | } else if (file.type === 'file') {
1799 | this.copyStatic(file);
1800 | }
1801 | };
1802 | |
1803 |
1804 |
1805 | |
1806 | Iterates over the files in the FileMap object to find posts.
1807 |
1808 |
1809 |
1810 |
1811 | |
1812 |
1813 | SiteBuilder.prototype.findPosts = function() {
1814 | return this.fileMap.files.filter(function(file) {
1815 | return file.type.indexOf('post') !== -1;
1816 | });
1817 | };
1818 | |
1819 |
1820 |
1821 | |
1822 | Iterates over the files in the FileMap object to find "other" rendered files.
1823 |
1824 |
1825 |
1826 |
1827 | |
1828 |
1829 | SiteBuilder.prototype.otherRenderedFiles = function() {
1830 | var self = this;
1831 | return this.fileMap.files.filter(function(file) {
1832 | return self.isRenderedFile(file);
1833 | });
1834 | };
1835 | |
1836 |
1837 |
1838 | |
1839 | Iterates over the files in the FileMap object to find static files that require copying.
1840 |
1841 |
1842 |
1843 |
1844 | |
1845 |
1846 | SiteBuilder.prototype.staticFiles = function() {
1847 | return this.fileMap.files.filter(function(file) {
1848 | return file.type === 'file';
1849 | });
1850 | };
1851 | |
1852 |
1853 |
1854 | |
1855 | Copies a static file.
1856 |
1857 |
1858 |
1859 |
1860 | |
1861 |
1862 | SiteBuilder.prototype.copyStatic = function(file, fn) {
1863 | var outDir = this.outFileName(path.dirname(file.name.replace(this.root, '')))
1864 | , fileName = path.join(outDir, path.basename(file.name))
1865 | , self = this;
1866 |
1867 |
1868 | if (path.basename(file.name).match(/^_/)) return fn.apply(self);
1869 |
1870 | fs.mkdir_p(outDir, 0777, function(err) {
1871 | if (err) {
1872 | console.error('Error creating directory:', outDir);
1873 | throw(err);
1874 | }
1875 |
1876 | fs.readFile(file.name, function(err, data) {
1877 | if (err) {
1878 | console.error('Error reading file:', file.name);
1879 | throw(err);
1880 | }
1881 |
1882 | fs.writeFile(fileName, data, function(err) {
1883 | if (err) {
1884 | console.error('Error writing file:', fileName);
1885 | throw(err);
1886 | }
1887 |
1888 | if (fn) fn.apply(self);
1889 | });
1890 | });
1891 | });
1892 | };
1893 | |
1894 |
1895 |
1896 | |
1897 | Parse YAML meta data for both files and posts.
1898 |
1899 |
1900 |
1901 | param: String File name (used by logging on errors) param: String Data to parse return: Array Parsed YAML
1902 | |
1903 |
1904 | SiteBuilder.prototype.parseMeta = function(file, data) {
1905 | function clean(yaml) {
1906 | for (var key in yaml) {
1907 | if (typeof yaml[key] === 'string') {
1908 | var m = yaml[key].match(/^"([^"]*)"$/);
1909 | if (m) yaml[key] = m[1];
1910 | }
1911 | }
1912 | return yaml;
1913 | }
1914 |
1915 |
1916 | function fix(text) {
1917 | if (!text) return;
1918 | return text.split('\n').map(function(line) {
1919 | if (line.match(/^- /))
1920 | line = ' ' + line;
1921 | return line;
1922 | }).join('\n');
1923 | }
1924 |
1925 | var dataChunks = data.split('---')
1926 | , parsedYAML = [];
1927 |
1928 | try {
1929 | if (dataChunks[1]) {
1930 |
1931 | parsedYAML = clean(yamlish.decode(fix(dataChunks[1] || data)));
1932 | return [parsedYAML, ((dataChunks || []).slice(2).join('---')).trim()];
1933 | } else {
1934 | return ['', data];
1935 | }
1936 | } catch (e) {
1937 | console.error("Couldn't parse YAML in:", file, ':', e);
1938 | }
1939 | };
1940 | |
1941 |
1942 |
1943 | |
1944 | Writes a file, making directories recursively when required.
1945 |
1946 |
1947 |
1948 |
1949 | |
1950 |
1951 | SiteBuilder.prototype.write = function(fileName, content) {
1952 | if (!content) return console.error('No content for:', fileName);
1953 |
1954 |
1955 | content = this.applyPostFilters(content);
1956 |
1957 | fs.mkdir_p(path.dirname(fileName), 0777, function(err) {
1958 | if (err) {
1959 | console.error('Error creating directory:', path.dirname(fileName));
1960 | throw(err);
1961 | }
1962 |
1963 | fs.writeFile(fileName, content, function(err) {
1964 | if (err) {
1965 | console.error('Error writing file:', fileName);
1966 | throw(err);
1967 | }
1968 | });
1969 | });
1970 | };
1971 | |
1972 |
1973 |
1974 | |
1975 | Returns a full path name.
1976 |
1977 |
1978 |
1979 |
1980 | |
1981 |
1982 | SiteBuilder.prototype.outFileName = function(subDir, name) {
1983 | return path.join(this.outputRoot, subDir, name);
1984 | };
1985 | |
1986 |
1987 |
1988 | |
1989 | Caches templates inside _includes/
1990 |
1991 | |
1992 |
1993 | SiteBuilder.prototype.cacheIncludes = function() {
1994 | var self = this;
1995 |
1996 | function done() {
1997 | self.events.emit('cached includes');
1998 | }
1999 |
2000 | path.exists(path.join(this.root, '_includes'), function(exists) {
2001 | if (!exists) {
2002 | done();
2003 | } else {
2004 | fs.readdir(path.join(self.root, '_includes'), function(err, files) {
2005 | if (!files) return;
2006 | var file;
2007 |
2008 | if (files.length === 0) done();
2009 |
2010 | for (var i = 0; i < files.length; i++) {
2011 | file = files[i];
2012 |
2013 | if (path.extname(file) !== '.jade') {
2014 | if (i === files.length) return self.events.emit('cached includes');
2015 | } else {
2016 | fs.readFile(path.join(self.root, '_includes', file), 'utf8', function(err, data) {
2017 |
2018 | var html = jade.render(data, { locals: self.applyHelpers({}) })
2019 | , name = path.basename(file).replace(path.extname(file), '');
2020 | self.includes[name] = html;
2021 |
2022 | if (i === files.length) done();
2023 | });
2024 | }
2025 | }
2026 | });
2027 | }
2028 | });
2029 | };
2030 | |
2031 |
2032 |
2033 | |
2034 | Renders a post using a template. Called by renderPost.
2035 |
2036 |
2037 |
2038 | param: String Template file name param: Object A post object param: String The post's content
2039 | |
2040 |
2041 | SiteBuilder.prototype.renderTemplate = function(templateFile, post, content) {
2042 | var self = this;
2043 | templateFile = path.join(this.root, '_layouts', templateFile + '.jade');
2044 |
2045 | fs.readFile(templateFile, 'utf8', function(err, data) {
2046 | if (err) {
2047 | console.error('Error in: ' + templateFile);
2048 | console.error(err);
2049 | console.error(err.message);
2050 | throw(err);
2051 | }
2052 |
2053 | try {
2054 | var html = jade.render(data, { locals: self.applyHelpers({ post: post, content: content }) })
2055 | , fileName = self.outFileName(post.fileName, 'index.html')
2056 | , dirName = path.dirname(fileName);
2057 | } catch (e) {
2058 | console.error('Error rendering:', templateFile);
2059 | throw(e);
2060 | }
2061 |
2062 | path.exists(dirName, function(exists) {
2063 | if (exists) {
2064 | self.write(fileName, html);
2065 | } else {
2066 | fs.mkdir_p(dirName, 0777, function(err) {
2067 | if (err) {
2068 | console.error('Error making directory:', dirName);
2069 | throw(err);
2070 | }
2071 | self.write(fileName, html);
2072 | });
2073 | }
2074 | });
2075 | });
2076 | };
2077 | |
2078 |
2079 |
2080 | |
2081 | Renders a generic Jade file and will supply pagination if required.
2082 |
2083 |
2084 |
2085 |
2086 | |
2087 |
2088 | SiteBuilder.prototype.renderFile = function(file, fn) {
2089 | var self = this;
2090 |
2091 | if (file.type === 'file styl') {
2092 | var outFileName = self.outFileName(
2093 | path.dirname(file.name.replace(self.root, '')),
2094 | path.basename(file.name).replace(path.extname(file.name), '.css')
2095 | );
2096 |
2097 | return fs.readFile(file.name, 'utf8', function(err, fileData) {
2098 | stylus.render(fileData, { filename: path.basename(outFileName) }, function(err, css) {
2099 | if (err) throw err;
2100 | self.write(outFileName, css);
2101 | if (fn) fn.apply(self);
2102 | });
2103 | });
2104 | }
2105 |
2106 | function render(fileData, meta, layoutData, dirName) {
2107 |
2108 | var ext = path.basename(file.name).match('\\.[^.]*\\' + path.extname(file.name) + '$') ? '' : '.html';
2109 | dirName = dirName || '';
2110 |
2111 | var outFileName = self.outFileName(
2112 | path.dirname(file.name.replace(self.root, '')) + dirName,
2113 | path.basename(file.name).replace(path.extname(file.name), ext)
2114 | );
2115 |
2116 | var fileContent = jade.render(fileData, {
2117 | locals: self.applyHelpers({ paginator: self.paginator, page: meta }),
2118 | });
2119 |
2120 | if (!layoutData) {
2121 | self.write(outFileName, fileContent);
2122 | } else {
2123 | var html = jade.render(layoutData, { locals: self.applyHelpers({ content: fileContent }) });
2124 | self.write(outFileName, html);
2125 | }
2126 |
2127 | if (fn) fn.apply(self);
2128 | }
2129 |
2130 | fs.readFile(file.name, 'utf8', function(err, fileData) {
2131 | var meta = self.parseMeta(file.name, fileData)
2132 | , fileContent = '';
2133 |
2134 | fileData = meta[1];
2135 | meta = meta[0];
2136 |
2137 | if (!meta.layout) {
2138 | self.paginator = new Paginator(self.config.perPage, self.posts);
2139 | render(fileData, meta);
2140 | } else {
2141 | fs.readFile(path.join(self.root, '_layouts', meta.layout + '.jade'), function(err, layoutData) {
2142 | if (err) {
2143 | console.error('Unable to read layout:', meta.layout + '.jade');
2144 | throw(err);
2145 | }
2146 |
2147 |
2148 | self.paginator = new Paginator(self.config.perPage, self.posts)
2149 | render(fileData, meta, layoutData);
2150 |
2151 | if (meta.paginate) {
2152 | while (self.paginator.items.length) {
2153 | self.paginator.advancePage();
2154 | render(fileData, meta, layoutData, '/page' + self.paginator.page + '/');
2155 | }
2156 | }
2157 | });
2158 | }
2159 | });
2160 | };
2161 | |
2162 |
2163 |
2164 | |
2165 | Parses a file name according to the permalink format.
2166 |
2167 |
2168 |
2169 |
2170 | |
2171 |
2172 | SiteBuilder.prototype.parseFileName = function(fileName) {
2173 | var format = this.config.permalink
2174 | , parts = fileName.match(/(\d+)-(\d+)-(\d+)-(.*)/)
2175 | , year = parts[1]
2176 | , month = parts[2]
2177 | , day = parts[3]
2178 | , title = parts[4].replace(/\.(textile|md)/, '');
2179 |
2180 | return { date: new Date(Date.UTC(year, month - 1, day)),
2181 | fileName: format.replace(':year', year).
2182 | replace(':month', month).
2183 | replace(':day', day).
2184 | replace(':title', title) };
2185 | };
2186 | |
2187 |
2188 |
2189 | |
2190 | Applies internal and user-supplied content pre-filters.
2191 |
2192 |
2193 |
2194 |
2195 | |
2196 |
2197 | SiteBuilder.prototype.applyFilters = function(text) {
2198 | for (var key in filters) {
2199 | text = filters[key](text);
2200 | }
2201 |
2202 | for (key in userFilters) {
2203 | text = userFilters[key].apply(this, [text]);
2204 | }
2205 |
2206 | return text;
2207 | };
2208 | |
2209 |
2210 |
2211 | |
2212 | Applies user-supplied content post-filters. These are run after HTML is generated.
2213 |
2214 |
2215 |
2216 |
2217 | |
2218 |
2219 | SiteBuilder.prototype.applyPostFilters = function(text) {
2220 | for (key in userPostFilters) {
2221 | text = userPostFilters[key].apply(this, [text]);
2222 | }
2223 |
2224 | return text;
2225 | };
2226 | |
2227 |
2228 |
2229 | |
2230 | Renders a post.
2231 |
2232 |
2233 |
2234 |
2235 | |
2236 |
2237 | SiteBuilder.prototype.renderPost = function(file, fn) {
2238 | var self = this
2239 | , formatter;
2240 |
2241 | if (file.type.indexOf('textile') !== -1) {
2242 | formatter = textile;
2243 | } else if (file.type.indexOf('md') !== -1) {
2244 | formatter = markdown.makeHtml;
2245 | }
2246 |
2247 | fs.readFile(file.name, 'utf8', function(err, data) {
2248 | var meta = self.parseMeta(file.name, data);
2249 | data = meta[1];
2250 | meta = meta[0];
2251 |
2252 |
2253 | if (!meta.tags) meta.tags = meta.categories ? meta.categories : [];
2254 |
2255 | if (data && meta) {
2256 | var fileDetails = self.parseFileName(file.name);
2257 | meta.fileName = fileDetails.fileName;
2258 | meta.url = fileDetails.fileName;
2259 | meta.date = fileDetails.date;
2260 | meta.content = formatter(self.applyFilters(data));
2261 |
2262 | if (meta.summary)
2263 | meta.summary = formatter(self.applyFilters(meta.summary));
2264 |
2265 | self.renderTemplate(meta.layout, meta, meta.content);
2266 | self.posts.push(meta);
2267 | }
2268 |
2269 | if (fn) fn.apply(self);
2270 | });
2271 | };
2272 | |
2273 |
2274 |
2275 | |
2276 | Adds a listener to the internal EventEmitter object.
2277 |
2278 |
2279 |
2280 |
2281 | |
2282 |
2283 | SiteBuilder.prototype.on = function(eventName, fn) {
2284 | this.events.on(eventName, fn);
2285 | };
2286 | |
2287 |
2288 |
2289 | |
2290 | Adds a listener to the internal EventEmitter object.
2291 |
2292 |
2293 |
2294 |
2295 | |
2296 |
2297 | SiteBuilder.prototype.once = function(eventName, fn) {
2298 | this.events.once(eventName, fn);
2299 | };
2300 |
2301 | module.exports = SiteBuilder;
2302 |
2303 | |
2304 |
2305 | 