How to use atom-linter - 10 common examples

}

        // output raw command for debugging assistance
        if (atom.config.get('linter-jenkins.debug')) {
          stdin = cmd == 'curl' ? '' : ` < ${activeEditor.getPath()}`;
          return [{severity: 'info',
                   excerpt: cmd + ' ' + args.join(' ') + stdin,
                   location: {
                     file: file,
                     position: [[0, 0], [0, 1]]
                   }
                 }];
        }

        // lint
        return helpers.exec(cmd, args, opts).then(output => {
          var toReturn = [];

          output.split(/\r?\n/).forEach(function (line) {
            // matcher for output parsing and capturing
            const matches = regex.exec(line);

            // check for errors
            if (matches != null) {
              toReturn.push({
                severity: 'error',
                excerpt: matches[1],
                location: {
                  file: file,
                  position: [[Number.parseInt(matches[2]) - 1, Number.parseInt(matches[3]) - 1], [Number.parseInt(matches[2]) - 1, Number.parseInt(matches[3])]],
                },
              });

break;
      }

      // --suppress
      for (var suppress of atom.config.get('linter-cppcheck.suppress') || []) {
        args.push(`--suppress=${suppress}`);
      }

      // 
      args.push(textEditor.getPath());

      const executable = atom.config.get('linter-cppcheck.executable');
      console.debug(`[linter-cppcheck] Executing '${executable}' with args:` +
                    ` ${JSON.stringify(args, undefined, 2)}`);

      return exec(
        executable,
        args,
        {
          stream: 'both',
          throwOnStderr: false,
        }
      ).then((output) => {
        if (output.exitCode != 0) {
          atom.notifications.addError(
            'Cppcheck failed',
            {
              buttons: [
                {
                  className: 'btn icon icon-gear',
                  onDidClick: ()=>{
                    atom.workspace.open("atom://config/packages/linter-cppcheck");

// Debug the command executed to run the Code Climate CLI to the console
        if (atom.inDevMode()) {
          // eslint-disable-next-line no-console
          console.log('linter-codeclimate:: Command: ' +
            `\`${this.executablePath} ${execArgs.join(' ')}\``);
        }

        // Start measure for how long the analysis took.
        const measureId = `linter-codeclimate: \`${relpath}\` analysis`;
        startMeasure(measureId);

        // Execute the Code Climate CLI, parse the results, and emit them to the
        // Linter package as warnings. The Linter package handles the styling.
        let result;
        try {
          result = await Helpers.exec(this.executablePath, execArgs, execOpts);
        } catch (e) {
          notifyError(e, `${this.executablePath} ${execArgs.join(' ')}`);
          return null;
        }

        // Handle unique spawning: killed execs will return null
        if (result === null) {
          return null;
        }

        let messages;
        try {
          messages = JSON.parse(result);
        } catch (e) {
          notifyError(
            e, `${this.executablePath} ${execArgs.join(' ')}`,

hints = [`--hint=${hlintConfig}`];
        } else {
          // It's outside the project, or not found
          hints = [];
        }
        if (this.ignoreReduceDuplication) {
          hints.push('--ignore="Reduce duplication"');
        }
        const execArgs = baseArgs.concat(hints);

        const execOpts = {
          ignoreExitCode: true,
          cwd: fileDir,
        };

        const output = await exec(this.executablePath, execArgs, execOpts);
        let info;
        try {
          info = JSON.parse(output);
        } catch (error) {
          // eslint-disable-next-line no-console
          console.error('Unable to parse output:', output);
          return null;
        }
        return info.map((error) => {
          const message = {
            excerpt: `${error.hint}: ${error.from} ==> ${error.to}`,
            location: {
              file: filePath,
              position: [
                [error.startLine - 1, error.startColumn - 1],
                [error.endLine - 1, error.endColumn - 1],

servers.forEach((server, rootDirectory) => {
      const executable = this.executablePath || findCached(rootDirectory, defaultFlowBinLocation) || 'flow'
      exec(executable, ['stop'], {
        cwd: rootDirectory,
        timeout: 60 * 1000,
        detached: true,
        ignoreExitCode: true,
      }).catch(() => null) // <-- ignore all errors
    })
  },

const lintMix = async (textEditor) => {
  const filePath = textEditor.getPath();
  const fileText = textEditor.getText();
  const execOpts = await getOpts(filePath);

  const result = await exec(mixPath, ['compile'], execOpts);
  if (textEditor.getText() !== fileText) {
    // File contents have changed since the run was triggered, don't update messages
    return null;
  }
  return handleResult(result, filePath);
};

projectDir = atom.project.getDirectories().find(
      (dir) => {
        return dir.contains(textEditor.getPath() )
      }
    )
    projectDir = projectDir && projectDir.path ? projectDir.path : null;

    options = {
      env: {
          "RAKUDO_ERROR_COLOR": 0
      },
      cwd: projectDir,
      stream : "both",
      stdin  : textEditor.getText()
    }
    return helpers.exec(command, args, options).then( (output) => {

      // return nothing if no errors are found
      if (output.stdout.match(/Syntax OK\n?/i) && output.stderr == "") {
        return []
      }

      // Try to find the error message and line number
      regex = /.+?[\r\n]((?:.|[\r\n])+\s+at\s+.+?(\d+)(?:\.|[\r\n]|$)[\s\S]*)/
      stderr = output.stderr
      match = regex.exec(stderr)
      if (match) {
        // Success; Remove the ansi escape sequence noise from the message
        message = match[1]
        line    = match[2] - 1
      } else {
        // We failed, at least show the message without line number information

for (i = 0; i < atom.config.get('linter-terraform-syntax.globalVarFiles').length; i++)
              args.push(...['-var-file', atom.config.get('linter-terraform-syntax.globalVarFiles')[i]]);

          // add local var files
          if (atom.config.get('linter-terraform-syntax.localVarFiles')[0] != '')
            for (i = 0; i < atom.config.get('linter-terraform-syntax.localVarFiles').length; i++)
              args.push(...['-var-file', atom.config.get('linter-terraform-syntax.localVarFiles')[i]]);

          // do not check if required variables are specified if desired
          if (!(atom.config.get('linter-terraform-syntax.checkRequiredVar')) && !(atom.config.get('linter-terraform-syntax.useTerraformPlan')))
            args.push('-check-variables=false')
        }

        // execute terraform fmt if selected
        if (atom.config.get('linter-terraform-syntax.useTerraformFormat'))
          helpers.exec(atom.config.get('linter-terraform-syntax.terraformExecutablePath'), ['fmt', '-list=false', dir])

        return helpers.exec(atom.config.get('linter-terraform-syntax.terraformExecutablePath'), args, options).then(output => {
          var toReturn = [];

          // new terraform validate will be doing JSON parsing
          if (!(atom.config.get('linter-terraform-syntax.useTerraformPlan')) && atom.config.get('linter-terraform-syntax.newVersion')) {
            // parse json output
            const info = JSON.parse(output)

            // command is reporting an issue
            if (info.valid == false) {
              info.diagnostics.forEach((issue) => {
                // if no range information given we have to improvise
                var file = dir;
                var line_start = 0;
                var line_end = 0;

activate() {
    const helpers = require('atom-linter');

    // check for ansible-lint >= minimum version
    helpers.exec(atom.config.get('linter-ansible-linting.ansibleLintExecutablePath'), ['-T']).then(output => {
      if (!(/repeatability/.exec(output))) {
        atom.notifications.addWarning(
          'ansible-lint < 3.5 is unsupported. Backwards compatibility should exist, but is not guaranteed.',
          {
            detail: "Please upgrade your version of ansible-lint to >= 3.5.\n",
            dismissable: true
          }
        );
      }
    });
  },

// Setup args
        const args = ['--relative', '--json', '--error-level', errorLevel];

        const optionsMap = require('./flags.js');

        // Add the flags to the command options
        Object.keys(allSettings).forEach((flag) => {
          if (Object.hasOwnProperty.call(optionsMap, flag) && allSettings[flag] === true) {
            args.push(optionsMap[flag]);
          }
        });

        // Add the file to be checked to the arguments
        args.push(projectRelativeFilePath);

        return helpers.exec(executablePath, args, { cwd: projectPath, ignoreExitCode: true })
          .then((output) => {
            const toReturn = [];

            // If puppet-lint errors to stdout then redirect the message to atom error notifications
            if (/puppet-lint:/.exec(output)) {
              atom.notifications.addError(
                'Puppet-Lint errored due to the following reason(s):',
                {
                  detail: output,
                },
              );

              // return early
              return toReturn;
            }