istanbul ignore next
196646
function smartTruncate(input) {
  if (input.length < 60000) {
    return input;
  }
  const releaseNotesMatch = input.match(
    new RegExp(`### Release Notes.*### ${appName} configuration`, 'ms')
  );
  // istanbul ignore if
  if (releaseNotesMatch) {
    const divider = `</details>\n\n---\n\n### ${appName} configuration`;
    const [releaseNotes] = releaseNotesMatch;
    const nonReleaseNotesLength =
      input.length - releaseNotes.length - divider.length;
    const availableLength = 60000 - nonReleaseNotesLength;
    return input.replace(
      releaseNotes,
      releaseNotes.slice(0, availableLength) + divider
    );
  }
  return input.substring(0, 60000);
}
175191
def Ignore(self, target, dependency):
        """"""
        tlist = self.arg2nodes(target, self.fs.Entry)
        dlist = self.arg2nodes(dependency, self.fs.Entry)
        for t in tlist:
            t.add_ignore(dlist)
        return tlist
337889
function _firstNotWs(doc, lineNum) {
        var text = doc.getLine(lineNum);
        if (text === null || text === undefined) {
            return 0;
        }

        return text.search(/\S|$/);
    }
1267087
@Override
    public ResponseToRoom ignore(String... params) {
        excludedVars.addAll(Arrays.asList(params));
        return this;
    }
924214
function(next) {
            if (options.noModules) return next();
            var opts = {
                denyModules: options.denyModules || core.denyModules[core.role] || core.denyModules[""],
                allowModules: options.allowModules || core.allowModules[core.role] || core.allowModules[""],
                stopOnError: options.stopOnError || core.stopOnError,
            };
            var modules = path.resolve(__dirname, "../modules");
            core.loadModules(modules, opts);
            core.path.modules.forEach(function(mod) {
                if (modules == path.resolve(mod)) return;
                core.loadModules(mod, opts);
            });
            next();
        }
632866
function(next) {
          async.map([src,dest], function(path, done) {
            fs.stat(path, function(err, stat) {
              done(null, stat); // Ignore error
            });
          },
          function(err, results) {
            statSrc  = results[0];
            statDest = results[1];
            if(!statSrc) {
              // src is needed
              next(new Error('File not found: ' + src));
            }
            // Ignore anything that is not directory or file
            if(!(statSrc.isFile() || statSrc.isDirectory())) {
              grunt.verbose.writeln('  Ignore:'+' Source is not a file or a directory.'.grey);
              return done(null, false);
            }

            // Add stat to options for user defined transform & process
            options.statSrc  = statSrc;
            options.statDest = statDest;

            next();
          });
        }
1079468
function cleanUpOldExecutable(next) {
        fs.unlink(nodeCompiler.releasePath, function(err) {
          if (err) {
            if (err.code === 'ENOENT') {
              next();
            } else {
              throw err;
            }
          } else {
            next();
          }
        });
      }
210857
function ignoreNode(node) {
            const unknownNodeTokens = new Set(sourceCode.getTokens(node, { includeComments: true }));

            unknownNodeTokens.forEach(token => {
                if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) {
                    const firstTokenOfLine = tokenInfo.getFirstTokenOfLine(token);

                    if (token === firstTokenOfLine) {
                        offsets.ignoreToken(token);
                    } else {
                        offsets.setDesiredOffset(token, firstTokenOfLine, 0);
                    }
                }
            });
        }
559298
def forget_masks(self):
        """"""
        self._seqno = 1
        self._maskobjs = []
        self._treepaths = []
        self.tree_dict = Bunch.caselessDict()
        self.redo()
1190150
function(next) {
            core.allowPackages.forEach(function(pkg) {
                try {
                    var mod = path.dirname(require.resolve(pkg)).replace(/\/lib$/, "");
                    core.packages[pkg] = { path: mod };
                    if (lib.statSync(mod + "/etc").isDirectory()) {
                        core.packages[pkg].etc = 1;
                        var cfg = lib.readFileSync(mod + "/etc/config");
                        if (cfg) {
                            config = cfg + "\n" + config;
                            core.packages[pkg].config = 1;
                            core.parseConfig(cfg, 1);
                        }
                    }
                    ["modules","locales","views","web"].forEach(function(x) {
                        if (lib.statSync(mod + "/" + x).isDirectory()) {
                            core.path[x].unshift(mod + "/" + x);
                            core.packages[pkg][x] = 1;
                        }
                    });
                    logger.debug("init:", "npm package:", pkg, core.packages[pkg]);
                } catch(e) {
                    logger.error("init:", "npm package:", pkg, e);
                }
            });
            next();
        }
841236
def push_silent(text, can_suppress = false)
      flush_merged_text
      return if can_suppress && @options.suppress_eval?
      newline = (text == "end") ? ";" : "\n"
      @temple << [:code, "#{resolve_newlines}#{text}#{newline}"]
      @output_line = @output_line + text.count("\n") + newline.count("\n")
    end
462416
static function ignoreStatement($tokens, &$i) {

    for (;; ++$i) {
      if (';' === $token = $tokens[$i]) {
        ++$i;
        return NULL;
      }
      elseif ('(' === $token) {
        if (FALSE === ParserUtil::skipCurvy($tokens, $i)) {
          return FALSE;
        }
      }
      elseif ('{' === $token) {
        if (FALSE === ParserUtil::skipCurly($tokens, $i)) {
          return FALSE;
        }
        return NULL;
      }
      elseif (')' === $token) {
        return FALSE;
      }
      elseif ('}' === $token) {
        return FALSE;
      }
      elseif ('#' === $token) {
        return FALSE;
      }
    }

    return FALSE;
  }
686174
private void skipScript() {
        if (!atTerminator()) {
            int oldIndex = index;
            ++index;

            char c;
            while (!isTerminatorOrIDSeparator(c = next()) && AsciiUtil.isAlpha(c));
            --index;

            if (index - oldIndex != 5) { // +1 to account for separator
                index = oldIndex;
            }
        }
    }
812434
protected boolean ignore(VDMToken tok) throws LexException
	{
		if (lastToken().is(tok))
		{
			nextToken();
			return true;
		} else
		{
			return false;
		}
	}
718934
function(msg) {
      // eslint-disable-next-line no-console
      if (console.debug) {
        // eslint-disable-next-line no-console
        console.debug.apply(console, arguments);
      } else {
        // eslint-disable-next-line no-console
        console.log.apply(console, arguments);
      }
    }
1049323
function next() {
	
		var fns = activeQueue.shift();

		if ( !fns ) {
			return;
		}

		ret = ret.then(
			typeof fns[0] === 'function' ? fns[0].bind(self) : fns[0],
			typeof fns[1] === 'function' ? fns[1].bind(self) : fns[1]
		);

		next();
	}
1363221
public function ignoreVerticalSpace()
    {
        ignoreHorizontalSpace:
        if (! $this->isEnd() && $this->currentAscii()->isVerticalSpace()) {
            $this->next();
            goto ignoreHorizontalSpace;
        }
    }