#$@%#$%!

Ngiler SH3LL 360
: / opt / alt / ruby34 / share / ruby / syntax_suggest /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : block_expand.rb \| Size : 4.88 KB
# frozen_string_literal: true module SyntaxSuggest # This class is responsible for taking a code block that exists # at a far indentaion and then iteratively increasing the block # so that it captures everything within the same indentation block. # # def dog # puts "bow" # puts "wow" # end # # block = BlockExpand.new(code_lines: code_lines) # .call(CodeBlock.new(lines: code_lines[1])) # # puts block.to_s # # => puts "bow" # puts "wow" # # # Once a code block has captured everything at a given indentation level # then it will expand to capture surrounding indentation. # # block = BlockExpand.new(code_lines: code_lines) # .call(block) # # block.to_s # # => def dog # puts "bow" # puts "wow" # end # class BlockExpand def initialize(code_lines:) @code_lines = code_lines end # Main interface. Expand current indentation, before # expanding to a lower indentation def call(block) if (next_block = expand_neighbors(block)) next_block else expand_indent(block) end end # Expands code to the next lowest indentation # # For example: # # 1 def dog # 2 print "dog" # 3 end # # If a block starts on line 2 then it has captured all it's "neighbors" (code at # the same indentation or higher). To continue expanding, this block must capture # lines one and three which are at a different indentation level. # # This method allows fully expanded blocks to decrease their indentation level (so # they can expand to capture more code up and down). It does this conservatively # as there's no undo (currently). def expand_indent(block) now = AroundBlockScan.new(code_lines: @code_lines, block: block) .force_add_hidden .stop_after_kw .scan_adjacent_indent now.lookahead_balance_one_line now.code_block end # A neighbor is code that is at or above the current indent line. # # First we build a block with all neighbors. If we can't go further # then we decrease the indentation threshold and expand via indentation # i.e. `expand_indent` # # Handles two general cases. # # ## Case #1: Check code inside of methods/classes/etc. # # It's important to note, that not everything in a given indentation level can be parsed # as valid code even if it's part of valid code. For example: # # 1 hash = { # 2 name: "richard", # 3 dog: "cinco", # 4 } # # In this case lines 2 and 3 will be neighbors, but they're invalid until `expand_indent` # is called on them. # # When we are adding code within a method or class (at the same indentation level), # use the empty lines to denote the programmer intended logical chunks. # Stop and check each one. For example: # # 1 def dog # 2 print "dog" # 3 # 4 hash = { # 5 end # # If we did not stop parsing at empty newlines then the block might mistakenly grab all # the contents (lines 2, 3, and 4) and report them as being problems, instead of only # line 4. # # ## Case #2: Expand/grab other logical blocks # # Once the search algorithm has converted all lines into blocks at a given indentation # it will then `expand_indent`. Once the blocks that generates are expanded as neighbors # we then begin seeing neighbors being other logical blocks i.e. a block's neighbors # may be another method or class (something with keywords/ends). # # For example: # # 1 def bark # 2 # 3 end # 4 # 5 def sit # 6 end # # In this case if lines 4, 5, and 6 are in a block when it tries to expand neighbors # it will expand up. If it stops after line 2 or 3 it may cause problems since there's a # valid kw/end pair, but the block will be checked without it. # # We try to resolve this edge case with `lookahead_balance_one_line` below. def expand_neighbors(block) now = AroundBlockScan.new(code_lines: @code_lines, block: block) # Initial scan now .force_add_hidden .stop_after_kw .scan_neighbors_not_empty # Slurp up empties now .scan_while { \|line\| line.empty? } # If next line is kw and it will balance us, take it expanded_lines = now .lookahead_balance_one_line .lines # Don't allocate a block if it won't be used # # If nothing was taken, return nil to indicate that status # used in `def call` to determine if # we need to expand up/out (`expand_indent`) if block.lines == expanded_lines nil else CodeBlock.new(lines: expanded_lines) end end # Manageable rspec errors def inspect "#<SyntaxSuggest::CodeBlock:0x0000123843lol >" end end end Back

Edit File : block_expand.rb | Size : 4.88 KB

# frozen_string_literal: true

