How to use decomment - 9 common examples

let matches, type, arg;
    const lines = source.match(LINES);

    for (let i = 0; i < lines.length - 1 /* last line is always empty */; i++) {
      const text = lines[i];

      if (matches = text.match(DIRECTIVE)) {
        const token = {_line: 1 + i};

        type = matches[1];
        arg = matches[2].trim();
        token.args = [];

        // remove single line comments from arg
        arg = decomment.text(arg);

        switch (type) {

          case 'include':
            // detect "once" flag
            if (/^once\b/.test(arg)) {
              token.args.push('once');
              arg = arg.substr(5).trim();
            }

            this._checkArgumentIsNonempty(type, arg, token._line);
            token.type = TOKENS.INCLUDE;
            token.args.push(arg);
            break;

          case 'set':

jsPreprocess(jsText) {
    let newContent = jsText;
    // check the code for js errors before sending it to strip comments
    // or loops.
    JSHINT(newContent);

    if (JSHINT.errors.length === 0) {
      newContent = decomment(newContent, {
        ignore: /\/\/\s*noprotect/g,
        space: true
      });
      newContent = loopProtect(newContent);
    }
    return newContent;
  }

jsPreprocess(jsText) {
    let newContent = jsText;
    // check the code for js errors before sending it to strip comments
    // or loops.
    JSHINT(newContent);

    if (JSHINT.errors.length === 0) {
      newContent = decomment(newContent, {
        ignore: /\/\/\s*noprotect/g,
        space: true
      });
      newContent = loopProtect(newContent);
    }
    return newContent;
  }

.then(data => {
        // Uncomment files as if they were plain text files (avoiding issues with jsx)
        outputFile(filePath, decomment.text(data));
      })
      .catch(err => {

function getFileLines (file) {
  const lines = [];
  let decommented, EOL;
  const strFile = fs.readFileSync(file).toString().replace(/#/g, ' ');
  try {
    EOL = decomment.getEOL(strFile);
    decommented = decomment(strFile);
  } catch (e) {
    console.error(file, e);
    return lines;
  }
  decommented.split(EOL)
    .forEach(line => lines.push(line));
  return lines;
}

getText() {
    if (this.props.isEnabled) {
      if (this.props.stageOperator) {
        if (this.props.stageOperator === OUT && this.props.isValid) {
          return `Documents will be saved to the collection: ${decomment(this.props.stageValue)}`;
        }
        const stageInfo = STAGE_SPRINKLE_MAPPINGS[this.props.stageOperator];
        return (
          <div>
            <span>
              Output after <span>
                {this.props.stageOperator}
              </span> stage
            </span>
            {this.renderInfoSprinkle(stageInfo)}
            <span>(Sample of {this.props.count} {this.getWord()})</span>
          </div>
        );
      }

renderOutSection() {
    if (this.props.isComplete) {
      return (
        <div>
          <div>
            Documents persisted to collection: {decomment(this.props.stage)}.
          </div>
          <div>
            Go to collection.
          </div>
        </div>
      );
    }
    return (
      <div>
        <div>
          The $out operator will cause the pipeline to persist the results
          to the specified collection. If the collection exists it will be
          replaced. Please confirm to execute.
        </div></div>

export default function generateStage(state) {
  if (!state.isEnabled || !state.stageOperator || state.stage === '') {
    return {};
  }
  const stage = {};
  try {
    const decommented = decomment(state.stage);
    parse(`{${state.stageOperator}: ${decommented}}`);
    stage[state.stageOperator] = parser(decommented);
  } catch (e) {
    state.syntaxError = e.message;
    state.isValid = false;
    state.previewDocuments = [];
    return {};
  }
  state.isValid = true;
  state.syntaxError = null;
  return stage;
}

gulpDecomment.html = function (options) {
    return main(options, decomment.html);
};