Class: PlatformosCheck::LanguageServer::DiagnosticsManager

Inherits:
Object
  • Object
show all
Defined in:
lib/platformos_check/language_server/diagnostics_manager.rb

Constant Summary collapse

NO_DIAGNOSTICS =

The empty array is used in the protocol to mean that no diagnostics exist for this file. It’s not always evident when reading code.

[].freeze

Instance Method Summary collapse

Constructor Details

#initialize ⇒ DiagnosticsManager

This class exists to facilitate LanguageServer diagnostics tracking.

Motivations:

1. The first time we lint, we want all the errors from all the files.
2. If we fix all the errors in a file, we have to send an empty array for that file.
3. If we do a partial check, we should consider the whole platformos_app diagnostics as valid, and return cached results
4. We should be able to create WorkspaceEdits from diagnostics, so that the ExecuteCommandEngine can do its job
5. We should clean up diagnostics that were applied by the client



21
22
23
24
25
 
# File 'lib/platformos_check/language_server/diagnostics_manager.rb', line 21

def initialize
  @latest_diagnostics = {} # { [Pathname(relative_path)] => Diagnostic[] }
  @mutex = Mutex.new
  @first_run = true
end

Instance Method Details

#build_diagnostics(offenses, analyzed_files: nil, only_single_file: false) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/platformos_check/language_server/diagnostics_manager.rb', line 36

def build_diagnostics(offenses, analyzed_files: nil, only_single_file: false)
  @mutex.synchronize do
    full_check = analyzed_files.nil?
    analyzed_paths = analyzed_files.map { |path| Pathname.new(path) } unless full_check

    # When analyzed_files is nil, contains all offenses.
    # When analyzed_files is !nil, contains all whole platformos_app offenses and single file offenses of the analyzed_files.
    current_diagnostics = offenses
                          .select(&:app_file)
                          .group_by(&:app_file)
                          .transform_keys { |app_file| Pathname.new(app_file.relative_path) }
                          .transform_values do |app_file_offenses|
      app_file_offenses.map { |o| Diagnostic.new(o) }
    end

    previous_paths = paths(@latest_diagnostics)
    current_paths = paths(current_diagnostics)

    diagnostics_update = (current_paths + previous_paths).map do |path|
      # When doing single file checks, we keep the whole platformos_app old
      # ones and accept the new single ones
      if only_single_file && analyzed_paths.include?(path)
        single_file_diagnostics = current_diagnostics[path] || NO_DIAGNOSTICS
        whole_platformos_app_diagnostics = whole_platformos_app_diagnostics(path) || NO_DIAGNOSTICS
        [path, single_file_diagnostics + whole_platformos_app_diagnostics]

      # If doing single file checks that are not in the
      # analyzed_paths array then we just keep the old
      # diagnostics
      elsif only_single_file
        [path, previous_diagnostics(path) || NO_DIAGNOSTICS]

      # When doing a full_check, we either send the current
      # diagnostics or an empty array to clear the diagnostics
      # for that file.
      elsif full_check
        [path, current_diagnostics[path] || NO_DIAGNOSTICS]

      # When doing a partial check, the single file diagnostics
      # from the previous runs should be sent. Otherwise the
      # latest results are the good ones.
      else
        new_diagnostics = current_diagnostics[path] || NO_DIAGNOSTICS
        should_use_cached_results = !analyzed_paths.include?(path)
        old_diagnostics = should_use_cached_results ? single_file_diagnostics(path) : []
        [path, new_diagnostics + old_diagnostics]
      end
    end.to_h

    @latest_diagnostics = diagnostics_update
                          .reject { |_, v| v.empty? }

    @first_run = false

    # Only send updates for the current file when running with only_single_file
    diagnostics_update
      .reject { |p, _| only_single_file && !analyzed_paths.include?(p) }
  end
end

#clear_diagnostics(relative_path) ⇒ Object

For when you know there shouldn’t be anything on that file anymore. (e.g. file delete or file rename)



124
125
126
127
 
# File 'lib/platformos_check/language_server/diagnostics_manager.rb', line 124

def clear_diagnostics(relative_path)
  relative_path = sanitize_path(relative_path)
  @latest_diagnostics.delete(relative_path)
end

#delete_applied(diagnostics) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/platformos_check/language_server/diagnostics_manager.rb', line 105

def delete_applied(diagnostics)
  diagnostics = sanitize(diagnostics)
                .select(&:correctable?)

  previous_paths = paths(@latest_diagnostics)

  diagnostics.each do |diagnostic|
    delete(diagnostic.relative_path, diagnostic)
  end

  current_paths = paths(@latest_diagnostics)

  (current_paths + previous_paths).map do |path|
    [path, @latest_diagnostics[path] || []]
  end.to_h
end

#diagnostics(relative_path) ⇒ Object 



31
32
33
34
 
# File 'lib/platformos_check/language_server/diagnostics_manager.rb', line 31

def diagnostics(relative_path)
  relative_path = Pathname.new(relative_path) if relative_path.is_a?(String)
  @mutex.synchronize { @latest_diagnostics[relative_path] || [] }
end

#first_run? ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/platformos_check/language_server/diagnostics_manager.rb', line 27

def first_run?
  @first_run
end

#workspace_edit(diagnostics) ⇒ Object 



96
97
98
99
100
101
102
103
 
# File 'lib/platformos_check/language_server/diagnostics_manager.rb', line 96

def workspace_edit(diagnostics)
  diagnostics = sanitize(diagnostics)
                .select(&:correctable?)

  {
    documentChanges: document_changes(diagnostics)
  }
end