hexo-adsense 1.0.21 → 1.0.25

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

@@ -0,0 +1,179 @@
+'use strict';
+
+var Promise = require('bluebird');
+var chalk = require('chalk');
+var inquirer = require('inquirer');
+var fsStat = Promise.promisify(require('fs').stat);
+var fsRename = Promise.promisify(require('fs').rename);
+var fsMkdir = Promise.promisify(require('fs').mkdir);
+var path = require('path');
+
+module.exports = function modExports(args) {
+  // set up -a/--all option and searchTerms
+  var doWholeFolder = !!args.a || !!args.all;
+  var searchTerms = [];
+
+  if (!doWholeFolder) {
+    searchTerms = args._.map(function makeRE(arg) {
+      return new RegExp(arg, 'i');
+    });
+  }
+
+  this.load().then(function loadDB() {
+
+    var locals = this.locals;
+    var exileDir = path.join(this.source_dir, '_posts', '_exile');
+    var allPosts;
+
+    // if the _exile dir doesn't exist yet, make it
+    isDir(exileDir).then(function checkExileDir(exists) {
+      if (!exists) {
+        makeDir(exileDir);
+      }
+    }).then(function loadArticles() {
+      return getArticles(locals);
+    }).then(function selectArticle(arts) {
+      allPosts = arts;
+      return selectIsolated(arts, doWholeFolder);
+    }).then(function splitPosts(isolated) {
+      // split into { isolated, articlesToStash }
+      return makeIsoObject(allPosts, isolated);
+    }).then(function isolateArticles(articlesObject) {
+      return doIsolate(articlesObject);
+    }).then(function allDone(isolated) {
+      console.log(chalk.gray(isolated), 'successfully isolated.\nTo restore the exiled posts, run', chalk.yellow('hexo integrate'));
+    }).catch(function catchUncaught(err) {
+      console.log(err.stack ? chalk.red(err.stack) : chalk.gray(err));
+    });
+
+    function isDir(dir) {
+      return fsStat(dir).then(function doCheckDir(stats) {
+        if (stats.isFile() && /_exile/.test(dir)) {
+          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 before using this command.');
+          process.exit();
+        } else if (stats.isDirectory()) {
+          // console.log('%s is a directory', dir);
+          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.');
+          process.exit();
+        }
+      }).catch(function catchCheckDir() {
+        // The directory doesn't exist (which is not a bad thing)
+        // console.log('%s doesn\'t exist', dir);
+        return false;
+      });
+    }
+
+    function makeDir(dir) {
+      return fsMkdir(dir).then(function doMakeDir() {
+        console.log(chalk.gray(dir), 'created');
+      }).catch(function catchMakeDir(err) {
+        console.log(chalk.gray(dir), 'could not be created: ', chalk.red(err));
+      });
+    }
+
+    function getArticles(data) {
+      return Promise.resolve(data.get('posts').sort('-date').toArray());
+    }
+
+    function filterOnName(arts, terms) {
+      return arts.filter(function filterArts(article) {
+        return terms.every(function testRE(term) {
+          return term.test(article.title) || term.test(article.slug);
+        });
+      });
+    }
+
+    function selectIsolated(items, doAll) {
+      // narrow down the post to isolate based on the user's inputted search terms (if available)
+      var isolated = filterOnName(items, searchTerms);
+
+      // stash everything if run with the -a/--all option
+      if (doAll) {
+        return Promise.resolve(isolated);
+      }
+
+      if (isolated.length === 0) {
+        console.log(chalk.red('No posts matched. Exiting.'));
+        process.exit();
+      }
+
+      if (isolated.length === 1) {
+        return Promise.resolve(isolated[0].full_source);
+      }
+
+      // set up menu for selecting a post in case multiple match the search terms
+      var entries = isolated.map(function mapTitles(article) {
+        return [article.title, ' (', chalk.green(article.updated.format('YYYY-MM-DD')), ')'].join('');
+      });
+
+      return inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selected',
+          message: 'Select the post you want to isolate.',
+          choices: entries,
+        },
+      ]).then(function getAnswer(answer) {
+        var pos = entries.indexOf(answer.selected);
+        return isolated[pos].full_source;
+      });
+    }
+
+    function makeIsoObject(items, iso) {
+      var toStash = items.map(function mapSource(item) {
+        return item.full_source;
+      }).filter(function filterOutIsolated(item) {
+        return item !== iso;
+      });
+
+      return {
+        isolated: iso,
+        articlesToStash: toStash,
+      };
+    }
+
+    function doIsolate(itemObj) {
+      var newName;
+      var isolated = itemObj.isolated;
+      var toStash = itemObj.articlesToStash;
+
+      var movePromises = toStash.map(function makePromise(article) {
+        newName = path.join(exileDir, article.substr(article.lastIndexOf(path.sep)));
+        return new Promise(function returnPromise(resolve) {
+          resolve(move(article, newName));
+        });
+      });
+
+      // just for outputting a completed message
+      var thePost = (isolated) ? isolated : 'All posts';
+
+      return Promise.all(movePromises).then(function allDone() {
+        return thePost;
+      });
+    }
+
+    function move(origin, destination) {
+      // setting up the moving of the asset dirs in case they exist
+      var assetDir = path.join(path.parse(origin).dir, path.parse(origin).name);
+      var assetDirDestination = path.join(path.parse(destination).dir, path.parse(destination).name);
+      Promise.resolve(isDir(assetDir)).then(function checkAssetDir(exists) {
+        if (exists) {
+          fsRename(assetDir, assetDirDestination).then(function doAssetDirMove() {
+            // console.log('%s moved to %s', assetDir, assetDirDestination);
+          }).catch(function catchAssetDirMove(err) {
+            console.log('%s could not be moved to %s: %s', assetDir, assetDirDestination, err);
+          });
+        }
+      });
+      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);
+      });
+    }
+
+  }.bind(this));
+};
+

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

