TypeScript TextEditor.getText方法代码示例

 function editorFormat(input: string) {
   editor.setText(input)
   if (opts.selectBeforeTest) {
     editor.setSelectedBufferRange(editor.getBuffer().getRange())
   }
   atom.commands.dispatch(
     atom.views.getView(editor),
     'markdown-table-formatter:format',
   )
   return editor.getText()
 }

export async function prettifyFile(editor: TextEditor) {
  const [firstCursor, ...cursors] = editor
    .getCursors()
    .map((cursor) => cursor.getBufferPosition())
  const format = editor.getGrammar().scopeName
  const prettify = format === 'source.cabal' ? cabalFormat : filterFormat
  const workDir = (await getRootDir(editor.getBuffer())).getPath()
  try {
    const { stdout, stderr } = await prettify(
      editor.getText(),
      workDir,
      editor.getRootScopeDescriptor(),
    )
    editor.setText(stdout)
    const lastCursor = editor.getLastCursor()
    if (lastCursor) {
      lastCursor.setBufferPosition(firstCursor, { autoscroll: false })
    }
    cursors.forEach((cursor) => {
      editor.addCursorAtBufferPosition(cursor, { autoscroll: false })
    })
    if (stderr.length > 0) {
      atom.notifications.addWarning(
        'Prettifier reported the following problems:',
        {
          detail: stderr,
          dismissable: true,
        },
      )
    }
  } catch (e) {
    const err: Error = e.error || e
    let stderr: string = e.stderr ? e.stderr.trim() : ''
    if (err.message.includes(stderr)) {
      stderr = ''
    }
    atom.notifications.addError('Failed to prettify', {
      detail: `${stderr ? `${stderr}\n\n` : ''}${err.message}`,
      stack: err.stack,
      dismissable: true,
    })
  }
}

  lint: async (textEditor: TextEditor): Promise<LintResult> => {
    const filePath = textEditor.getPath();

    if (!filePath) {
      // The current TextEditor has no path associated with it.
      return null;
    }

    const input = textEditor.getText();

    const command = atom.config.get("linter-swiftlint.swiftlintExecutablePath");
    if (!fs.existsSync(command)) {
      return null;
    }

    const parameters = ["lint", "--use-stdin"];
    let config = path.normalize(
      atom.config.get("linter-swiftlint.configurationPath")
    );

    if (filePath && !path.isAbsolute(config)) {
      config =
        atom.project
          .getDirectories()
          .filter(directory => directory.contains(filePath))
          .map(directory => directory.getFile(config).getPath())
          .find(() => true) || config; // take first item if exists
    }

    if (config && fs.existsSync(config)) {
      parameters.push("--config", config);
    }

    const additionalOptions = atom.config.get(
      "linter-swiftlint.additionalOptions"
    );
    if (additionalOptions) {
      parameters.push(additionalOptions);
    }

    const options = {
      ignoreExitCode: true,
      stdin: input,
      throwOnStderr: false
    };

    const output = await helpers.exec(command, parameters, options);

    const messages: Message[] = [];
    let match = regex.exec(output);
    while (match !== null) {
      const line = Math.max(Number.parseInt(match[1], 10) - 1, 0);
      const col = Math.max(Number.parseInt(match[2], 10) - 1, 0);
      let position: Range;
      try {
        position = helpers.generateRange(textEditor, line, col);
      } catch(e) {
        // If the position wasn't valid, just return the start of the file
        // NOTE: Ideally this would handle the error and give the user an easy
        // way to report it for eventual fixing.
        position = new Range([0, 0], [0, Number.POSITIVE_INFINITY]);
      }

      const type = match[3].toLowerCase();
      const severity =
        type === 'error' || type === 'warning' || type === 'info' ?
        type : 'error';

      messages.push({
        severity,
        excerpt: match[4],
        location: {
          file: filePath,
          position,
        }
      });

      // Pull in the next result (if any)
      match = regex.exec(output);
    }

    return messages;
  }