module SyntaxSuggest

Constants

DEFAULT_VALUE: Wird verwendet, um einen Standardwert anzuzeigen, der nicht mit einer anderen Eingabe verwechselt werden kann.
TIMEOUT_DEFAULT
VERSION

Öffentliche Klassenmethoden

call (source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: DEFAULT_VALUE, timeout: TIMEOUT_DEFAULT, io: $stderr)

Source

# File lib/syntax_suggest/api.rb, line 91
def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: DEFAULT_VALUE, timeout: TIMEOUT_DEFAULT, io: $stderr)
  search = nil
  filename = nil if filename == DEFAULT_VALUE
  Timeout.timeout(timeout) do
    record_dir ||= ENV["DEBUG"] ? "tmp" : nil
    search = CodeSearch.new(source, record_dir: record_dir).call
  end

  blocks = search.invalid_blocks
  DisplayInvalidBlocks.new(
    io: io,
    blocks: blocks,
    filename: filename,
    terminal: terminal,
    code_lines: search.code_lines
  ).call
rescue Timeout::Error => e
  io.puts "Search timed out SYNTAX_SUGGEST_TIMEOUT=#{timeout}, run with SYNTAX_SUGGEST_DEBUG=1 for more info"
  io.puts e.backtrace.first(3).join($/)
end

SyntaxSuggest.call [Privat]

Hauptschnittstelle für private Methoden

handle_error (e, re_raise: true, io: $stderr)

Source

# File lib/syntax_suggest/api.rb, line 68
def self.handle_error(e, re_raise: true, io: $stderr)
  unless e.is_a?(SyntaxError)
    io.puts("SyntaxSuggest: Must pass a SyntaxError, got: #{e.class}")
    raise e
  end

  file = PathnameFromMessage.new(e.message, io: io).call.name
  raise e unless file

  io.sync = true

  call(
    io: io,
    source: file.read,
    filename: file
  )

  raise e if re_raise
end

SyntaxSuggest.handle_error [Öffentlich]

Nimmt eine `SyntaxError`-Ausnahme entgegen, verwendet die Fehlermeldung, um die Datei zu lokalisieren. Anschließend wird die Datei analysiert, um die Stelle des Syntaxfehlers zu finden und diese Stelle an stderr auszugeben.

Beispiel

begin
  require 'bad_file'
rescue => e
  SyntaxSuggest.handle_error(e)
end

Standardmäßig wird die Ausnahme erneut ausgelöst, es sei denn, `re_raise: false`. Der Ausgabestandort der Nachricht kann mit der Eingabe `io: $stderr` konfiguriert werden.

Wenn kein gültiger Dateiname ermittelt werden kann, wird die ursprüngliche Ausnahme erneut ausgelöst (auch mit `re_raise: false`).

invalid? (source)

Source

# File lib/syntax_suggest/api.rb, line 156
def self.invalid?(source)
  source = source.join if source.is_a?(Array)
  source = source.to_s

  Prism.parse(source).failure?
end

module_for_detailed_message ()

Source

# File lib/syntax_suggest/core_ext.rb, line 9
def self.module_for_detailed_message
  Module.new {
    def detailed_message(highlight: true, syntax_suggest: true, **kwargs)
      return super unless syntax_suggest

      require "syntax_suggest/api" unless defined?(SyntaxSuggest::DEFAULT_VALUE)

      message = super

      if path
        file = Pathname.new(path)
        io = SyntaxSuggest::MiniStringIO.new

        SyntaxSuggest.call(
          io: io,
          source: file.read,
          filename: file,
          terminal: highlight
        )
        annotation = io.string

        annotation += "\n" unless annotation.end_with?("\n")

        annotation + message
      else
        message
      end
    rescue => e
      if ENV["SYNTAX_SUGGEST_DEBUG"]
        $stderr.warn(e.message)
        $stderr.warn(e.backtrace)
      end

      # Ignore internal errors
      message
    end
  }
end

SyntaxSuggest.module_for_detailed_message [Privat]

Wird verwendet, um `SyntaxError` über Module.prepend zu monkeypatchen