@@ -0,0 +1,145 @@
+'use strict';
+
+var Promise = require('bluebird');
+var chalk = require('chalk');
+var inquirer = require('inquirer');
+var fsStat = Promise.promisify(require('fs').stat);
+var fsUnlink = Promise.promisify(require('fs').unlink);
+var fsRmdir = Promise.promisify(require('rimraf'));
+
+module.exports = function modExports(args) {
+  var searchTerms;
+
+  if (!args._.join('')) {
+    console.log(chalk.red('You need to search for a specific post before you can remove it. Check `hexo help remove` for usage details.'));
+    process.exit();
+  } else {
+    // every whitespace-separated word in the input search is a case-insensitive regular expression
+    searchTerms = args._.map(function mapSearchTerms(arg) {
+      return new RegExp(arg, 'i');
+    });
+  }
+
+  // load database
+  this.load().then(function loadDb() {
+    var locals = this.locals;
+
+    // load posts and pages
+    getArticles(locals).then(function loadArticles(articles) {
+      return selectArticle(articles);
+    }).then(function processSelected(selected) {
+      return confirmRemove(selected);
+    }).catch(function failProcessSelected(err) {
+      console.log(err.stack ? chalk.red(err.stack) : chalk.gray(err));
+      process.exit();
+    });
+
+    function getArticles(data) {
+      return Promise.resolve(data.get('posts').toArray().concat(locals.get('pages').toArray()));
+    }
+
+    function filterOnName(articles, terms) {
+      return articles.filter(function filterArticles(article) {
+        return terms.every(function checkRE(term) {
+          return term.test(article.title) || term.test(article.slug);
+        });
+      });
+    }
+
+    function selectArticle(items) {
+      var filtered = filterOnName(items, searchTerms);
+
+      if (filtered.length === 0) {
+        return Promise.reject(chalk.red('No posts or pages found using your query.'));
+      }
+
+      if (filtered.length === 1) {
+        return Promise.resolve(filtered[0]);
+      }
+
+      var entries = filtered.map(function mapEntries(article) {
+        return [article.title, ' (', chalk.green(article.source), ')'].join('');
+      });
+
+      return inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selected',
+          message: 'Select the post or page you wish to rename.',
+          choices: entries,
+        },
+      ]).then(function getAnswer(answer) {
+        var pos = entries.indexOf(answer.selected);
+        return filtered[pos];
+      });
+    }
+
+    function confirmRemove(post) {
+      var message = '\n - Remove ' + chalk.green.underline(post.title) + '?\n' + chalk.red.bgBlack('Warning: this action is irreversible!');
+      var del = chalk.red('Delete it!');
+      var can = chalk.green('Cancel');
+
+      return inquirer.prompt([
+        {
+          type: 'list',
+          message: message,
+          name: 'answer',
+          choices: [
+            del,
+            can,
+          ],
+        },
+      ]).then(function getResponse(response) {
+        var ans = response.answer;
+
+        switch (ans) {
+        case del:
+          remove(post);
+          break;
+        case can:
+          console.log(chalk.gray('OK. See you later.'));
+          process.exit();
+          break;
+        default:
+          console.log(chalk.red('This shouldn\'t happen, please file a bug report.'));
+          process.exit();
+        }
+        return chalk.gray('Done.');
+      });
+    }
+
+    function remove(post) {
+      var src = post.full_source;
+
+      // first check if the file exists
+      fsStat(src).then(function getStats(stats) {
+        if (stats.isFile()) {
+
+          // delete the file
+          fsUnlink(src).then(function unlinkFile() {
+            var assetDir = src.substr(0, src.lastIndexOf('.'));
+            console.log(chalk.red.underline(src + ' deleted.'));
+
+            // check for the asset directory
+            fsStat(assetDir).then(function getAssetDirStats(adStats) {
+              if (adStats.isDirectory()) {
+
+                // delete the asset dir
+                fsRmdir(assetDir).then(function unlinkAssetDir() {
+                  console.log(chalk.red.underline(assetDir + ' (asset directory) deleted.'));
+                });
+              }
+            }).catch(function failAssetDir() {
+              console.log(chalk.gray('No asset dir found.'));
+            });
+          });
+        }
+      }).catch(function failRemove(err) {
+        console.log(chalk.red('Problem deleting article :', err));
+        process.exit();
+      });
+    }
+
+  }.bind(this));
+};
+

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

