hexo-adsense 1.0.21 → 1.0.25

package/packages/hexo-cli-extras/README.md

@@ -0,0 +1,146 @@
+# hexo-cli-extras
+
+This is a simple plugin for [Hexo](https://github.com/hexojs/hexo), a Node.js-based static site generator/blog framework.
+
+The plugin adds a handful of useful commands to the Hexo command-line interface: `edit`, `rename`, `remove`, `isolate` and `integrate`.
+
+Basic terminal editing:
+
+![example](./docs/basic.gif)
+
+Basic GUI editing and selection on tag (sorry for the bad resolution):
+
+![example](./docs/gui.gif)
+
+A more detailed explanation of the commands and their options is included below, but remember that you can run `hexo help` followed by any command in your terminal to get an overview (eg `hexo help edit`). You may also find the tips and notes at the very bottom of this README useful.
+
+## Installation
+
+```
+npm install --save hexo-cli-extras
+```
+
+Note that the plugin *must* be installed locally. So if you have multiple blogs, you have to install it separately for each of them.
+
+## edit command
+
+Select a post, page or draft using search terms and/or filters and open it in your favorite terminal $EDITOR or associated GUI text editor. If multiple items match your query, a menu will be displayed. By the way, if you're a vim-user with a distaste for arrow-keys, the menu supports vim-style keybindings (yay).
+
+```
+hexo edit [title] [-a | --after MM-DD-YYYY] [-b | --before MM-DD-YYYY] [-c | --category | --categories CATEGORY] [-f | --folder SUBFOLDER] [-l | --layout] [-t | --tag | --tags TAG] [--draft | --drafts] [-g | --gui] [-p | --page | --pages]
+```
+
+### quick examples
+
+```
+hexo edit
+```
+--> gives you a menu with *all* your posts in descending chronological order, select one to edit using the  arrow keys or `j`/`k`
+
+```
+hexo edit search term
+```
+--> uses the regular expressions `search` and `term` to filter the titles (or slugs) of your articles and displays a menu with all matches -- if only one article matches, it will open automatically in your editor
+
+```
+hexo edit -a 11-11-2015 -g
+```
+--> gives you a menu with all posts published after 11/11/2015 -- the selected article will open in gui mode
+
+```
+hexo edit neovim -c vim
+```
+--> looks in the database for articles in the "vim" category which match the regular expression "neovim" in their titles or slugs
+
+### detailed information (get this info on the command line with `hexo help edit`)
+
+- `title` is a regular expression (case insensitive and spaces are allowed) for matching the title of a post
+- `-a` or `--after` (optional) filters out all posts that were made before the given date. A little parsing is done to help you, but use `MM-DD-YYYY` for best results
+- `-b` or `--before` (optional) filters out all posts that were made after the given date. A little parsing is done to help you, but use `MM-DD-YYYY` for best results
+- `-c` or `--category` (optional) filters posts on category
+- `-f` or `--folder` (optional) is (part of) the name of a subfolder in `hexo_dir/source` to narrow down your search in case you have multiple folders (for filtering on drafts, prefer to use `-d`)
+- `-l` or `--layout` (optional) filters posts/pages with a specific layout
+- `-t` or `--tag` (optional) filters posts on tag
+- `--draft` or `--drafts` (optional) excludes all published posts
+- `-g` or `--gui` (optional) causes selected files to open using an associated GUI editor, rather than a terminal editor set in the $EDITOR environment variable
+- `-p` or `--page` (optional) selects pages instead of posts
+
+
+*Note*: boolean options can be combined (for example `hexo edit -dp` to search for drafts that are pages)
+
+*Note*: Drafts only appear in searches without the `--drafts` option if you have `render_drafts` set to true in `_config.yml`. If set to false, you must use the `--draft` option to filter on drafts. Also, drafts are excluded automatically when you use any of the date filters, because dates make little sense with drafts.
+
+*Note*: Filter on title first and use boolean options last or you may get unexpected results. For example, `hexo edit -g my post` will filter just on "post" whereas `hexo edit my draft -g` will correctly filter on "my draft".
+
+*Note*: By default, files open in your current terminal window using your `$EDITOR` environment variable. Set it in your dotfiles (for example, in `.bashrc` or `.zshrc`).
+
+*Note*: The `gui` option (or the lack of an `$EDITOR` variable) will cause files to open with `xdg-open` (linux, osx) or `start` (windows). If you're on linux and nothing seems to happen, you can change the handler for plain text markdown files to a `*.desktop` file of your choice. For example, for Sublime Text: `xdg-mime default sublime-text.desktop text/plain`
+
+## rename command
+
+Rename a post, page or draft. The title and the filename can be renamed independently or both at the same time.
+
+![example](./docs/rename.png)
+
+```
+hexo rename <old title/slug> <-n | --new "new title">
+```
+
+`old title/slug` is one or more regular expressions to find a post or page. If more match your regex, a selection menu will be displayed.
+
+`new title` is the new title for your post. In case you just want to rename the file, it will be `slugize`d automatically (ie it will get converted to lower case, and all special characters and spaces will be made url-friendly).
+
+After selecting a file, you will be presented with another menu. From there you can choose whether to rename the filename, the title of the post, both, or cancel altogether.
+
+*Note*: if you have set `render_drafts` to false in `_config.yml`, you won't be able to rename drafts from the command line. It works only with that setting set to true or if you publish the post first.
+
+*Note*: wrap the new title in single or double quotes! If you forget, the presence of spaces or special characters may cause strange behavior.
+
+
+## remove command
+
+Delete a post.
+
+![example](./docs/remove.png)
+
+```
+hexo remove <search terms>
+```
+
+Search for a post and delete it after confirmation. This will cause the irreversible removal of the selected post *and* its associated asset folder (if it exists), along with all its contents.
+
+## isolate command
+
+Isolate a post by temporarily removing all others from the build process.
+
+```
+hexo isolate <search terms> [-a | --all]
+```
+
+This command was inspired by Octopress. For testing purposes, you may want to isolate a post so you can work on it and test it in isolation from all others. This accomplishes that aim by moving all posts and asset directories (pages are not supported right now) to an `_exile` subfolder, where they will be ignored.
+
+The `-a` or `--all` option will cause *all* posts to be moved, and your search terms to be ignored.
+
+Run `hexo integrate` to restore the posts to their previous location.
+
+## integrate command
+
+Restores all exiled posts.
+
+```
+hexo integrate
+```
+
+## Info
+
+- It doesn't matter where in the hexo directory you are on the command line. As long as you are inside a hexo directory somewhere, the commands should work.
+
+- Installing this plugin will also cause any new post you create with `hexo new ...` to open automatically in your text editor.
+
+- The terminal menu may not work as expected in the default Windows command shell (`cmd.exe`), but it should work just fine in more powerful shells.
+
+- If you don't like the command-line centric workflow this plugin encourages, you may want to consider using an administration plugin instead - check out [hexo-admin](https://github.com/jaredly/hexo-admin) or [hexo-hey](https://github.com/nihgwu/hexo-hey).
+
+- Filter on title first and use boolean options last or you may get unexpected results. For example, `hexo edit -g my post` will filter just on "post" whereas `hexo edit my draft -g` will correctly filter on "my draft".
+
+- By default, files open in your current terminal window using your `EDITOR` environment variable. Set it somewhere in your dotfiles (`.bashrc` or `.zshrc` are good locations, and don't forget to source the file or reboot before testing). If `$EDITOR` doesn't exist, or if you use the `gui` option, files will open with [xdg-open](https://wiki.archlinux.org/index.php/default_applications#xdg-open_2) (linux, osx) or `start` (windows) instead.

package/packages/hexo-cli-extras/index.js

@@ -0,0 +1,48 @@
+'use strict';
+
+require('./lib/extensions')(hexo);
+
+hexo.extend.console.register('edit', 'Edit a post or draft with your favorite $EDITOR', {
+  desc: 'Edit a post or draft with your favorite $EDITOR. Filter on title (if applicable), before using optional arguments.',
+  usage: '[title] [-a | --after MM-DD-YYYY] [-b | --before MM-DD-YYYY] [-c | --category CATEGORY] [-d | --draft | --drafts] [-f | --folder FOLDER] [-g | --gui] [-l | --layout LAYOUT] [-p | --page | --pages] [-t | --tag | --tags TAG]',
+  arguments: [
+    {name: 'title', desc: '(Part of) the title of a post. If more posts match this regex, a menu will be called.'},
+  ],
+  options: [
+    {name: '-a, --after', desc: 'Only consider posts after this date (MM-DD-YYYY)'},
+    {name: '-b, --before', desc: 'Only consider posts before this date (MM-DD-YYYY)'},
+    {name: '-c, --category, --categories', desc: 'Category to filter on.'},
+    {name: '-d, --draft, --drafts', desc: 'Only consider drafts'},
+    {name: '-f, --folder', desc: 'Name of subfolder to filter on.'},
+    {name: '-g, --gui', desc: 'Open file with associated GUI text editor. Default is to open in terminal using $EDITOR. If no $EDITOR is found, it will fall back to gui mode.'},
+    {name: '-l, --layout', desc: 'Only consider posts with a given layout'},
+    {name: '-p, --page, --pages', desc: 'Only consider pages'},
+    {name: '-t, --tag, --tags', desc: 'Tag to filter on.'},
+  ],
+}, require('./lib/edit'));
+
+hexo.extend.console.register('rename', 'Rename a post or draft', {
+  desc: 'Rename a post or draft. Search for a post and set a new name with the -n or --new option, followed by the new title wrapped in single or double quotes',
+  usage: '<old name> <-n | --new new name>',
+  options: [
+    {name: '-n, --new', desc: '(required) The new title. Wrap in single or double quotes if the title includes spaces.'},
+  ],
+}, require('./lib/rename'));
+
+hexo.extend.console.register('remove', 'Remove a post or draft', {
+  desc: 'Search for a post or draft and remove it.',
+  usage: '<search terms for a post to be deleted>',
+}, require('./lib/remove'));
+
+hexo.extend.console.register('isolate', 'Isolate a post or page by temporarily removing all others from the build process', {
+  desc: 'Move all posts to an ignored _exile subfolder, except for the one matching a given search term. If multiple posts match, a menu will be called. This can be useful for speeding up testing, but don\'t forget to use the integrate command to restore the exiled posts back to their previous location before deploying your site.',
+  usage: '[search term]',
+  options: [
+    {name: '-a, --all', desc: 'Stash all posts in _exile, including the one for which the pattern matches.'},
+  ],
+}, require('./lib/isolate'));
+
+hexo.extend.console.register('integrate', 'Restore isolated posts', {
+  desc: 'Restore all exiled posts from _posts/_exile back to _posts. Opposite of the isolate command.',
+  usage: '',
+}, require('./lib/integrate'));

package/packages/hexo-cli-extras/lib/edit.js

@@ -0,0 +1,209 @@
+'use strict';
+
+var chalk = require('chalk');
+var moment = require('moment');
+var open = require('opn');
+var editor = process.env.EDITOR;
+var spawn = require('child_process').spawn;
+var path = require('path');
+var inquirer = require('inquirer');
+var Promise = require('bluebird');
+
+module.exports = function modExports(args) {
+  var filters = {
+    title: args._ || '',
+
+    after: args.a  || args.after    ||                    null,
+    before: args.b || args.before   ||                    null,
+    cat: args.c    || args.category || args.categories || null,
+    draft: args.draft               || args.drafts     || null,
+    folder: args.f || args.folder   ||                    null,
+    layout: args.l || args.layout   ||                    null,
+    tag: args.t    || args.tag      ||                    null,
+  };
+
+  var gui  = args.g || args.gui  || !editor;
+  var page = args.p || args.page || args.pages || null;
+
+  // load in the posts before processing them
+  this.load().then(function loadDB() {
+    var sourceDir = this.source_dir;
+    var searchDir = sourceDir;
+
+    var query = (page) ? 'pages' : 'posts';
+
+    // the following promise chain details the main functionality
+    loadArticles(query, this.locals).then(function filter(articles) {
+      return filterArticles(articles, filters);
+    }).then(function select(filtered) {
+      return selectArticle(filtered);
+    }).then(function openFn(selected) {
+      openFile(selected);
+    }).catch(function catchAll(err) {
+      console.log(err.stack ? chalk.red(err.stack) : chalk.red('Error: ') + chalk.gray(err));
+    });
+
+    function loadArticles(dataType, locals) {
+      return Promise.resolve(locals.get(dataType).sort('-date').toArray());
+    }
+
+    function filterArticles(items, filterObj) {
+      var results;
+      // allow omission of leading underscore or trailing s for the common _drafts and _posts folders;
+      if (/post|draft/.test(filterObj.folder)) {
+        filterObj.folder = (/^_/.test(filterObj.folder)) ? filterObj.folder : '_' + filterObj.folder;
+        filterObj.folder = (/s$/.test(filterObj.folder)) ? filterObj.folder : filterObj.folder + 's';
+      }
+
+      results = filterTitle(items, filterObj.title);
+
+      results = (filterObj.draft)  ? filterDrafts(results) : results;
+      results = (filterObj.layout) ? filterLayout(results, filterObj.layout) : results;
+      results = (filterObj.folder) ? filterFolder(results, filterObj.folder) : results;
+      results = (filterObj.tag)    ? filterTag(results, filterObj.tag) : results;
+      results = (filterObj.cat)    ? filterCategory(results, filterObj.cat) : results;
+      results = (filterObj.before) ? filterBefore(results, filterObj.before) : results;
+      results = (filterObj.after)  ? filterAfter(results, filterObj.after) : results;
+
+      return results;
+
+      // filter the posts with the supplied regular expression
+      function filterTitle(posts, title) {
+        var reTitle = title.map(function makeRE(word) {
+          return new RegExp(word, 'i');
+        });
+
+        return posts.filter(function filterPosts(post) {
+          return reTitle.every(function checkRE(regex) {
+            return regex.test(post.title) || regex.test(post.slug);
+          });
+        });
+      }
+
+      // filter the posts using a subfolder if supplied
+      function filterFolder(posts, folder) {
+        var reFolder = new RegExp(folder);
+        return posts.filter(function filterPosts(post) {
+          return reFolder.test(post.source.substr(0, post.source.lastIndexOf(path.sep)));
+        });
+      }
+
+      // filter the posts using a tag if supplied
+      function filterTag(posts, tag) {
+        var reTag = new RegExp(tag);
+        return posts.filter(function filterPosts(post) {
+          return post.tags.data.some(function checkRe(postTag) {
+            return reTag.test(postTag.name);
+          });
+        });
+      }
+
+      // filter the posts using a category if supplied
+      function filterCategory(posts, cat) {
+        var reCat = new RegExp(cat);
+        return posts.filter(function filterPosts(post) {
+          return post.categories.data.some(function checkRe(postCat) {
+            return reCat.test(postCat.name);
+          });
+        });
+      }
+
+      // filter the posts using a layout if supplied
+      function filterLayout(posts, layout) {
+        var reLayout = new RegExp(layout, 'i');
+
+        return posts.filter(function filterPosts(post) {
+          return reLayout.test(post.layout);
+        });
+      }
+
+      // filter out all non-published posts
+      function filterDrafts(posts) {
+        return posts.filter(function filterPosts(post) {
+          return !post.published;
+        });
+      }
+
+      // filter the posts using a before date if supplied
+      function filterBefore(posts, before) {
+        var momentBefore = moment(before.replace(/\//g, '-'), 'MM-DD-YYYY', true);
+        if (!momentBefore.isValid()) {
+          console.log(chalk.red('Before date is not valid (expecting `MM-DD-YYYY`), ignoring argument.'));
+          return posts;
+        }
+
+        return posts.filter(function filterPosts(post) {
+          return moment(post.date).isBefore(momentBefore);
+        });
+      }
+
+      // filter the posts using an after date if supplied
+      function filterAfter(posts, after) {
+        var momentAfter = moment(after.replace(/\//g, '-'), 'MM-DD-YYYY', true);
+        if (!momentAfter.isValid()) {
+          console.log(chalk.red('After date is not valid (expecting `MM-DD-YYYY`), ignoring argument.'));
+          return posts;
+        }
+
+        return posts.filter(function filterPosts(post) {
+          return moment(post.date).isAfter(momentAfter);
+        });
+      }
+    }
+
+    function selectArticle(items) {
+      if (items.length === 0) {
+        return Promise.reject('Sorry, no articles match your query.');
+      }
+
+      if (items.length === 1) {
+        // no menu necessary if there is only one matching file
+        var selected = path.join(searchDir, items[0].source);
+        return Promise.resolve(selected);
+      }
+
+      // populate a list of entries to use for the menu -- slugs are easy because they show the subfolder and can easily
+      // be put back together with the searchDir to open the file
+      var entries = items.map(function makeEntries(post) {
+        var entry = '';
+        var loc = post.source.substr(0, post.source.lastIndexOf(path.sep));
+        if (!post.published) {
+          entry = ['[', chalk.yellow.bgBlack('draft'), '] ', post.title].join('');
+        } else {
+          entry = ['[', chalk.gray(post.date.format('MM-DD-YYYY')), '] ', post.title, ' (', chalk.green(loc), ')'].join('');
+        }
+
+        return entry;
+      });
+
+      // display the menu
+      return inquirer.prompt([
+        {
+          type: 'list',
+          name: 'file',
+          message: 'Select the file you wish to edit.',
+          choices: entries,
+        }
+      ]).then(function getAnswer(answer) {
+        var pos = entries.indexOf(answer.file);
+        var selected = path.join(sourceDir, items[pos].source);
+
+        if (!selected) {
+          return Promise.reject('Invalid choice.');
+        }
+        return selected;
+      });
+    }
+
+    // spawn process and open with associated gui or terminal editor
+    function openFile(file) {
+      var edit;
+      if (!editor || gui) {
+        open(file);
+      } else {
+        edit = spawn(editor, [file], {stdio: 'inherit'});
+        edit.on('exit', process.exit);
+      }
+    }
+  }.bind(this));
+};

package/packages/hexo-cli-extras/lib/env.js

@@ -0,0 +1,52 @@
+"use strict";
+const Hexo = require("hexo");
+const { memoize } = require("underscore");
+const argv = require("minimist")(process.argv.slice(2));
+
+/**
+ * Check is production or development
+ * @param {Hexo} inHexo
+ * @returns
+ */
+const getEnv = memoize(function (inHexo) {
+  var DEV = "development";
+  var PRD = "production";
+  // --development
+  const arg = typeof argv["development"] == "boolean" && argv["development"];
+
+  // set NODE_ENV = "development"
+  const env = process.env.NODE_ENV && process.env.NODE_ENV.toString().toLowerCase() === "development";
+
+  // define is development
+  const isDev = arg || env;
+
+  if (inHexo) {
+    if (isDev) return DEV;
+    if (typeof inHexo.env.args.development == "boolean" && inHexo.env.args.development) return DEV;
+    if (inHexo.env.args._ && inHexo.env.args._.length > 0) {
+      for (var i = 0; i < inHexo.env.args._.length; i++) {
+        if (inHexo.env.args._[i] == "s" || inHexo.env.args._[i] == "server") return DEV;
+        if (inHexo.env.args._[i] == "d" || inHexo.env.args._[i] == "deploy") return PRD;
+        if (inHexo.env.args._[i] == "g" || inHexo.env.args._[i] == "generate") return PRD;
+      }
+    }
+  }
+
+  return null;
+});
+
+const isDev = memoize(function (hexo) {
+  return getEnv(hexo) == "development";
+});
+
+const isProd = memoize(function (hexo) {
+  return getEnv(hexo) == "production";
+});
+
+module.exports = {
+  env: function (inHexo) {
+    return getEnv(inHexo);
+  },
+  isProd,
+  isDev,
+};

package/packages/hexo-cli-extras/lib/extensions.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = function modExports(hexo) {
+  var open = require('opn');
+  var editor = process.env.EDITOR;
+  var spawn = require('child_process').spawn;
+
+  // extend `hexo new` to open newly created post/draft
+  hexo.on('new', function onNew(post) {
+    var edit;
+    var content = post.content;
+
+    // only open a new empty post -- prevent opening on publishing an already written one
+    if (content.substr(content.indexOf('\n---\n')).length === 5) {
+      if (!editor) {
+        open(post.path);
+      } else {
+        edit = spawn(editor, [post.path], {stdio: 'inherit'});
+        edit.on('exit', process.exit);
+      }
+    }
+  });
+};

package/packages/hexo-cli-extras/lib/integrate.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var Promise = require('bluebird');
+var chalk = require('chalk');
+var fsStat = Promise.promisify(require('fs').stat);
+var fsRename = Promise.promisify(require('fs').rename);
+var fsReaddir = Promise.promisify(require('fs').readdir);
+var path = require('path');
+
+module.exports = function modExports() {
+
+  // load DB (kind of unnecessary here, but it does give easy access to source_dir)
+  this.load().then(function loadDB() {
+    var postsDir = path.join(this.source_dir, '_posts');
+    var exileDir = path.join(postsDir, '_exile');
+
+    isExileDir(exileDir).then(function checkExileDir(exists) {
+      if (!exists) {
+        process.exit();
+      }
+    }).then(function lsDir() {
+      return getExiledPosts(exileDir);
+    }).then(function checkExiledPosts(files) {
+      if (!files) {
+        console.log(chalk.red('No exiled posts detected. Exiting..'));
+        process.exit();
+      } else {
+        return files;
+      }
+    }).then(function processFiles(files) {
+      // set the exiled files up for restoration
+      return files.map(function mapAbsolutePaths(file) {
+        return {
+          origin: path.join(exileDir, file),
+          destination: path.join(postsDir, file),
+        };
+      });
+    }).then(function doIntegrate(files) {
+      var movePromises = files.map(function makePromise(file) {
+        return new Promise(function returnPromise(resolve) {
+          resolve(move(file.origin, file.destination));
+        });
+      });
+
+      Promise.all(movePromises).then(function allDone() {
+        console.log(chalk.gray('All exiled posts and asset directories restored.'));
+      });
+    }).catch(function catchUncaught(err) {
+      console.log(err.stack ? chalk.red(err.stack) : chalk.red('Error: ') + chalk.gray(err));
+    });
+
+    function move(origin, destination) {
+      return fsRename(origin, destination).then(function doMove() {
+        // console.log('%s moved to %s', origin, destination);
+      }).catch(function catchMove(err) {
+        console.log('%s could not be moved to %s: %s', origin, destination, err);
+      });
+    }
+
+    function isExileDir(dir) {
+      return fsStat(dir).then(function doCheckDir(stats) {
+        if (stats.isFile()) {
+          console.log(chalk.gray(dir), 'seems to be a file on your filesystem! It needs to be either non-existent or a directory, so please rename your _exile post and run', chalk.yellow('hexo isolate'), 'before using this command.');
+          return false;
+        } else if (stats.isDirectory()) {
+          return true;
+        } else {
+          console.log(chalk.gray(dir), 'seems to be neither a file nor a directory! This really shouldn\'t be happening, please issue a bug report.');
+          return false;
+        }
+      }).catch(function catchCheckDir() {
+        // The directory doesn't exist
+        console.log(chalk.red('No _exile dir detected. Have you run'), chalk.yellow('hexo isolate'), chalk.red('first?'));
+        return false;
+      });
+    }
+
+    function getExiledPosts(dir) {
+      return fsReaddir(dir).then(function doReadDir(contents) {
+        return contents;
+      }).catch(function catchCheckDir(err) {
+        console.log(chalk.red('Error: '), err);
+      });
+    }
+  }.bind(this));
+};
+