Class: DeadEnd::CaptureCodeContext

Inherits:
Object
  • Object
show all
Defined in:
lib/dead_end/capture_code_context.rb

Overview

Turns a “invalid block(s)” into useful context

There are three main phases in the algorithm:

  1. Sanitize/format input source

  2. Search for invalid blocks

  3. Format invalid blocks into something meaninful

This class handles the third part.

The algorithm is very good at capturing all of a syntax error in a single block in number 2, however the results can contain ambiguities. Humans are good at pattern matching and filtering and can mentally remove extraneous data, but they can’t add extra data that’s not present.

In the case of known ambiguious cases, this class adds context back to the ambiguitiy so the programmer has full information.

Beyond handling these ambiguities, it also captures surrounding code context information:

puts block.to_s # => "def bark"

context = CaptureCodeContext.new(
  blocks: block,
  code_lines: code_lines
)

lines = context.call.map(&:original)
puts lines.join
# =>
  class Dog
    def bark
  end

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(blocks:, code_lines:) ⇒ CaptureCodeContext

Returns a new instance of CaptureCodeContext.



43
44
45
46
47
48
 
# File 'lib/dead_end/capture_code_context.rb', line 43

def initialize(blocks:, code_lines:)
  @blocks = Array(blocks)
  @code_lines = code_lines
  @visible_lines = @blocks.map(&:visible_lines).flatten
  @lines_to_output = @visible_lines.dup
end

Instance Attribute Details

#code_lines ⇒ Object (readonly)

Returns the value of attribute code_lines.



41
42
43
 
# File 'lib/dead_end/capture_code_context.rb', line 41

def code_lines
  @code_lines
end

Instance Method Details

#call ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/dead_end/capture_code_context.rb', line 50

def call
  @blocks.each do |block|
    capture_first_kw_end_same_indent(block)
    capture_last_end_same_indent(block)
    capture_before_after_kws(block)
    capture_falling_indent(block)
  end

  @lines_to_output.select!(&:not_empty?)
  @lines_to_output.uniq!
  @lines_to_output.sort!

  @lines_to_output
end

#capture_before_after_kws(block) ⇒ Object

Shows surrounding kw/end pairs

The purpose of showing these extra pairs is due to cases of ambiguity when only one visible line is matched.

For example:

1  class Dog
2    def bark
4    def eat
5    end
6  end

In this case either line 2 could be missing an ‘end` or line 4 was an extra line added by mistake (it happens).

When we detect the above problem it shows the issue as only being on line 2

2    def bark

Showing “neighbor” keyword pairs gives extra context:

2    def bark
4    def eat
5    end



116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/dead_end/capture_code_context.rb', line 116

def capture_before_after_kws(block)
  return unless block.visible_lines.count == 1

  around_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
    .start_at_next_line
    .capture_neighbor_context

  around_lines -= block.lines

  @lines_to_output.concat(around_lines)
end

#capture_falling_indent(block) ⇒ Object

Shows the context around code provided by “falling” indentation

Converts:

it "foo" do

into:

class OH
  def hello
    it "foo" do
  end
end



80
81
82
83
84
85
86
87
 
# File 'lib/dead_end/capture_code_context.rb', line 80

def capture_falling_indent(block)
  AroundBlockScan.new(
    block: block,
    code_lines: @code_lines
  ).on_falling_indent do |line|
    @lines_to_output << line
  end
end

#capture_first_kw_end_same_indent(block) ⇒ Object

The logical inverse of ‘capture_last_end_same_indent`

When there is an invalid block with an ‘end` missing a keyword right after another `end`, it is unclear where which end is missing the keyword.

Take this example:

class Dog       # 1
    puts "woof" # 2
  end           # 3
end             # 4

the problem line will be identified as:

❯ end            # 4

This happens because lines 1, 2, and 3 are technically valid code and are expanded first, deemed valid, and hidden. We need to un-hide the matching keyword on line 1. Also work backwards and if there’s a mis-matched end, show it too



209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/dead_end/capture_code_context.rb', line 209

def capture_first_kw_end_same_indent(block)
  return if block.visible_lines.length != 1
  return unless block.visible_lines.first.is_end?

  visible_line = block.visible_lines.first
  lines = @code_lines[block.lines.first.index..visible_line.index]
  matching_kw = lines.reverse.detect { |line| line.indent == block.current_indent && line.is_kw? }
  return unless matching_kw

  @lines_to_output << matching_kw

  kw_count = 0
  end_count = 0
  orphan_end = @code_lines[matching_kw.index..visible_line.index].detect do |line|
    kw_count += 1 if line.is_kw?
    end_count += 1 if line.is_end?

    end_count >= kw_count
  end

  return unless orphan_end
  @lines_to_output << orphan_end
end

#capture_last_end_same_indent(block) ⇒ Object

When there is an invalid block with a keyword missing an end right before another end, it is unclear where which keyword is missing the end

Take this example:

class Dog       # 1
  def bark      # 2
    puts "woof" # 3
end             # 4

However due to github.com/zombocom/dead_end/issues/32 the problem line will be identified as:

❯ class Dog       # 1

Because lines 2, 3, and 4 are technically valid code and are expanded first, deemed valid, and hidden. We need to un-hide the matching end line 4. Also work backwards and if there’s a mis-matched keyword, show it too



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/dead_end/capture_code_context.rb', line 149

def capture_last_end_same_indent(block)
  return if block.visible_lines.length != 1
  return unless block.visible_lines.first.is_kw?

  visible_line = block.visible_lines.first
  lines = @code_lines[visible_line.index..block.lines.last.index]

  # Find first end with same indent
  # (this would return line 4)
  #
  #   end             # 4
  matching_end = lines.detect { |line| line.indent == block.current_indent && line.is_end? }
  return unless matching_end

  @lines_to_output << matching_end

  # Work backwards from the end to
  # see if there are mis-matched
  # keyword/end pairs
  #
  # Return the first mis-matched keyword
  # this would find line 2
  #
  #     def bark      # 2
  #       puts "woof" # 3
  #   end             # 4
  end_count = 0
  kw_count = 0
  kw_line = @code_lines[visible_line.index..matching_end.index].reverse.detect do |line|
    end_count += 1 if line.is_end?
    kw_count += 1 if line.is_kw?

    !kw_count.zero? && kw_count >= end_count
  end
  return unless kw_line
  @lines_to_output << kw_line
end