@@ -0,0 +1,171 @@
+'use strict';
+
+var Promise = require('bluebird');
+var chalk = require('chalk');
+var inquirer = require('inquirer');
+var fsReadFile = Promise.promisify(require('fs').readFile);
+var fsStat = Promise.promisify(require('fs').stat);
+var fsWriteFile = Promise.promisify(require('fs').writeFile);
+var fsRename = Promise.promisify(require('fs').rename);
+var slugize = require('hexo-util').slugize;
+var path = require('path');
+
+module.exports = function modExports(args) {
+  var oldName;
+  var newName = args.n || args.new || '';
+
+  if (!args._.join('') || !newName) {
+    console.log(chalk.red('Both a new and an old filename/title are required. `hexo rename help` to display help.'));
+    process.exit();
+  } else {
+    // every whitespace-separated word in the input search is a case-insensitive regular expression
+    oldName = args._.map(function makeRE(arg) {
+      return new RegExp(arg, 'i');
+    });
+  }
+
+  // load database
+  this.load().then(function loadDB() {
+    var selectedPost;
+
+    loadArticles(this.locals).then(function select(arts) {
+      return selectArticle(arts);
+    }).then(function selectRename(selected) {
+      selectedPost = selected;
+      return chooseRenameStyle(selectedPost);
+    }).then(function process(renameStyle) {
+      if (renameStyle === 'filename') {
+        return renameFile(selectedPost, newName);
+      } else if (renameStyle === 'title') {
+        return renameTitle(selectedPost, newName);
+      } else {
+        return renameTitle(selectedPost, newName).then(function alsoFilename() {
+          return renameFile(selectedPost, newName);
+        });
+      }
+    }).catch(function catchAll(err) {
+      console.log(err.stack ? chalk.red(err.stack) : chalk.red('Error: ') + chalk.gray(err));
+      process.exit();
+    });
+
+    function selectArticle(items) {
+      var articles = filterOnName(items, oldName);
+
+      if (articles.length === 0) {
+        return Promise.reject('No posts or pages found using your query.');
+      }
+
+      if (articles.length === 1) {
+        // no menu if there is only one result
+        return Promise.resolve(articles[0]);
+      }
+
+      var entries = articles.map(function mapArts(article) {
+        return [article.title, ' (', chalk.green(article.source), ')'].join('');
+      });
+
+      return inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selected',
+          message: 'Select the post or page you wish to rename.',
+          choices: entries,
+        },
+      ]).then(function getAnswer(answer) {
+        var pos = entries.indexOf(answer.selected);
+        return articles[pos];
+      });
+    }
+
+    function chooseRenameStyle(post) {
+      var message = '\n - Rename title (' + chalk.green.underline(post.title) + ') to ' +
+          chalk.cyan.underline(newName) + ' ?\n - Rename filename (' +
+          chalk.green.underline(post.source.substr(post.source.lastIndexOf(path.sep))) + ') to ' +
+          chalk.cyan.underline(slugize(newName, {transform: 1}) + '.md') + ' ?';
+
+      return inquirer.prompt([
+        {
+          type: 'list',
+          message: message,
+          name: 'answer',
+          choices: [
+            'Yes, rename both',
+            'Title only please (don\'t rename the file!)',
+            'Filename only please (don\'t rename the title!)',
+            'No, forget it, cancel everything.',
+          ],
+        },
+      ]).then(function processRes(response) {
+        var ans = response.answer;
+
+        switch (ans) {
+          case 'Yes, rename both':
+            return 'both';
+          case 'Title only please (don\'t rename the file!)':
+            return 'title';
+          case 'Filename only please (don\'t rename the title!)':
+            return 'filename';
+          default:
+            return Promise.reject('User cancelled rename operation');
+        }
+      });
+    }
+
+    function renameFile(art, renamed) {
+
+      var src = art.full_source;
+      var newSrc = path.join(src.substr(0, src.lastIndexOf(path.sep)), slugize(renamed, {transform: 1}));
+
+      // first the markdown file
+      return fsRename(src, newSrc + '.md').then(function doRenameMd() {
+        var fldr;
+
+        console.log(chalk.red(src) + ' renamed to ' + chalk.green(newSrc) + '.md');
+
+        fldr = src.substr(0, src.lastIndexOf('.'));
+
+        // then the folder if it exists
+        return fsStat(fldr).then(function doCheckDir(stats) {
+          if (stats.isDirectory()) {
+            return fsRename(fldr, newSrc).then(function doRenameDir() {
+              console.log(chalk.underline('Asset folder renamed as well.'));
+            });
+          } else {
+            return 'Done';
+          }
+        }).catch(function catchCheckDir() {
+          return console.log(chalk.underline('No asset folder found.'));
+        });
+      });
+
+    }
+
+    function renameTitle(art, newTitle) {
+      var oldTitle = art.title;
+      var oldTitleString = new RegExp('title:.*');
+
+      // change the title through the file system because changing it in the db caused issues
+      return fsReadFile(art.full_source, 'utf8').then(function doReadArt(data) {
+        var cont = data.replace(oldTitleString, 'title: "' + newTitle + '"');
+
+        return fsWriteFile(art.full_source, cont, 'utf8').then(function doWriteArt() {
+          console.log(chalk.red(oldTitle) + ' renamed to ' + chalk.green(newTitle));
+        });
+      });
+    }
+
+    function loadArticles(locals) {
+      return Promise.resolve(locals.get('posts').toArray().concat(locals.get('pages').toArray()));
+    }
+
+    function filterOnName(articles, terms) {
+      return articles.filter(function filterArts(article) {
+        return terms.every(function testRE(term) {
+          return term.test(article.title) || term.test(article.slug);
+        });
+      });
+    }
+
+  }.bind(this));
+};
+