module SyntaxSuggest
  # This class is responsible for taking a code block that exists
  # at a far indentaion and then iteratively increasing the block
  # so that it captures everything within the same indentation block.
  #
  #   def dog
  #     puts "bow"
  #     puts "wow"
  #   end
  #
  # block = BlockExpand.new(code_lines: code_lines)
  #   .call(CodeBlock.new(lines: code_lines[1]))
  #
  # puts block.to_s
  # # => puts "bow"
  #      puts "wow"
  #
  #
  # Once a code block has captured everything at a given indentation level
  # then it will expand to capture surrounding indentation.
  #
  # block = BlockExpand.new(code_lines: code_lines)
  #   .call(block)
  #
  # block.to_s
  # # => def dog
  #        puts "bow"
  #        puts "wow"
  #      end
  #
  class BlockExpand
    def initialize(code_lines:)
      @code_lines = code_lines
    end

# Main interface. Expand current indentation, before
    # expanding to a lower indentation
    def call(block)
      if (next_block = expand_neighbors(block))
        next_block
      else
        expand_indent(block)
      end
    end

# Expands code to the next lowest indentation
    #
    # For example:
    #
    #   1 def dog
    #   2   print "dog"
    #   3 end
    #
    # If a block starts on line 2 then it has captured all it's "neighbors" (code at
    # the same indentation or higher). To continue expanding, this block must capture
    # lines one and three which are at a different indentation level.
    #
    # This method allows fully expanded blocks to decrease their indentation level (so
    # they can expand to capture more code up and down). It does this conservatively
    # as there's no undo (currently).
    def expand_indent(block)
      now = AroundBlockScan.new(code_lines: @code_lines, block: block)
        .force_add_hidden
        .stop_after_kw
        .scan_adjacent_indent

now.lookahead_balance_one_line

now.code_block
    end

# A neighbor is code that is at or above the current indent line.
    #
    # First we build a block with all neighbors. If we can't go further
    # then we decrease the indentation threshold and expand via indentation
    # i.e. `expand_indent`
    #
    # Handles two general cases.
    #
    # ## Case #1: Check code inside of methods/classes/etc.
    #
    # It's important to note, that not everything in a given indentation level can be parsed
    # as valid code even if it's part of valid code. For example:
    #
    #   1 hash = {
    #   2   name: "richard",
    #   3   dog: "cinco",
    #   4 }
    #
    # In this case lines 2 and 3 will be neighbors, but they're invalid until `expand_indent`
    # is called on them.
    #
    # When we are adding code within a method or class (at the same indentation level),
    # use the empty lines to denote the programmer intended logical chunks.
    # Stop and check each one. For example:
    #
    #   1 def dog
    #   2   print "dog"
    #   3
    #   4   hash = {
    #   5 end
    #
    # If we did not stop parsing at empty newlines then the block might mistakenly grab all
    # the contents (lines 2, 3, and 4) and report them as being problems, instead of only
    # line 4.
    #
    # ## Case #2: Expand/grab other logical blocks
    #
    # Once the search algorithm has converted all lines into blocks at a given indentation
    # it will then `expand_indent`. Once the blocks that generates are expanded as neighbors
    # we then begin seeing neighbors being other logical blocks i.e. a block's neighbors
    # may be another method or class (something with keywords/ends).
    #
    # For example:
    #
    #   1 def bark
    #   2
    #   3 end
    #   4
    #   5 def sit
    #   6 end
    #
    # In this case if lines 4, 5, and 6 are in a block when it tries to expand neighbors
    # it will expand up. If it stops after line 2 or 3 it may cause problems since there's a
    # valid kw/end pair, but the block will be checked without it.
    #
    # We try to resolve this edge case with `lookahead_balance_one_line` below.
    def expand_neighbors(block)
      now = AroundBlockScan.new(code_lines: @code_lines, block: block)

# Initial scan
      now
        .force_add_hidden
        .stop_after_kw
        .scan_neighbors_not_empty

# Slurp up empties
      now
        .scan_while { |line| line.empty? }

# If next line is kw and it will balance us, take it
      expanded_lines = now
        .lookahead_balance_one_line
        .lines

# Don't allocate a block if it won't be used
      #
      # If nothing was taken, return nil to indicate that status
      # used in `def call` to determine if
      # we need to expand up/out (`expand_indent`)
      if block.lines == expanded_lines
        nil
      else
        CodeBlock.new(lines: expanded_lines)
      end
    end

# Manageable rspec errors
    def inspect
      "#<SyntaxSuggest::CodeBlock:0x0000123843lol >"
    end
  end
end

Back