Hexo 自动提取摘要

const htmlparser = require("htmlparser2");
const domutils = require("domutils");
const defaults = require("lodash.defaults");

// hexo-excerpt 中提供的方法，具体见下文
const Filter = require("./lib/dom-filter");
const DEFAULT_CONFIG = {
  depth: 2,
  excerpt_excludes: [],
  more_excludes: [],
  hideWholePostExcerpts: false,
};

// 注册过滤器，参考 hexo-auto-excerpt
hexo.extend.filter.register("after_post_render", excerpt);

// 全局参数
let excerptFilter;
let moreFilter;
let opts;
/**
 * 提取文章摘要, 此部分提取自 hexo-excerpt
 * @param {Document} post 文章
 */
function excerpt(post) {
  init();
  //honour the <!-- more --> !!!
  if (
    /<!--\s*more\s*-->/.test(post.content) ||
    post.content.indexOf('<a id="more"></a>') !== -1
  ) {
    return post;
  }

  let nodes = [];

  let parser = new htmlparser.Parser(
    new htmlparser.DomHandler((err, dom) => {
      if (!err) {
        nodes = dom;
      }
    }),
    {
      decodeEntities: false,
    }
  );

  parser.write(post.content);
  parser.done();

  // tracks how many tag nodes we found
  let stopIndex = 1;
  // tracks how many nodes we found in total
  let index = 0;
  for (; index < nodes.length && stopIndex <= opts.depth; index++) {
    if (nodes[index].type === "tag" && excerptFilter.match(nodes[index])) {
      stopIndex++;
    }
  }

  // set correct excerpt and more nodes values
  let excerptNodes = nodes.slice(0, index);
  let moreNodes = nodes.slice(index);

  // filter nodes
  excerptNodes = excerptFilter.filter(excerptNodes);
  moreNodes = moreFilter.filter(moreNodes);

  // If the hideWholePostExcerpts option is set to true (the default), don't show
  // excerpts for short posts (i.e. ones where the excerpt is the whole post)
  if (moreNodes.length != 0 || !opts.hideWholePostExcerpts) {
    post.excerpt = excerptNodes
      .map((node) => domutils.getOuterHTML(node))
      .join("");
    post.more = moreNodes.map((node) => domutils.getOuterHTML(node)).join("");
  }

  return post;
}

/**
 * 初始化配置
 */
function init() {
  const config = hexo.config;
  let legacy = {};
  if (config.excerpt_depth) {
    hexo.log.warn(
      "excerpt_depth is deprecated, please use excerpt.depth instead."
    );
    legacy.depth = config.excerpt_depth;
  }

  opts = opts || defaults({}, config.excerpt, legacy, DEFAULT_CONFIG);
  opts.depth = parseInt(opts.depth);
  if (!Array.isArray(opts.excerpt_excludes))
    opts.excerpt_excludes = [opts.excerpt_excludes];
  if (!Array.isArray(opts.more_excludes))
    opts.more_excludes = [opts.more_excludes];
  excerptFilter = excerptFilter || new Filter(hexo, opts.excerpt_excludes);
  moreFilter = moreFilter || new Filter(hexo, opts.more_excludes);
}

const domutils = require("domutils");
const CSSselect = require("css-select");

function Filter(hexo, excludes) {
  this.hexo = hexo;
  this.selectors = excludes.map(this._compile.bind(this));
}

Filter.prototype._compile = function (selector) {
  try {
    return CSSselect.compile(selector);
  } catch (err) {
    this.hexo.log.error(
      "hexo-excerpt: Ignore invalid CSS selector: " + selector
    );
    return (n) => false;
  }
};

Filter.prototype.match = function (node) {
  // not match any
  return !this.selectors.some((s) => s(node));
};

Filter.prototype.filter = function (nodes) {
  // remove inner nodes that doesn't match
  domutils
    .filter((n) => !this.match(n), nodes)
    .forEach((node) => {
      domutils.removeElement(node);
    });

  // only keep top level nodes that match
  return nodes.filter(this.match.bind(this));
};

module.exports = Filter;

const pagination = require("hexo-pagination");
hexo.extend.generator.register("tag", generator);
function generator(db) {
  const config = this.config;
  const perPage = config.tag_generator.per_page;
  const paginationDir = config.pagination_dir || "page";
  const orderBy = config.tag_generator.order_by || "-date";
  const tags = db.tags;
  let tagDir;

  init();

  const pages = tags.reduce((result, tag) => {
    if (!tag.length) return result;

    const posts = tag.posts.sort(orderBy);
    // 预处理 posts，提取摘要，excerpt 方法定义在上文
    posts.data = posts.data.map(excerpt);
    const data = pagination(tag.path, posts, {
      perPage: perPage,
      layout: ["tag", "archive", "index"],
      format: paginationDir + "/%d/",
      data: {
        tag: tag.name,
      },
    });
    return result.concat(data);
  }, []);

  // generate tag index page, usually /tags/index.html
  if (config.tag_generator.enable_index_page) {
    tagDir = config.tag_dir;
    if (tagDir[tagDir.length - 1] !== "/") {
      tagDir += "/";
    }

    pages.push({
      path: tagDir,
      layout: ["tag-index", "tag", "archive", "index"],
      // posts: db.posts,
      data: {
        base: tagDir,
        total: 1,
        current: 1,
        current_url: tagDir,
        // posts: db.posts,
        prev: 0,
        prev_link: "",
        next: 0,
        next_link: "",
        tags: tags,
      },
    });
  }
  return pages;
}

/**
 * 文章属性打印
 * 查看其文章结构
 * @param {Document} document 文章
 */
function documentPrint(document) {
  if (document instanceof Array) {
    console.log("documentPrint ====== begin");
    document.forEach((item) => documentPrint(item));
    console.log("documentPrint ====== end");
    return;
  }
  for (const key in document) {
    if (document.hasOwnProperty(key)) {
      const value = document[key];
      if (!"more、_content、raw".includes(key)) {
        console.log("====> %o: %o", key, value);
      } else {
        console.log("====> %o: %o", key, "[blog]");
      }
    }
  }
}