package/packages/hexo-cli-extras/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "hexo-cli-extras",
+  "description": "Hexo plugin that adds an edit, rename, remove, isolate and integrate command for easier command line administration of your Hexo-powered website.",
+  "keywords": [
+    "hexo",
+    "plugin",
+    "cli",
+    "command line"
+  ],
+  "version": "1.0.4",
+  "main": "index",
+  "author": "Gregory Scheerlinck <gregory.scheerlinck@gmail.com> (http://gregjs.com)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/greg-js/hexo-cli-extras.git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "lint": "eslint index.js lib/*.js"
+  },
+  "dependencies": {
+    "bluebird": "^3.0.5",
+    "chalk": "^2.4.2",
+    "hexo-util": "^0.6.3",
+    "inquirer": "^6.2.2",
+    "moment": "^2.10.6",
+    "opn": "^5.4.0",
+    "rimraf": "^2.4.3",
+    "minimist": "^1.2.5"
+  },
+  "devDependencies": {
+    "eslint": "^2.11.0"
+  }
+}

package/packages/hexo-extend-injector2/.eslintrc

@@ -0,0 +1,4 @@
+{
+  "extends": "hexo",
+  "root": true
+}

package/packages/hexo-extend-injector2/.github/workflows/linter.yml

@@ -0,0 +1,27 @@
+name: Linter
+
+on: [push, pull_request]
+
+jobs:
+  linter:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Use Node.js 12.x
+        uses: actions/setup-node@v2
+        with:
+          node-version: '12.x'
+      - name: Cache NPM dependencies
+        uses: actions/cache@v1
+        with:
+          path: node_modules
+          key: ${{ runner.OS }}-npm-cache
+          restore-keys: |
+            ${{ runner.OS }}-npm-cache
+      - name: Install Dependencies
+        run: npm install
+      - name: Lint
+        run: |
+          npm run eslint
+        env:
+          CI: true

package/packages/hexo-extend-injector2/.github/workflows/tester.yml

@@ -0,0 +1,24 @@
+name: Tester
+
+on: [push, pull_request]
+
+jobs:
+  tester:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        node-version: ['10.x', '12.x', '14.x']
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install Dependencies
+        run: npm install
+      - name: Test
+        run: npm run test
+        env:
+          CI: true

package/packages/hexo-extend-injector2/.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+  "eslint.options": {
+    "rules": {
+      "linebreak-style": "off"
+    }
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true
+  }
+}