ULTRA [ growontech.com ]

Linux premium216.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64

LiteSpeed

66.29.141.148 | Your IP: 3.135.190.244

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / alt / ruby33 / share / ruby / syntax_suggest /

Home Upload Mass Deface Mass Delete Back Connect Notify

capture_code_context.rb

# frozen_string_literal: true

module SyntaxSuggest
  module Capture
  end
end

require_relative "capture/falling_indent_lines"
require_relative "capture/before_after_keyword_ends"

module SyntaxSuggest
  # 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
  #
  class CaptureCodeContext
    attr_reader :code_lines

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

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

sorted_lines
    end

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

@lines_to_output
    end

# Shows the context around code provided by "falling" indentation
    #
    # Converts:
    #
    #       it "foo" do
    #
    # into:
    #
    #   class OH
    #     def hello
    #       it "foo" do
    #     end
    #   end
    #
    def capture_falling_indent(block)
      Capture::FallingIndentLines.new(
        block: block,
        code_lines: @code_lines
      ).call do |line|
        @lines_to_output << line
      end
    end

# 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
    #
    def capture_before_after_kws(block)
      return unless block.visible_lines.count == 1

around_lines = Capture::BeforeAfterKeywordEnds.new(
        code_lines: @code_lines,
        block: block
      ).call

around_lines -= block.lines

@lines_to_output.concat(around_lines)
    end

# 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 https://github.com/ruby/syntax_suggest/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
    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

# 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
    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
  end
end

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	drwxr-xr-x	2024-08-07 05:03:21
..	dir	-	root/linksafe	drwxr-xr-x	2024-08-07 05:03:28
capture	dir	-	root/linksafe	drwxr-xr-x	2024-08-07 05:03:21
api.rb	text/x-ruby	6.07 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
around_block_scan.rb	text/x-ruby	6.9 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
block_expand.rb	text/x-ruby	4.87 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
capture_code_context.rb	text/x-ruby	6.67 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
clean_document.rb	text/x-ruby	8.73 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
cli.rb	text/x-ruby	3.12 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
code_block.rb	text/x-ruby	2.13 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
code_frontier.rb	text/x-ruby	5.61 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
code_line.rb	text/x-ruby	6.62 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
code_search.rb	text/x-ruby	3.81 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
core_ext.rb	text/x-ruby	3.02 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
display_code_with_line_numbers.rb	text/x-ruby	1.77 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
display_invalid_blocks.rb	text/x-ruby	1.75 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
explain_syntax.rb	text/x-ruby	2.69 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
left_right_lex_count.rb	text/x-ruby	4.06 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
lex_all.rb	text/x-ruby	1.66 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
lex_value.rb	text/x-ruby	1.5 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
parse_blocks_from_indent_line.rb	text/x-ruby	1.5 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
pathname_from_message.rb	text/x-ruby	1.42 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
priority_engulf_queue.rb	text/x-ruby	1.26 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
priority_queue.rb	text/x-ruby	2 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
ripper_errors.rb	text/x-ruby	960 B	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
scan_history.rb	text/x-ruby	2.92 KB	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
unvisited_lines.rb	text/x-ruby	705 B	root/linksafe	-rw-r--r--	2024-07-23 12:52:46
version.rb	text/x-ruby	76 B	root/linksafe	-rw-r--r--	2024-07-23 12:52:46