record_dir (dir)

Source

# File lib/syntax_suggest/api.rb, line 116
def self.record_dir(dir)
  time = Time.now.strftime("%Y-%m-%d-%H-%M-%s-%N")
  dir = Pathname(dir)
  dir.join(time).tap { |path|
    path.mkpath
    alias_dir = dir.join("last")
    FileUtils.rm_rf(alias_dir) if alias_dir.exist?
    FileUtils.ln_sf(time, alias_dir)
  }
end

SyntaxSuggest.record_dir [Privat]

Wird verwendet, um ein eindeutiges Verzeichnis zum Aufzeichnen von Suchschritten für Debugging-Zwecke zu generieren

use_prism_parser? ()

Source

# File lib/syntax_suggest/api.rb, line 42
def self.use_prism_parser?
  defined?(Prism)
end

SyntaxSuggest.use_prism_parser? [Privat]

Gibt an, ob der Prism-Parser verfügbar ist oder ob auf `Ripper` zurückgegriffen werden soll

valid? (source)

Source

# File lib/syntax_suggest/api.rb, line 207
def self.valid?(source)
  !invalid?(source)
end

SyntaxSuggest.valid? [Privat]

Gibt wahr zurück, wenn die gegebene Quelleneingabe syntaktisch korrekt ist

SyntaxSuggest.valid?(<<~EOM) # => true
  def foo
  end
EOM

SyntaxSuggest.valid?(<<~EOM) # => false
  def foo
    def bar # Syntax error here
  end
EOM

Sie können auch ein Array von Zeilen übergeben, und diese werden vor der Auswertung zusammengefügt

SyntaxSuggest.valid?(
  [
    "def foo\n",
    "end\n"
  ]
) # => true

SyntaxSuggest.valid?(
  [
    "def foo\n",
    "  def bar\n", # Syntax error here
    "end\n"
  ]
) # => false

Zur Information: Die Instanzen der Klasse `CodeLine` reagieren auf `to_s`, sodass die Übergabe eines `CodeLine`-Objekts oder eines Arrays als Objekt oder als Array in seine Code-Darstellung umgewandelt wird.

valid_without? (without_lines:, code_lines:)

Source

# File lib/syntax_suggest/api.rb, line 146
def self.valid_without?(without_lines:, code_lines:)
  lines = code_lines - Array(without_lines).flatten

  lines.empty? || valid?(lines)
end

SyntaxSuggest.valid_without? [Privat]

Dies gibt an, ob die `code_lines` gültig wären, wenn die `without_lines` entfernt würden. Kurz gesagt, es ist eine Möglichkeit zu erkennen, ob wir die Zeilen mit Syntaxfehlern in unserem Dokument bereits gefunden haben.

code_lines = [
  CodeLine.new(line: "def foo\n",   index: 0)
  CodeLine.new(line: "  def bar\n", index: 1)
  CodeLine.new(line: "end\n",       index: 2)
]

SyntaxSuggest.valid_without?(
  without_lines: code_lines[1],
  code_lines: code_lines
)                                    # => true

SyntaxSuggest.valid?(code_lines) # => false

Öffentliche Instanzmethoden

detailed_message (highlight: true, syntax_suggest: true, **kwargs)

Source

# File lib/syntax_suggest/core_ext.rb, line 11
def detailed_message(highlight: true, syntax_suggest: true, **kwargs)
  return super unless syntax_suggest

  require "syntax_suggest/api" unless defined?(SyntaxSuggest::DEFAULT_VALUE)

  message = super

  if path
    file = Pathname.new(path)
    io = SyntaxSuggest::MiniStringIO.new

    SyntaxSuggest.call(
      io: io,
      source: file.read,
      filename: file,
      terminal: highlight
    )
    annotation = io.string

    annotation += "\n" unless annotation.end_with?("\n")

    annotation + message
  else
    message
  end
rescue => e
  if ENV["SYNTAX_SUGGEST_DEBUG"]
    $stderr.warn(e.message)
    $stderr.warn(e.backtrace)
  end

  # Ignore internal errors
  message
end

Ruft die Methode der Superklasse auf