forb

forb.c (38716B)

---

 #! /usr/bin/env sheepy
 #include "libsheepyObject.h"
 #include "shpPackages/short/short.h"
 #include "shpPackages/preprocessor/preprocessor.h"
 #include "shpPackages/simpleTemplates/simpleTemplates.h"
 #include "forb.h"
 
 // forb new: copy templates to current directory
 // forb:     generate static blog in the _site directory
 
 // Steps
 // read arguments
 // check inputs
 // load config
 // copy main css
 // copy images
 // generate index
   // read posts
   // generate html code for each post for index.html
   // create configuation for index
 // generate about
 // generate posts
 // generate feed.xml
 // clean tmp files
 
 #define configFile "_config.yml"
 #define indexFile "index.html"
 #define layoutDir "_layouts"
 #define draftsDir "_drafts"
 #define PostsDir "_posts"
 #define publishedDir "_published"
 #define siteDir "_site"
 #define mainCss "css/main.css"
 #define imagesDir "images"
 #define content "{{ content }}"
 
 /* enable/disable logging */
 /* #undef pLog */
 /* #define pLog(...) */
 
 void help(void);
 
 void publish(const char *path);
 
 void update(const char *path);
 
 bool readFileWithFrontMatter(char *filename, smallJsont *kv, smallArrayt *lines);
 
 bool generateAPageOrAPost(char *filename, smallJsont *cfg, smallArrayt *postsFeed);
 
 int main(int ARGC, char** ARGV) {
 
   initLibsheepy(ARGV[0]);
   setLogMode(LOG_FUNC);
   //openProgLogFile();
   setLogSymbols(LOG_UTF8);
   //disableLibsheepyErrorLogs;
 
   // steps
   // process command line arguments
   // arg new
   //   create directory structure when config file is not found
   //   else create a draft
   // arg help
   //   print help
   // arg publish
   //   copy draft to post dir, the date field is updated
   // arg update
   //   copy published post to post dir, the date field is updated
   // when there are no arguments, generate the blog
   // check inputs
   // load config
   // copy main css
   // copy images
   // generate index
   //   read posts
   //   list all md files in _posts and _published
   //   generate html code for each post for index.html
   //   create configuation for index
   // save index
   // generate about page
   // generate posts
   //   collect html code for 10 last post for feed.xml
   // generate feed.xml
   // clean tmp files
   // list all md files in _posts
   // move posts from _posts to _published
   // add first publish date if needed
 
   // read arguments
   #define checkInput(path) procbegin\
     if (not isPath(path)) {\
       logE(BLD"%s not found."RST"\n"\
           , path);\
       help();\
       XFailure;\
     }\
     procend
 
   if (ARGC > 1) {
     if (eqG(ARGV[1], "new") and not isPath(configFile)) {
       // create directory structure when config file is not found
       bool a;
       if (a = isPath("about.md")) {
         if (a) logE("about.md already exists.");
         logE("Stop.");
         XFailure;
       }
       cleanCharP(progPath) = shDirname(getRealProgPath());
       logCommandf("cp -R %s/template/* .", progPath);
       XSuccess;
     }
     elif (eqG(ARGV[1], "new")) {
       // create a draft
       checkInput(draftsDir);
       if (ARGC < 3) {
         logE(BLD"Too few arguments"RST", post title missing.\n"
              "forb new "BLD"TITLE"RST"\n"
             );
         XFailure;
       }
       // create post title and filename
       cleanListP(args) = dupG(ARGV);
       delElemG(&args, 1);
       delElemG(&args, 0);
       cleanCharP(title) = joinG(args, ' ');
       uniqG(&title, ' ');
       //lv(title);
       cleanCharP(draftName) = dupG(title);
       char *tmp = draftName;
       while(*tmp++) {
         if (*tmp and not isalnum(*tmp)) {
           *tmp = '-';
         }
       }
       lowerG(&draftName);
       uniqG(&draftName, '-');
       prependG(&draftName, draftsDir"/");
       pushG(&draftName, ".markdown");
       //lv(draftName);
       cleanCharP(defaultDraft) = replaceG(draftTemplate, "$TITLE", title, 1);
       writeFileG(defaultDraft, draftName);
       logP(BLD GRN"Generated %s\n"RST
           "Open %s in your text editor and write your post.", draftName, draftName);
       XSuccess;
     }
     elif (eqG(ARGV[1], "-h") or eqG(ARGV[1], "--help") or eqG(ARGV[1], "help")) {
       help();
       XSuccess;
     }
     elif (eqG(ARGV[1], "publish") or eqG(ARGV[1], "post")) {
       // copy draft to post dir
       if (ARGC < 3) {
         logE("publish failed. Missing path, usage:\n"
              "forb publish PATH"
              );
         XFailure;
       }
       rangeFrom(i, 2, ARGC) {
         if (not isPath(ARGV[i])) {
           logE("Path %d '%s' not found", i, ARGV[i]);
         }
         else {
           checkInput(draftsDir);
           checkInput(PostsDir);
           publish(ARGV[i]);
         }
       }
       XSuccess;
     }
     elif (eqG(ARGV[1], "update")) {
       // copy published post to post dir, the date field is updated
       if (ARGC < 3) {
         logE("update failed. Missing path, usage:\n"
              "forb update PATH"
              );
         XFailure;
       }
       rangeFrom(i, 2, ARGC) {
         if (not isPath(ARGV[i])) {
           logE("Path %d '%s' not found", i, ARGV[i]);
         }
         else {
           checkInput(publishedDir);
           checkInput(PostsDir);
           update(ARGV[i]);
         }
       }
       XSuccess;
     }
     else {
       logE("Command "BLD"'%s'"RST" not found or invalid parameters.\n\n"
            , ARGV[1]);
       help();
       XFailure;
     }
   }
 
   // when there are no arguments, generate the blog
 
   // check inputs
   checkInput(configFile);
   checkInput(indexFile);
   checkInput(layoutDir);
 
   // load config
   cleanAllocateSmallJson(cfg);
   readFileG(cfg, configFile);
 
   if (not isPath(siteDir)) {
     mkdirParents(siteDir);
   }
 
   // copy main css
   if (not isPath(siteDir"/css")) {
     mkdirParents(siteDir"/css");
   }
   copy(mainCss, siteDir"/"mainCss);
 
   // copy images
   if (not isPath(siteDir"/"imagesDir)) {
     mkdirParents(siteDir"/"imagesDir);
   }
   command("cp "imagesDir"/* "siteDir"/"imagesDir"/");
 
 
   // generate index
   cleanAllocateSmallArray(indexf);
   cleanAllocateSmallJson(indexCfg);
   readFileWithFrontMatter(indexFile, indexCfg, indexf);
 
     // read posts
     // list all md files in _posts and _published
   cleanSmallArrayP(postsDir) = readDirG(rtSmallArrayt, PostsDir);
   iter(postsDir, L) {
     castS(l,L);
     if (not endsWithG(l, ".markdown")) {
       delElemG(postsDir, iterIndexG(postsDir));
     }
   }
   //lv(postsDir);
   cleanSmallArrayP(pubDir)   = readDirG(rtSmallArrayt, publishedDir);
   iter(pubDir, L) {
     castS(l,L);
     if (not endsWithG(l, ".markdown")) {
       delElemG(pubDir, iI(pubDir));
     }
   }
   appendNFreeG(postsDir, dupG(pubDir));
   compactG(postsDir);
   sortG(postsDir);
 
     // generate html code for each post for index.html
   cleanAllocateSmallArray(postsIndex);
   iterLast(postsDir, L) {
     castS(l,L);
     cleanCharP(postHtmlFile) = copyRngG(ssGet(l), 11, 0);
     replaceG(&postHtmlFile, ".markdown", ".html", 1);
     // determine if file is in _posts or _published
     if (hasG(pubDir, l)) {
       // file is in _published
       prependG(l, publishedDir"/");
     }
     else {
       prependG(l, PostsDir"/");
     }
     setPG(postsDir, iI(postsDir), l);
     cleanAllocateSmallJson(postCfg);
     cleanAllocateSmallArray(postf);
     readFileWithFrontMatter(ssGet(l), postCfg, postf);
     // select first publish date for html path: root/category/YY/MM/DD/postName.html
     cleanCharP(postDate) = hasG(postCfg, "firstPublishDate") ? copyRngG($(postCfg, "firstPublishDate"), 0, 10) : copyRngG($(postCfg, "date"), 0, 10);
     replaceG(&postDate, "-", "/", 0);
     cleanSmallArrayP(postUrlA) = createSA($(cfg, "baseurl"),
         $(postCfg, "categories"), postDate, postHtmlFile);
     cleanCharP(postUrl) = joinSG(postUrlA, "/");
     // char *date is the visible date string: 'date' when the post is published for the first time, 'firstPublishDate update on date' when the post has been updated
     cleanCharP(date);
     if (hasG(postCfg, "firstPublishDate")) {
       if (eqG($(postCfg, "date"), $(postCfg, "firstPublishDate"))) goto onlyPublishDate;
       // there is an update date
       $(postCfg, "date")[10] = 0;
       $(postCfg, "firstPublishDate")[10] = 0;
       date = catS($(postCfg, "firstPublishDate"), " updated on ", $(postCfg, "date"));
     }
     else {
       onlyPublishDate:
       $(postCfg, "date")[10] = 0;
       date = dupG($(postCfg, "date"));
     }
     cleanCharP(s) = formatS("<li>\n"
                       "  <span class=\"post-meta\">%s</span>\n"
                       "\n"
                       "  <h2>\n"
                       "    <a class=\"post-link\" href=\"%s\">%s</a>\n"
                       "  </h2>\n"
                       "</li>\n"
                       ,date, postUrl, $(postCfg, "title"));
     pushG(postsIndex, s);
   }
   //cleanCharP(postsIndexS) = joinSG(postsIndex, "\n");
   //lv(postsIndexS);
 
   iter(indexf, L) {
     castS(l,L);
     if (hasG(l, "{{ posts }}")) {
       delElemG(indexf, iterIndexG(indexf));
       insertNFreeG(indexf, iterIndexG(indexf), dupG(postsIndex));
       break;
     }
   }
 
   cleanCharP(layoutFile) = catS(layoutDir,"/",$(indexCfg, "layout"),".html");
 
   //lv(layoutFile);
 
   var index = preprocess(layoutFile);
 
   iter(index, L) {
     castS(l,L);
     if (hasG(l, content)) {
       delElemG(index, iterIndexG(index));
       insertNFreeG(index, iterIndexG(index), dupG(indexf));
       break;
     }
   }
 
   //logG(index);
 
     // create configuation for index
 
   /* // TODO list all md files in dir (the pages) */
   /* cleanSmallArrayP(pages) = readDirG(rtSmallArrayt, "."); */
   /* iter(pages, L) { */
   /*   castS(l,L); */
   /*   if (not endsWithG(l, ".md")) { */
   /*     delElemG(pages, iterIndexG(pages)); */
   /*   } */
   /* } */
   /* lv(pages); */
 
   cleanAllocateSmallArray(about);
   cleanAllocateSmallJson(aboutCfg);
   readFileWithFrontMatter("about.md", aboutCfg, about);
 
     // page list on first line on all pages
   char *sitePages = catS("<a class=\"page-link\" href=\"", $(cfg, "baseurl"), $(aboutCfg, "permalink"), "\">", $(aboutCfg, "title"), "</a>");
 
   cleanAllocateSmallDict(pageValues);
 
   setNFreeG(pageValues, "_\%title", getNDupO(cfg, "title"));
   setNFreeG(pageValues, "_\%description", getNDupO(cfg, "description"));
   setNFreeG(pageValues, "_\%site.description", getNDupO(cfg, "description"));
   setNFreeG(pageValues, "_\%css", catS($(cfg, "baseurl"), "/css/main.css"));
   setNFreeG(pageValues, "_\%url", catS($(cfg, "url"), $(cfg, "baseurl")));
   setNFreeG(pageValues, "_\%site.title", getNDupO(cfg, "title"));
   setNFreeG(pageValues, "_\%feed", catS($(cfg, "url"), $(cfg, "baseurl"), "/feed.xml"));
   setNFreeG(pageValues, "_\%baseurl", getNDupO(cfg, "baseurl"));
   setNFreeG(pageValues, "_\%site.pages", sitePages);
   setNFreeG(pageValues, "_\%site.email", getNDupO(cfg, "email"));
   setNFreeG(pageValues, "_\%site.github_username", getNDupO(cfg, "github_username"));
   setNFreeG(pageValues, "_\%site.twitter_username", getNDupO(cfg, "twitter_username"));
 
   //lv(pageValues);
 
   simpleTemplatesReplaceKeysWithValues(index, pageValues);
 
   //logG(index);
 
   // save index
   writeFileG(index, siteDir"/index.html");
 
 
   // generate about page
   generateAPageOrAPost("about.md", cfg, null/*postsFeed*/);
 
   // generate posts
   cleanAllocateSmallArray(postsFeed);
 
   int count = 0;
   iterLast(postsDir, L) {
     castS(l,L);
     // collect html code for 10 last post for feed.xml
     generateAPageOrAPost(ssGet(l), cfg, count++ < 10 ? postsFeed : null);
   }
 
   // generate feed.xml
   cleanAllocateSmallArray(feed);
   cleanAllocateSmallJson(feedCfg);
   readFileWithFrontMatter("feed.xml", feedCfg, feed);
 
   //lv(feedCfg);
   //lv(feed);
 
   iter(feed, L) {
     castS(l,L);
     if (hasG(l, "{{ posts }}")) {
       delElemG(feed, iterIndexG(feed));
       insertNFreeG(feed, iterIndexG(feed), dupG(postsFeed));
       break;
     }
   }
 
   setNFreeG(pageValues, "_\%date", getCurrentDate());
   simpleTemplatesReplaceKeysWithValues(feed, pageValues);
 
   writeFileG(feed, siteDir"/feed.xml");
 
   // clean tmp files
   if (isPath("tmp.html")) rmAll("tmp.html");
   if (isPath("tmp.md"))   rmAll("tmp.md");
 
 
   // list all md files in _posts
   cleanSmallArrayP(postFiles) = readDirG(rtSmallArrayt, PostsDir);
   iter(postFiles, L) {
     castS(l,L);
     if (not endsWithG(l, ".markdown")) {
       delElemG(postFiles, iterIndexG(postFiles));
     }
   }
   //lv(postFiles);
 
   // move posts from _posts to _published
   // add first publish date if needed
   iter(postFiles, L) {
     castS(p,L);
     cleanCharP(postPath) = catS(PostsDir"/", ssGet(p));
     cleanAllocateSmallArray(post);
     readFileG(post, postPath);
 
     char *status = "search front matter";
     i32 dateIdx  = -1;
     iter(post, L) {
       castS(l,L);
       if (not eqG(status, "search front matter") and startsWithG(l, "firstPublishDate:"))
         // found first publish date. Stop.
         break;
       if (not eqG(status, "search front matter") and eqG(l, "---")) {
         if (dateIdx == -1) {
           logE("Date not found in front matter, post is %m", p);
           break;
         }
         cleanCharP(pDate) = replaceG($(post, dateIdx), "date:", "firstPublishDate:", 1);
         injectG(post, iI(post), pDate);
         break;
       }
       if (eqG(status, "date") and startsWithG(l, "date:")) {
         dateIdx = iI(post);
         status = "publishDate";
       }
       if (eqG(status, "search front matter") and eqG(l, "---")) {
         status = "date";
       }
     }
 
     // move post to _published directory
     cleanCharP(pubPath)  = catS(publishedDir"/", ssGet(p));
     if (not writeFileG(post, pubPath)) {
       logE("Could not write '%s', post is: %m", pubPath, p);
       continue;
     }
     if (not rmAllG(postPath)) {
       logE("Could not remove: %s", postPath);
       continue;
     }
   }
 }
 
 void help(void) {
   logI(BLD GRN"Forb help\n"RST
       "Argument convention: the arguments are words\n\n"
       BLD YLW"\nFORB SUBCOMMANDS:\n\n"RST
       "  help, -h, --help --- print this help message\n"
       "  without argument --- generate the blog in the "siteDir" directory, the posts in "PostsDir" are moved to "publishedDir"\n"
       "  new [title]      --- copy default template or when running in a forb directory, create a draft post\n"
       "  publish PATH     --- publish a draft, the draft file is moved from the "draftsDir" directory to the "PostsDir" directory and today's date is added to the file name and in the post\n"
       "  post PATH        --- publish a draft, the draft file is moved from the "draftsDir" directory to the "PostsDir" directory and today's date is added to the file name and in the post\n"
       "  update PATH      --- move post in "publishedDir" to "PostsDir", edit the post and generate the blog. The update date is added to the post and the first publish date is kept\n"
       );
 }
 
 
 /**
  * publish a post in _drafts to _posts
  */
 void publish(const char *path) {
   // steps
   // check extension
   // read post
   // create date string for filename
   // create destination filename
   // create date string for front matter
   // add date string in front matter
   // failed to find front matter or categories
   // save posts directory
   // remove path
 
   // check extension
   if (not endsWithG(path, ".markdown")) {
     logE("'%s' doesn't have the markdown extension. Stop.", path);
     XFailure;
   }
 
   // read post
   cleanAllocateSmallArray(post);
   readFileG(post, path);
 
   // create date string for filename
   cleanCharP(date) = getCurrentDateYMD();
   date[10] = 0;
   //lv(date);
   //lv(path);
 
   // create destination filename
   cleanCharP(dest) = catS(PostsDir"/", date, "-", basename(path));
   //lv(dest);
 
   // create date string for front matter
   date[10] = ' ';
   prependG(&date, "date: ");
   //lv(date);
 
   // add date string in front matter
   char *status = "search front matter";
   iter(post, L) {
     castS(l, L);
     if (eqG(status, "stop at categories") and startsWithG(l, "categories:")) {
       injectG(post, iI(post), date);
       goto publishPost;
     }
     if (eqG(status, "stop at categories") and eqG(l, "---")) {
       logE("categories not found in front matter, path is: %s", path);
       ret;
     }
     if (eqG(status, "search front matter") and eqG(l, "---")) {
       status = "stop at categories";
     }
   }
 
   // failed to find front matter or categories
   logE("front matter or categories not found, path is %s", path);
   ret;
 
   publishPost:
   // save posts directory
   if (not writeFileG(post, dest)) {
     logE("Could not write '%s', path is: %s", dest, path);
     ret;
   }
 
   // remove path
   if (not rmAllG(path)) {
     logE("Could not remove: %s", path);
   }
 
   logP("Published draft post to %s", dest);
 }
 
 
 /**
  * update a post in _published to _posts
  */
 void update(const char *path) {
   // steps
   // check extension
   // read post
   // create destination filename
   // create date string for front matter
   // change date string in front matter
   // failed to find front matter or date
   // save posts directory
   // remove path
 
   // check extension
   if (not endsWithG(path, ".markdown")) {
     logE("'%s' doesn't have the markdown extension. Stop.");
     XFailure;
   }
 
   // read post
   cleanAllocateSmallArray(post);
   readFileG(post, path);
 
   // create destination filename
   cleanCharP(dest) = catS(PostsDir"/", basename(path));
   //lv(dest);
 
   // create date string for front matter
   cleanCharP(date) = getCurrentDateYMD();
   date[10] = ' ';
   prependG(&date, "date: ");
   //lv(date);
 
   // change date string in front matter
   char *status = "search front matter";
   iter(post, L) {
     castS(l, L);
     if (eqG(status, "stop at date") and startsWithG(l, "date:")) {
       setG(post, iI(post), date);
       goto publishPost;
     }
     if (eqG(status, "stop at date") and eqG(l, "---")) {
       logE("date not found in front matter, path is: %s", path);
       ret;
     }
     if (eqG(status, "search front matter") and eqG(l, "---")) {
       status = "stop at date";
     }
   }
 
   // failed to find front matter or date
   logE("front matter or date not found, path is %s", path);
   ret;
 
   publishPost:
   // save posts directory
   if (not writeFileG(post, dest)) {
     logE("Could not write '%s', path is: %s", dest, path);
     ret;
   }
 
   // remove path
   if (not rmAllG(path)) {
     logE("Could not remove: %s", path);
   }
 
   logP("Update already published post in %s", dest);
 }
 
 
 /**
  * read file filename with front matter and text (any type of text)
  *
  * \return
  *   kv: keys and values for yml code in front matter
  *   lines: lines in file filename without front matter
  */
 bool readFileWithFrontMatter(char *filename, smallJsont *kv, smallArrayt *lines) {
   int frontMatterStart = -1, frontMatterEnd = -1;
 
   // Steps
   // find front matter start and end
   // parse yml code in front matter
   // remove front matter from lines
 
   if (not isPath(filename)) {
     logE("File '%s' not found.", filename);
     ret no;
   }
 
   readFileG(lines, filename);
 
   // find front matter start and end
   char *status = "start";
   iter(lines, L) {
     castS(l,L);
     if (eqS(status, "end") and (startsWithG(l, "---"))) {
       frontMatterEnd = iterIndexG(lines);
       break;
     }
     if (eqS(status, "start") and (startsWithG(l, "---"))) {
       frontMatterStart = iterIndexG(lines)+1;
       status = "end";
     }
   }
 
   if (frontMatterStart == -1 or frontMatterEnd == -1) {
     logE("front matter not found in '%s'", filename);
     ret no;
   }
 
   // parse yml code in front matter
   var frontMatter = copyRngG(lines, frontMatterStart, frontMatterEnd);
 
   //lv(frontMatter);
 
   // TODO change to: parseYMLG(indexCfg, frontMatter);
   // when parseYMLG accepts smallArrays
   cleanCharP(fm) = joinSG(frontMatter, "\n");
   parseYMLG(kv, fm);
 
   //lv(indexCfg);
   finishG(frontMatter);
 
   // remove front matter from lines
   sliceG(lines, frontMatterEnd+1, 0);
   //lv(lines);
 
   ret yes;
 }
 
 /**
  * convert post filename ("2020-06-09-getting-started" without markdown)
  * to url for linking posts easily in the blog.
  *
  * The url format is "/category/YYYY/MM/DD/filename.html"
  */
 char *postToUrl(char *filename) {
   cleanCharP(fn) = catS(PostsDir"/",filename,".markdown");
   if (not isPath(fn)) {
     free(fn);
     fn = catS(publishedDir"/",filename,".markdown");
   }
 
   cleanAllocateSmallArray(pf);
   cleanAllocateSmallJson(pCfg);
   readFileWithFrontMatter(fn, pCfg, pf);
 
   cleanCharP(postHtmlFile) = copyRngG(fn, 22, 0);
   replaceG(&postHtmlFile, ".markdown", ".html", 1);
 
   // select first publish date for html path: root/category/YY/MM/DD/postName.html
   cleanCharP(postDate) = hasG(pCfg, "firstPublishDate") ? copyRngG($(pCfg, "firstPublishDate"), 0, 10) : copyRngG($(pCfg, "date"), 0, 10);
   replaceG(&postDate, "-", "/", 0);
   char *pUrl = catS("/",$(pCfg,"categories"),"/",postDate,"/",postHtmlFile);
 
   ret pUrl;
 }
 
 
 bool generateAPageOrAPost(char *filename, smallJsont *cfg, smallArrayt *postsFeed) {
 
   // Steps
   // check if filename exists
   // parse front matter yml
   // convert markdown to html
   // add class in <code>
   // process {% post_url 2015-12-22-test %}
   // add syntax highlighting
   // insert html in layout template
   // add layout and html code in sub layout
   // TODO list pages on first line of all pages
   // configure destination path, post url, date and description
   // detect if generating a post or a page to select path and parameters
   // replace keys with values
   // generate feed
   // write post html page
 
   // check if filename exists
   if (not isPath(filename)) {
     logE("%s not found", filename);
     ret false;
   }
 
   // parse front matter yml
   cleanAllocateSmallArray(pf);
   cleanAllocateSmallJson(pCfg);
   readFileWithFrontMatter(filename, pCfg, pf);
 
   //lv(filename);
 
   // process {% post_url 2015-12-22-test %}
   // skip converting to URL in code blocks
   enum {searchcodeblock, incodeblock};
   int mdstatus = searchcodeblock;
   iter(pf, L) {
     castS(l,L);
     // process {% post_url 2015-12-22-running-rocket-chat %}
     // only outside code block, keep inside code blocks
     // (keep this block after code highlighting to get the correct status from the first line
     // in the code block)
     if (mdstatus equals searchcodeblock and hasG(l, "{\% post_url ")) {
       // convert all % post_url to valid url on the line
       char *cursor       = hasG(l, "{\% post_url ");
       while (cursor) {
         char *startp       = cursor;
         char *endp         = findS(cursor, " \%}");
         int start          = startp - ssGet(l);
         int end            = endp   - ssGet(l);
         // post filename
         char *postFilemane = startp + strlen("{\% post_url ");
         *endp              = 0;
         //lv(postFilemane);
         cleanCharP(url)    = postToUrl(postFilemane);
         delG(l, start, end+3);
         insertG(l, start, url);
         cursor             = findS(ssGet(l)+start, "{\% post_url ");
       }
       //lv(l);
       setPG(pf, iterIndexG(pf), l);
     }
     if (startsWithG(l, "```"))
       mdstatus is mdstatus equals searchcodeblock ? incodeblock : searchcodeblock;
   }
   //lv(pf);
 
   // convert markdown to html
   writeFileG(pf, "tmp.md");
 
   // TODO get path once and reuse
   cleanCharP(progPath) = shDirname(getRealProgPath());
   commandf("%s/shpPackages/md2html/md2html --full-html --ftables --fstrikethrough tmp.md --output=tmp.html", progPath);
 
   cleanAllocateSmallArray(pHtml);
   readFileG(pHtml, "tmp.html");
 
     // keep only html code between the body tags
   int bodyStart = -1, bodyEnd = -1;
   iter(pHtml, L) {
     castS(l,L);
     if (hasG(l, "<body>"))  bodyStart = iterIndexG(pHtml)+1;
     if (hasG(l, "</body>")) {
       bodyEnd   = iterIndexG(pHtml);
       break;
     }
   }
   sliceG(pHtml, bodyStart, bodyEnd);
 
   // add class in <code>
   // add syntax highlighting
   enum {searchCode, notspecified, bash, javascript, python, html, coffeescript};
   int status = searchCode;
   int lastCodeHighlightingLine = -1;
   iter(pHtml, L) {
     castS(l,L);
     // code highlighting
     if (status == searchCode and hasG(l, "<code>")) {
       if (hasG(l, "<pre><code>")) {
         replaceG(l, "<pre><code>", "<figure class=\"highlight\"><pre><code class=\"highlighter-rouge\">", 0);
         status = notspecified;
       }
       else {
         replaceG(l, "<code>", "<code class=\"highlighter-rouge\">", 0);
       }
     }
     if (status == searchCode and hasG(l, "<pre><code class=\"language-")) {
       lastCodeHighlightingLine = iterIndexG(pHtml);
     }
     if (status == searchCode and hasG(l, "<pre><code class=\"language-bash\">")) {
       status = bash;
     }
     if (status == searchCode and hasG(l, "<pre><code class=\"language-javascript\">")) {
       status = javascript;
     }
     if (status == searchCode and hasG(l, "<pre><code class=\"language-python\">")) {
       status = python;
     }
     if (status == searchCode and hasG(l, "<pre><code class=\"language-html\">")) {
       status = html;
     }
     if (status == searchCode and hasG(l, "<pre><code class=\"language-coffeescript\">")) {
       status = coffeescript;
     }
     if (hasG(l, "</code></pre>")) {
       if (status == searchCode) {
         if (lastCodeHighlightingLine == -1) {
           logW("line %d in html for "BLD"%s"RST", code highlighting not found. This code block doesn't have highlighting.", iterIndexG(pHtml), &filename[18]);
         }
         else {
           logW("line %d in html for "BLD"%s"RST", code highlighting not recognize: '%s'. This code block doesn't have highlighting.", iterIndexG(pHtml), &filename[18], $(pHtml, lastCodeHighlightingLine));
         }
       }
       else replaceG(l, "</code></pre>", "</code></pre></figure>", 0);
       status = searchCode;
     }
 
     // bash highlight
     if (status == bash) {
       replaceManyG(l, "<pre><code class=\"language-bash\">", "<figure class=\"highlight\"><pre><code class=\"language-bash\" data-lang=\"bash\">",
           "cd ", "<span class=\"nb\">cd </span>",
           "echo ", "<span class=\"nb\">echo </span>",
           "set ", "<span class=\"nb\">set </span>");
       // detect comment
       if (hasG(l, "#")) {
         replaceG(l, "#", "<span class=\"c\">#", 1);
         pushG(l, "</span>");
       }
       // strings
       if (not hasG(l, "<figure class=\"highlight\"><pre><code class=\"language-")) {
         var c = countG(l, '\'');
         if (c != 0 and (c & 1) == 0) {
           #define highlightQuotes(q, qS, qE) procbegin\
             var len = lenG(l);\
             var qL  = lenG(q);\
             cleanCharP(str) = malloc(len + ((strlen(qS) + strlen(qE)) * c/2) + 1);\
             char *ps  = str;\
             char *ln  = ssGet(l);\
             enum {qSearch, q1};\
             int status = qSearch;\
             range(i, len) {\
               if (eqIS(ln, q, i)) {\
                 if (status == qSearch) {\
                   status = q1;\
                   strcpy(ps, qS);\
                   ps += strlen(qS);\
                   *ps++ = ln[i];\
                 }\
                 elif (status == q1) {\
                   status = qSearch;\
                   rangeFrom(n, i, i+qL) {\
                     *ps++ = ln[n];\
                   }\
                   i += qL;\
                   strcpy(ps, qE);\
                   ps += strlen(qE);\
                 }\
               }\
               else {\
                 *ps++ = ln[i];\
               }\
             }\
             *ps = 0;\
             setValG(l, str);\
             procend
           highlightQuotes("'", "<span class=\"s1\">", "</span>");
         }
       }
     }
 
     // javascript highlight
     elif (status == javascript) {
       replaceManyG(l, "<pre><code class=\"language-javascript\">", "<figure class=\"highlight\"><pre><code class=\"language-javascript\" data-lang=\"javascript\">",
                       "*", "<span class=\"o\">*</span>",
                       "var", "<span class=\"kd\">var</span>",
                       "function", "<span class=\"kd\">function</span>",
                       "return", "<span class=\"kd\">return</span>",
                       "delete", "<span class=\"kd\">delete</span>",
                       "new", "<span class=\"kd\">new</span>",
                       "this", "<span class=\"kd\">this</span>",
                       "true", "<span class=\"kd\">true</span>",
                       "false", "<span class=\"kd\">false</span>",
                       "export", "<span class=\"kd\">export</span>",
                       "Object", "<span class=\"nb\">Object</span>"
                       );
       // detect comment
       if (hasG(l, "//") and not hasG(l, "://")) {
         replaceG(l, "//", "<span class=\"c\">//", 1);
         pushG(l, "</span>");
       }
       // strings
       if (not hasG(l, "<figure class=\"highlight\"><pre><code class=\"language-")) {
         var c = countG(l, '\'');
         if (c != 0 and (c & 1) == 0) {
           highlightQuotes("'", "<span class=\"s1\">", "</span>");
         }
       }
     }
 
     // python highlighting
     elif (status == python) {
       replaceManyG(l, "<pre><code class=\"language-python\">", "<figure class=\"highlight\"><pre><code class=\"language-python\" data-lang=\"python\">",
                       "*", "<span class=\"o\">*</span>",
                       "for", "<span class=\"kd\">for</span>",
                       "print", "<span class=\"kd\">print</span>",
                       "def", "<span class=\"kd\">def</span>",
                       "return", "<span class=\"kd\">return</span>",
                       "del", "<span class=\"kd\">del</span>",
                       "dict", "<span class=\"nb\">dict</span>",
                       "range", "<span class=\"nb\">range</span>",
                       "zip", "<span class=\"nb\">zip</span>"
                       );
       // detect comment
       if (hasG(l, "#")) {
         replaceG(l, "#", "<span class=\"c\">#", 1);
         pushG(l, "</span>");
       }
       // strings
       if (not hasG(l, "<figure class=\"highlight\"><pre><code class=\"language-")) {
         var c = countG(l, '\'');
         if (c != 0 and (c & 1) == 0) {
           highlightQuotes("'", "<span class=\"s\">", "</span>");
         }
       }
     }
 
     // html highlight
     elif (status == html) {
       // removed "class=", "<span class=\"na\">class=</span>",
       // it causes conflicts
       replaceManyG(l, "<pre><code class=\"language-html\">", "<figure class=\"highlight\"><pre><code class=\"language-html\" data-lang=\"html\">",
                       "&lt;script ", "<span class=\"nt\">&lt;script </span>",
                       "&lt;/script&gt;", "<span class=\"nt\">&lt;/script&gt;</span>",
                       "&lt;div", "<span class=\"nt\">&lt;div</span>",
                       "&lt;/div&gt;", "<span class=\"nt\">&lt;/div&gt;</span>",
                       "&lt;a", "<span class=\"nt\">&lt;a</span>",
                       "&lt;/a&gt;", "<span class=\"nt\">&lt;/a&gt;</span>",
                       "&lt;title&gt;", "<span class=\"nt\">&lt;title&gt;</span>",
                       "&lt;/title&gt;", "<span class=\"nt\">&lt;/title&gt;</span>",
                       "&lt;link", "<span class=\"nt\">&lt;link</span>",
                       "&lt;h1&gt;", "<span class=\"nt\">&lt;h1&gt;</span>",
                       "&lt;/h1&gt;", "<span class=\"nt\">&lt;/h1&gt;</span>",
                       "&lt;p&gt;", "<span class=\"nt\">&lt;p&gt;</span>",
                       "&lt;/p&gt;", "<span class=\"nt\">&lt;/p&gt;</span>",
                       "&lt;ul&gt;", "<span class=\"nt\">&lt;ul&gt;</span>",
                       "&lt;/ul&gt;", "<span class=\"nt\">&lt;/ul&gt;</span>",
                       "&lt;li&gt;", "<span class=\"nt\">&lt;li&gt;</span>",
                       "&lt;/li&gt;", "<span class=\"nt\">&lt;/li&gt;</span>",
                       "name=", "<span class=\"na\">name=</span>",
                       "type=", "<span class=\"na\">type=</span>",
                       "input=", "<span class=\"na\">input=</span>",
                       "style=", "<span class=\"na\">style=</span>",
                       "href=", "<span class=\"na\">href=</span>",
                       "src=", "<span class=\"na\">src=</span>"
                       );
       // strings
       if (not hasG(l, "<figure class=\"highlight\"><pre><code class=\"language-")) {
         var c = countG(l, "&quot;");
         if (c != 0 and (c & 1) == 0) {
           highlightQuotes("&quot;", "<span class=\"s\">", "</span>");
         }
       }
     }
 
     // coffeescript highlight
     elif (status == coffeescript) {
       replaceManyG(l, "<pre><code class=\"language-coffeescript\">", "<figure class=\"highlight\"><pre><code class=\"language-coffeescript\" data-lang=\"coffeescript\">",
                       "*", "<span class=\"o\">*</span>",
                       "delete", "<span class=\"kd\">delete</span>",
                       "new", "<span class=\"kd\">new</span>",
                       "this", "<span class=\"kd\">this</span>",
                       "true", "<span class=\"kd\">true</span>",
                       "false", "<span class=\"kd\">false</span>",
                       "export", "<span class=\"kd\">export</span>",
                       "Object", "<span class=\"nb\">Object</span>"
                       );
       // detect comment
       if (hasG(l, "#")) {
         replaceG(l, "#", "<span class=\"c\">#", 1);
         pushG(l, "</span>");
       }
       // strings
       if (not hasG(l, "<figure class=\"highlight\"><pre><code class=\"language-")) {
         var c = countG(l, '\'');
         if (c != 0 and (c & 1) == 0) {
           highlightQuotes("'", "<span class=\"s1\">", "</span>");
         }
       }
     }
 
     setPG(pHtml, iterIndexG(pHtml), l);
   }
 
   //lv(pHtml);
 
   // insert html in layout template
   cleanCharP(layoutFile) = catS(layoutDir,"/",$(pCfg, "layout"),".html");
 
   //lv(layoutFile);
 
   cleanAllocateSmallArray(layoutf);
   cleanAllocateSmallJson(layoutCfg);
   readFileWithFrontMatter(layoutFile, layoutCfg, layoutf);
 
   //lv(layoutf);
 
   // replace content with mardown generated html
 
   iter(layoutf, L) {
     castS(l,L);
     if (hasG(l, content)) {
       delElemG(layoutf, iterIndexG(layoutf));
       insertNFreeG(layoutf, iterIndexG(layoutf), dupG(pHtml));
       break;
     }
   }
 
   // add layout and html code in sub layout
   cleanCharP(subLayoutFile) = catS(layoutDir,"/",$(layoutCfg, "layout"),".html");
 
   var p = preprocess(subLayoutFile);
 
   //logG(p);
 
   iter(p, L) {
     castS(l,L);
     if (hasG(l, content)) {
       delElemG(p, iterIndexG(p));
       insertNFreeG(p, iterIndexG(p), dupG(layoutf));
       break;
     }
   }
 
   // TODO list pages on first line of all pages
   cleanAllocateSmallArray(about);
   cleanAllocateSmallJson(aboutCfg);
   readFileWithFrontMatter("about.md", aboutCfg, about);
 
   char *sitePages    = catS("<a class=\"page-link\" href=\"", $(cfg, "baseurl"), $(aboutCfg, "permalink"), "\">", $(aboutCfg, "title"), "</a>");
 
   // configure destination path, post url, date and description
   cleanCharP(dst)    = null;
   char *pUrl         = null;
   baset *description = null;
   // char *date is the visible date string: 'date' when the post is published for the first time, 'firstPublishDate update on date' when the post has been updated
   cleanCharP(date)   = null;
   // detect if generating a post or a page to select path and parameters
   if (startsWithG(filename, PostsDir"/") or startsWithG(filename, publishedDir"/")) {
     cleanCharP(postHtmlFile) = startsWithG(filename, PostsDir"/") ? copyRngG(filename, 18, 0) : copyRngG(filename, 22, 0);
     replaceG(&postHtmlFile, ".markdown", ".html", 1);
 
     // select first publish date for html path: root/category/YY/MM/DD/postName.html
     cleanCharP(postDate) = hasG(pCfg, "firstPublishDate") ? copyRngG($(pCfg, "firstPublishDate"), 0, 10) : copyRngG($(pCfg, "date"), 0, 10);
     replaceG(&postDate, "-", "/", 0);
     dst  = catS(siteDir,"/",$(pCfg, "categories"),"/",postDate,"/",postHtmlFile);
     pUrl = catS($(cfg, "url"),$(cfg, "baseurl"),"/",
                 $(pCfg,"categories"),"/",postDate,"/",postHtmlFile);
     if (hasG(pCfg, "firstPublishDate")) {
       if (eqG($(pCfg, "date"), $(pCfg, "firstPublishDate"))) goto onlyPublishDate;
       // there is an update date
       $(pCfg, "date")[10] = 0;
       $(pCfg, "firstPublishDate")[10] = 0;
       date = catS($(pCfg, "firstPublishDate"), " updated on ", $(pCfg, "date"));
     }
     else {
       onlyPublishDate:
       $(pCfg, "date")[10] = 0;
       date = dupG($(pCfg, "date"));
     }
 
     iter(pf, L) {
       castS(l,L);
       if (not isBlankG(l)) {
         description = (baset*) dupG(l);
         break;
       }
     }
     replaceManyG((smallStringt*)description, "\"", "", "'", "", "`", "");
     //lv(description);
   }
   else {
     dst         = catS(siteDir, $(pCfg, "permalink"), "index.html");
     pUrl        = catS($(cfg, "url"), $(cfg, "baseurl"), $(pCfg, "permalink"));
     description = getNDupO(cfg, "description");
   }
 
   // replace keys with values
   cleanAllocateSmallDict(pageValues);
 
   setNFreeG(pageValues, "_\%title", getNDupO(pCfg, "title"));
   setNFreeG(pageValues, "_\%description", description);
   setNFreeG(pageValues, "_\%site.description", getNDupO(cfg, "description"));
   setNFreeG(pageValues, "_\%css", catS($(cfg, "baseurl"), "/css/main.css"));
   setNFreeG(pageValues, "_\%url", pUrl);
   setNFreeG(pageValues, "_\%site.title", getNDupO(cfg, "title"));
   setNFreeG(pageValues, "_\%feed", catS($(cfg, "url"), $(cfg, "baseurl"), "/feed.xml"));
   setNFreeG(pageValues, "_\%baseurl", getNDupO(cfg, "baseurl"));
   setNFreeG(pageValues, "_\%site.pages", sitePages);
   setNFreeG(pageValues, "_\%site.email", getNDupO(cfg, "email"));
   setNFreeG(pageValues, "_\%site.github_username", getNDupO(cfg, "github_username"));
   setNFreeG(pageValues, "_\%site.twitter_username", getNDupO(cfg, "twitter_username"));
   if (startsWithG(filename, PostsDir"/") or startsWithG(filename, publishedDir"/")) {
     setG(pageValues, "_\%date", date);
   }
 
   //lv(pageValues);
 
   simpleTemplatesReplaceKeysWithValues(p, pageValues);
 
   // generate feed
   if (postsFeed) {
     cleanCharP(postContent) = joinSG(pHtml, '\n');
     iReplaceManyS(&postContent, "<",  "&lt;",
                                ">",  "&gt;",
                                "\"", "&quot;");
     pushNFreeG(postsFeed, formatS(
       "<item>\n"
       "  <title>%s</title>\n"
       "  <description>%s</description>\n"
       "  <pubDate>%s</pubDate>\n"
       "  <link>%s</link>\n"
       "  <guid isPermaLink=\"true\">%s</guid>\n"
       "  <category>%s</category>\n"
       "</item>\n",
       $(pCfg, "title"), postContent, date, $(pageValues, "_\%url"), $(pageValues, "_\%url"),
       $(pCfg, "categories")));
   }
 
   //logG(p);
 
   // write post html page
   cleanCharP(dstDir) = shDirname(dst);
 
   //lv(dst);
   //lv(dstDir);
 
   if (not isPath(dstDir)) {
     mkdirParents(dstDir);
   }
 
   writeFileG(p, dst);
 
   ret true;
 }
 
 // vim: set expandtab ts=2 sw=2: