@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/syntax_suggest/api.rb

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "version"
-
-require "tmpdir"
-require "stringio"
-require "pathname"
-require "timeout"
-
-# We need Ripper loaded for `Prism.lex_compat` even if we're using Prism
-# for lexing and parsing
-require "ripper"
-
-# Prism is the new parser, replacing Ripper
-#
-# We need to "dual boot" both for now because syntax_suggest
-# supports older rubies that do not ship with syntax suggest.
-#
-# We also need the ability to control loading of this library
-# so we can test that both modes work correctly in CI.
-if (value = ENV["SYNTAX_SUGGEST_DISABLE_PRISM"])
-  warn "Skipping loading prism due to SYNTAX_SUGGEST_DISABLE_PRISM=#{value}"
-else
-  begin
-    require "prism"
-  rescue LoadError
-  end
-end
-
-module SyntaxSuggest
-  # Used to indicate a default value that cannot
-  # be confused with another input.
-  DEFAULT_VALUE = Object.new.freeze
-
-  class Error < StandardError; end
-  TIMEOUT_DEFAULT = ENV.fetch("SYNTAX_SUGGEST_TIMEOUT", 1).to_i
-
-  # SyntaxSuggest.use_prism_parser? [Private]
-  #
-  # Tells us if the prism parser is available for use
-  # or if we should fallback to `Ripper`
-  def self.use_prism_parser?
-    defined?(Prism)
-  end
-
-  # SyntaxSuggest.handle_error [Public]
-  #
-  # Takes a `SyntaxError` exception, uses the
-  # error message to locate the file. Then the file
-  # will be analyzed to find the location of the syntax
-  # error and emit that location to stderr.
-  #
-  # Example:
-  #
-  #   begin
-  #     require 'bad_file'
-  #   rescue => e
-  #     SyntaxSuggest.handle_error(e)
-  #   end
-  #
-  # By default it will re-raise the exception unless
-  # `re_raise: false`. The message output location
-  # can be configured using the `io: $stderr` input.
-  #
-  # If a valid filename cannot be determined, the original
-  # exception will be re-raised (even with
-  # `re_raise: false`).
-  def self.handle_error(e, re_raise: true, io: $stderr)
-    unless e.is_a?(SyntaxError)
-      io.puts("SyntaxSuggest: Must pass a SyntaxError, got: #{e.class}")
-      raise e
-    end
-
-    file = PathnameFromMessage.new(e.message, io: io).call.name
-    raise e unless file
-
-    io.sync = true
-
-    call(
-      io: io,
-      source: file.read,
-      filename: file
-    )
-
-    raise e if re_raise
-  end
-
-  # SyntaxSuggest.call [Private]
-  #
-  # Main private interface
-  def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: DEFAULT_VALUE, timeout: TIMEOUT_DEFAULT, io: $stderr)
-    search = nil
-    filename = nil if filename == DEFAULT_VALUE
-    Timeout.timeout(timeout) do
-      record_dir ||= ENV["DEBUG"] ? "tmp" : nil
-      search = CodeSearch.new(source, record_dir: record_dir).call
-    end
-
-    blocks = search.invalid_blocks
-    DisplayInvalidBlocks.new(
-      io: io,
-      blocks: blocks,
-      filename: filename,
-      terminal: terminal,
-      code_lines: search.code_lines
-    ).call
-  rescue Timeout::Error => e
-    io.puts "Search timed out SYNTAX_SUGGEST_TIMEOUT=#{timeout}, run with SYNTAX_SUGGEST_DEBUG=1 for more info"
-    io.puts e.backtrace.first(3).join($/)
-  end
-
-  # SyntaxSuggest.record_dir [Private]
-  #
-  # Used to generate a unique directory to record
-  # search steps for debugging
-  def self.record_dir(dir)
-    time = Time.now.strftime("%Y-%m-%d-%H-%M-%s-%N")
-    dir = Pathname(dir)
-    dir.join(time).tap { |path|
-      path.mkpath
-      alias_dir = dir.join("last")
-      FileUtils.rm_rf(alias_dir) if alias_dir.exist?
-      FileUtils.ln_sf(time, alias_dir)
-    }
-  end
-
-  # SyntaxSuggest.valid_without? [Private]
-  #
-  # This will tell you if the `code_lines` would be valid
-  # if you removed the `without_lines`. In short it's a
-  # way to detect if we've found the lines with syntax errors
-  # in our document yet.
-  #
-  #   code_lines = [
-  #     CodeLine.new(line: "def foo\n",   index: 0)
-  #     CodeLine.new(line: "  def bar\n", index: 1)
-  #     CodeLine.new(line: "end\n",       index: 2)
-  #   ]
-  #
-  #   SyntaxSuggest.valid_without?(
-  #     without_lines: code_lines[1],
-  #     code_lines: code_lines
-  #   )                                    # => true
-  #
-  #   SyntaxSuggest.valid?(code_lines) # => false
-  def self.valid_without?(without_lines:, code_lines:)
-    lines = code_lines - Array(without_lines).flatten
-
-    lines.empty? || valid?(lines)
-  end
-
-  # SyntaxSuggest.invalid? [Private]
-  #
-  # Opposite of `SyntaxSuggest.valid?`
-  if defined?(Prism)
-    def self.invalid?(source)
-      source = source.join if source.is_a?(Array)
-      source = source.to_s
-
-      Prism.parse(source).failure?
-    end
-  else
-    def self.invalid?(source)
-      source = source.join if source.is_a?(Array)
-      source = source.to_s
-
-      Ripper.new(source).tap(&:parse).error?
-    end
-  end
-
-  # SyntaxSuggest.valid? [Private]
-  #
-  # Returns truthy if a given input source is valid syntax
-  #
-  #   SyntaxSuggest.valid?(<<~EOM) # => true
-  #     def foo
-  #     end
-  #   EOM
-  #
-  #   SyntaxSuggest.valid?(<<~EOM) # => false
-  #     def foo
-  #       def bar # Syntax error here
-  #     end
-  #   EOM
-  #
-  # You can also pass in an array of lines and they'll be
-  # joined before evaluating
-  #
-  #   SyntaxSuggest.valid?(
-  #     [
-  #       "def foo\n",
-  #       "end\n"
-  #     ]
-  #   ) # => true
-  #
-  #   SyntaxSuggest.valid?(
-  #     [
-  #       "def foo\n",
-  #       "  def bar\n", # Syntax error here
-  #       "end\n"
-  #     ]
-  #   ) # => false
-  #
-  # As an FYI the CodeLine class instances respond to `to_s`
-  # so passing a CodeLine in as an object or as an array
-  # will convert it to it's code representation.
-  def self.valid?(source)
-    !invalid?(source)
-  end
-end
-
-# Integration
-require_relative "cli"
-
-# Core logic
-require_relative "code_search"
-require_relative "code_frontier"
-require_relative "explain_syntax"
-require_relative "clean_document"
-
-# Helpers
-require_relative "lex_all"
-require_relative "code_line"
-require_relative "code_block"
-require_relative "block_expand"
-require_relative "mini_stringio"
-require_relative "priority_queue"
-require_relative "unvisited_lines"
-require_relative "around_block_scan"
-require_relative "priority_engulf_queue"
-require_relative "pathname_from_message"
-require_relative "display_invalid_blocks"
-require_relative "parse_blocks_from_indent_line"

package/lib/ruby/3.4.11/syntax_suggest/around_block_scan.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "scan_history"
-
-module SyntaxSuggest
-  # This class is useful for exploring contents before and after
-  # a block
-  #
-  # It searches above and below the passed in block to match for
-  # whatever criteria you give it:
-  #
-  # Example:
-  #
-  #   def dog         # 1
-  #     puts "bark"   # 2
-  #     puts "bark"   # 3
-  #   end             # 4
-  #
-  #   scan = AroundBlockScan.new(
-  #     code_lines: code_lines
-  #     block: CodeBlock.new(lines: code_lines[1])
-  #   )
-  #
-  #   scan.scan_while { true }
-  #
-  #   puts scan.before_index # => 0
-  #   puts scan.after_index  # => 3
-  #
-  class AroundBlockScan
-    def initialize(code_lines:, block:)
-      @code_lines = code_lines
-      @orig_indent = block.current_indent
-
-      @stop_after_kw = false
-      @force_add_empty = false
-      @force_add_hidden = false
-      @target_indent = nil
-
-      @scanner = ScanHistory.new(code_lines: code_lines, block: block)
-    end
-
-    # When using this flag, `scan_while` will
-    # bypass the block it's given and always add a
-    # line that responds truthy to `CodeLine#hidden?`
-    #
-    # Lines are hidden when they've been evaluated by
-    # the parser as part of a block and found to contain
-    # valid code.
-    def force_add_hidden
-      @force_add_hidden = true
-      self
-    end
-
-    # When using this flag, `scan_while` will
-    # bypass the block it's given and always add a
-    # line that responds truthy to `CodeLine#empty?`
-    #
-    # Empty lines contain no code, only whitespace such
-    # as leading spaces a newline.
-    def force_add_empty
-      @force_add_empty = true
-      self
-    end
-
-    # Tells `scan_while` to look for mismatched keyword/end-s
-    #
-    # When scanning up, if we see more keywords then end-s it will
-    # stop. This might happen when scanning outside of a method body.
-    # the first scan line up would be a keyword and this setting would
-    # trigger a stop.
-    #
-    # When scanning down, stop if there are more end-s than keywords.
-    def stop_after_kw
-      @stop_after_kw = true
-      self
-    end
-
-    # Main work method
-    #
-    # The scan_while method takes a block that yields lines above and
-    # below the block. If the yield returns true, the @before_index
-    # or @after_index are modified to include the matched line.
-    #
-    # In addition to yielding individual lines, the internals of this
-    # object give a mini DSL to handle common situations such as
-    # stopping if we've found a keyword/end mis-match in one direction
-    # or the other.
-    def scan_while
-      stop_next_up = false
-      stop_next_down = false
-
-      @scanner.scan(
-        up: ->(line, kw_count, end_count) {
-          next false if stop_next_up
-          next true if @force_add_hidden && line.hidden?
-          next true if @force_add_empty && line.empty?
-
-          if @stop_after_kw && kw_count > end_count
-            stop_next_up = true
-          end
-
-          yield line
-        },
-        down: ->(line, kw_count, end_count) {
-          next false if stop_next_down
-          next true if @force_add_hidden && line.hidden?
-          next true if @force_add_empty && line.empty?
-
-          if @stop_after_kw && end_count > kw_count
-            stop_next_down = true
-          end
-
-          yield line
-        }
-      )
-
-      self
-    end
-
-    # Scanning is intentionally conservative because
-    # we have no way of rolling back an aggressive block (at this time)
-    #
-    # If a block was stopped for some trivial reason, (like an empty line)
-    # but the next line would have caused it to be balanced then we
-    # can check that condition and grab just one more line either up or
-    # down.
-    #
-    # For example, below if we're scanning up, line 2 might cause
-    # the scanning to stop. This is because empty lines might
-    # denote logical breaks where the user intended to chunk code
-    # which is a good place to stop and check validity. Unfortunately
-    # it also means we might have a "dangling" keyword or end.
-    #
-    #   1 def bark
-    #   2
-    #   3 end
-    #
-    # If lines 2 and 3 are in the block, then when this method is
-    # run it would see it is unbalanced, but that acquiring line 1
-    # would make it balanced, so that's what it does.
-    def lookahead_balance_one_line
-      kw_count = 0
-      end_count = 0
-      lines.each do |line|
-        kw_count += 1 if line.is_kw?
-        end_count += 1 if line.is_end?
-      end
-
-      return self if kw_count == end_count # nothing to balance
-
-      @scanner.commit_if_changed # Rollback point if we don't find anything to optimize
-
-      # Try to eat up empty lines
-      @scanner.scan(
-        up: ->(line, _, _) { line.hidden? || line.empty? },
-        down: ->(line, _, _) { line.hidden? || line.empty? }
-      )
-
-      # More ends than keywords, check if we can balance expanding up
-      next_up = @scanner.next_up
-      next_down = @scanner.next_down
-      case end_count - kw_count
-      when 1
-        if next_up&.is_kw? && next_up.indent >= @target_indent
-          @scanner.scan(
-            up: ->(line, _, _) { line == next_up },
-            down: ->(line, _, _) { false }
-          )
-          @scanner.commit_if_changed
-        end
-      when -1
-        if next_down&.is_end? && next_down.indent >= @target_indent
-          @scanner.scan(
-            up: ->(line, _, _) { false },
-            down: ->(line, _, _) { line == next_down }
-          )
-          @scanner.commit_if_changed
-        end
-      end
-      # Rollback any uncommitted changes
-      @scanner.stash_changes
-
-      self
-    end
-
-    # Finds code lines at the same or greater indentation and adds them
-    # to the block
-    def scan_neighbors_not_empty
-      @target_indent = @orig_indent
-      scan_while { |line| line.not_empty? && line.indent >= @target_indent }
-    end
-
-    # Scan blocks based on indentation of next line above/below block
-    #
-    # Determines indentaion of the next line above/below the current block.
-    #
-    # Normally this is called when a block has expanded to capture all "neighbors"
-    # at the same (or greater) indentation and needs to expand out. For example
-    # the `def/end` lines surrounding a method.
-    def scan_adjacent_indent
-      before_after_indent = []
-
-      before_after_indent << (@scanner.next_up&.indent || 0)
-      before_after_indent << (@scanner.next_down&.indent || 0)
-
-      @target_indent = before_after_indent.min
-      scan_while { |line| line.not_empty? && line.indent >= @target_indent }
-
-      self
-    end
-
-    # Return the currently matched lines as a `CodeBlock`
-    #
-    # When a `CodeBlock` is created it will gather metadata about
-    # itself, so this is not a free conversion. Avoid allocating
-    # more CodeBlock's than needed
-    def code_block
-      CodeBlock.new(lines: lines)
-    end
-
-    # Returns the lines matched by the current scan as an
-    # array of CodeLines
-    def lines
-      @scanner.lines
-    end
-
-    # Manageable rspec errors
-    def inspect
-      "#<#{self.class}:0x0000123843lol >"
-    end
-  end
-end

package/lib/ruby/3.4.11/syntax_suggest/block_expand.rb

@@ -1,165 +0,0 @@
-# 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

package/lib/ruby/3.4.11/syntax_suggest/capture/before_after_keyword_ends.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  module Capture
-    # 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
-    #
-    #
-    # Example:
-    #
-    #   lines = BeforeAfterKeywordEnds.new(
-    #     block: block,
-    #     code_lines: code_lines
-    #   ).call()
-    #
-    class BeforeAfterKeywordEnds
-      def initialize(code_lines:, block:)
-        @scanner = ScanHistory.new(code_lines: code_lines, block: block)
-        @original_indent = block.current_indent
-      end
-
-      def call
-        lines = []
-
-        @scanner.scan(
-          up: ->(line, kw_count, end_count) {
-            next true if line.empty?
-            break if line.indent < @original_indent
-            next true if line.indent != @original_indent
-
-            # If we're going up and have one complete kw/end pair, stop
-            if kw_count != 0 && kw_count == end_count
-              lines << line
-              break
-            end
-
-            lines << line if line.is_kw? || line.is_end?
-            true
-          },
-          down: ->(line, kw_count, end_count) {
-            next true if line.empty?
-            break if line.indent < @original_indent
-            next true if line.indent != @original_indent
-
-            # if we're going down and have one complete kw/end pair,stop
-            if kw_count != 0 && kw_count == end_count
-              lines << line
-              break
-            end
-
-            lines << line if line.is_kw? || line.is_end?
-            true
-          }
-        )
-        @scanner.stash_changes
-
-        lines
-      end
-    end
-  end
-end