Class: RubyLsp::Listeners::FoldingRanges

Inherits:
Object
  • Object
show all
Includes:
Requests::Support::Common
Defined in:
lib/ruby_lsp/listeners/folding_ranges.rb

Instance Method Summary collapse

Methods included from Requests::Support::Common

#categorized_markdown_from_index_entries, #constant_name, #create_code_lens, #each_constant_path_part, #kind_for_entry, #markdown_from_index_entries, #namespace_constant_name, #not_in_dependencies?, #range_from_location, #range_from_node, #self_receiver?

Constructor Details

#initialize(response_builder, comments, dispatcher) ⇒ FoldingRanges

: (ResponseBuilders::CollectionResponseBuilder response_builder, Array comments, Prism::Dispatcher dispatcher) -> void



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 10

def initialize(response_builder, comments, dispatcher)
  @response_builder = response_builder
  @requires = [] #: Array[Prism::CallNode]
  @comments = comments

  dispatcher.register(
    self,
    :on_if_node_enter,
    :on_in_node_enter,
    :on_rescue_node_enter,
    :on_when_node_enter,
    :on_interpolated_string_node_enter,
    :on_array_node_enter,
    :on_block_node_enter,
    :on_case_node_enter,
    :on_case_match_node_enter,
    :on_class_node_enter,
    :on_module_node_enter,
    :on_for_node_enter,
    :on_hash_node_enter,
    :on_singleton_class_node_enter,
    :on_unless_node_enter,
    :on_until_node_enter,
    :on_while_node_enter,
    :on_else_node_enter,
    :on_ensure_node_enter,
    :on_begin_node_enter,
    :on_def_node_enter,
    :on_call_node_enter,
    :on_lambda_node_enter,
  )
end

Instance Method Details

#finalize_response! ⇒ Object

: -> void



44
45
46
47
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 44

def finalize_response!
  push_comment_ranges
  emit_requires_range
end

#on_array_node_enter(node) ⇒ Object

: (Prism::ArrayNode node) -> void



78
79
80
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 78

def on_array_node_enter(node)
  add_simple_range(node)
end

#on_begin_node_enter(node) ⇒ Object

: (Prism::BeginNode node) -> void



148
149
150
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 148

def on_begin_node_enter(node)
  add_simple_range(node)
end

#on_block_node_enter(node) ⇒ Object

: (Prism::BlockNode node) -> void



83
84
85
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 83

def on_block_node_enter(node)
  add_simple_range(node)
end

#on_call_node_enter(node) ⇒ Object

: (Prism::CallNode node) -> void



168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 168

def on_call_node_enter(node)
  # If we find a require, don't visit the child nodes (prevent `super`), so that we can keep accumulating into
  # the `@requires` array and then push the range whenever we find a node that isn't a CallNode
  if require?(node)
    @requires << node
    return
  end

  location = node.location
  add_lines_range(location.start_line, location.end_line - 1)
end

#on_case_match_node_enter(node) ⇒ Object

: (Prism::CaseMatchNode node) -> void



93
94
95
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 93

def on_case_match_node_enter(node)
  add_simple_range(node)
end

#on_case_node_enter(node) ⇒ Object

: (Prism::CaseNode node) -> void



88
89
90
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 88

def on_case_node_enter(node)
  add_simple_range(node)
end

#on_class_node_enter(node) ⇒ Object

: (Prism::ClassNode node) -> void



98
99
100
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 98

def on_class_node_enter(node)
  add_simple_range(node)
end

#on_def_node_enter(node) ⇒ Object

: (Prism::DefNode node) -> void



153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 153

def on_def_node_enter(node)
  params = node.parameters
  parameter_loc = params&.location
  location = node.location

  if params && parameter_loc.end_line > location.start_line
    # Multiline parameters
    add_lines_range(location.start_line, parameter_loc.end_line)
    add_lines_range(parameter_loc.end_line + 1, location.end_line - 1)
  else
    add_lines_range(location.start_line, location.end_line - 1)
  end
end

#on_else_node_enter(node) ⇒ Object

: (Prism::ElseNode node) -> void



138
139
140
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 138

def on_else_node_enter(node)
  add_simple_range(node)
end

#on_ensure_node_enter(node) ⇒ Object

: (Prism::EnsureNode node) -> void



143
144
145
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 143

def on_ensure_node_enter(node)
  add_simple_range(node)
end

#on_for_node_enter(node) ⇒ Object

: (Prism::ForNode node) -> void



108
109
110
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 108

def on_for_node_enter(node)
  add_simple_range(node)
end

#on_hash_node_enter(node) ⇒ Object

: (Prism::HashNode node) -> void



113
114
115
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 113

def on_hash_node_enter(node)
  add_simple_range(node)
end

#on_if_node_enter(node) ⇒ Object

: (Prism::IfNode node) -> void



50
51
52
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 50

def on_if_node_enter(node)
  add_statements_range(node)
end

#on_in_node_enter(node) ⇒ Object

: (Prism::InNode node) -> void



55
56
57
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 55

def on_in_node_enter(node)
  add_statements_range(node)
end

#on_interpolated_string_node_enter(node) ⇒ Object

: (Prism::InterpolatedStringNode node) -> void



70
71
72
73
74
75
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 70

def on_interpolated_string_node_enter(node)
  opening_loc = node.opening_loc || node.location
  closing_loc = node.closing_loc || node.parts.last&.location || node.location

  add_lines_range(opening_loc.start_line, closing_loc.start_line - 1)
end

#on_lambda_node_enter(node) ⇒ Object

: (Prism::LambdaNode node) -> void



181
182
183
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 181

def on_lambda_node_enter(node)
  add_simple_range(node)
end

#on_module_node_enter(node) ⇒ Object

: (Prism::ModuleNode node) -> void



103
104
105
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 103

def on_module_node_enter(node)
  add_simple_range(node)
end

#on_rescue_node_enter(node) ⇒ Object

: (Prism::RescueNode node) -> void



60
61
62
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 60

def on_rescue_node_enter(node)
  add_statements_range(node)
end

#on_singleton_class_node_enter(node) ⇒ Object

: (Prism::SingletonClassNode node) -> void



118
119
120
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 118

def on_singleton_class_node_enter(node)
  add_simple_range(node)
end

#on_unless_node_enter(node) ⇒ Object

: (Prism::UnlessNode node) -> void



123
124
125
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 123

def on_unless_node_enter(node)
  add_simple_range(node)
end

#on_until_node_enter(node) ⇒ Object

: (Prism::UntilNode node) -> void



128
129
130
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 128

def on_until_node_enter(node)
  add_simple_range(node)
end

#on_when_node_enter(node) ⇒ Object

: (Prism::WhenNode node) -> void



65
66
67
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 65

def on_when_node_enter(node)
  add_statements_range(node)
end

#on_while_node_enter(node) ⇒ Object

: (Prism::WhileNode node) -> void



133
134
135
 
# File 'lib/ruby_lsp/listeners/folding_ranges.rb', line 133

def on_while_node_enter(node)
  add_simple_range(node)
end