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

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

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Searches code for a syntax error
-  #
-  # 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 part.
-  #
-  # The bulk of the heavy lifting is done in:
-  #
-  #  - CodeFrontier (Holds information for generating blocks and determining if we can stop searching)
-  #  - ParseBlocksFromLine (Creates blocks into the frontier)
-  #  - BlockExpand (Expands existing blocks to search more code)
-  #
-  # ## Syntax error detection
-  #
-  # When the frontier holds the syntax error, we can stop searching
-  #
-  #   search = CodeSearch.new(<<~EOM)
-  #     def dog
-  #       def lol
-  #     end
-  #   EOM
-  #
-  #   search.call
-  #
-  #   search.invalid_blocks.map(&:to_s) # =>
-  #   # => ["def lol\n"]
-  #
-  class CodeSearch
-    private
-
-    attr_reader :frontier
-
-    public
-
-    attr_reader :invalid_blocks, :record_dir, :code_lines
-
-    def initialize(source, record_dir: DEFAULT_VALUE)
-      record_dir = if record_dir == DEFAULT_VALUE
-        (ENV["SYNTAX_SUGGEST_RECORD_DIR"] || ENV["SYNTAX_SUGGEST_DEBUG"]) ? "tmp" : nil
-      else
-        record_dir
-      end
-
-      if record_dir
-        @record_dir = SyntaxSuggest.record_dir(record_dir)
-        @write_count = 0
-      end
-
-      @tick = 0
-      @source = source
-      @name_tick = Hash.new { |hash, k| hash[k] = 0 }
-      @invalid_blocks = []
-
-      @code_lines = CleanDocument.new(source: source).call.lines
-
-      @frontier = CodeFrontier.new(code_lines: @code_lines)
-      @block_expand = BlockExpand.new(code_lines: @code_lines)
-      @parse_blocks_from_indent_line = ParseBlocksFromIndentLine.new(code_lines: @code_lines)
-    end
-
-    # Used for debugging
-    def record(block:, name: "record")
-      return unless @record_dir
-      @name_tick[name] += 1
-      filename = "#{@write_count += 1}-#{name}-#{@name_tick[name]}-(#{block.starts_at}__#{block.ends_at}).txt"
-      if ENV["SYNTAX_SUGGEST_DEBUG"]
-        puts "\n\n==== #{filename} ===="
-        puts "\n```#{block.starts_at}..#{block.ends_at}"
-        puts block
-        puts "```"
-        puts "  block indent:      #{block.current_indent}"
-      end
-      @record_dir.join(filename).open(mode: "a") do |f|
-        document = DisplayCodeWithLineNumbers.new(
-          lines: @code_lines.select(&:visible?),
-          terminal: false,
-          highlight_lines: block.lines
-        ).call
-
-        f.write("    Block lines: #{block.starts_at..block.ends_at} (#{name}) \n\n#{document}")
-      end
-    end
-
-    def push(block, name:)
-      record(block: block, name: name)
-
-      block.mark_invisible if block.valid?
-      frontier << block
-    end
-
-    # Parses the most indented lines into blocks that are marked
-    # and added to the frontier
-    def create_blocks_from_untracked_lines
-      max_indent = frontier.next_indent_line&.indent
-
-      while (line = frontier.next_indent_line) && (line.indent == max_indent)
-        @parse_blocks_from_indent_line.each_neighbor_block(frontier.next_indent_line) do |block|
-          push(block, name: "add")
-        end
-      end
-    end
-
-    # Given an already existing block in the frontier, expand it to see
-    # if it contains our invalid syntax
-    def expand_existing
-      block = frontier.pop
-      return unless block
-
-      record(block: block, name: "before-expand")
-
-      block = @block_expand.call(block)
-      push(block, name: "expand")
-    end
-
-    # Main search loop
-    def call
-      until frontier.holds_all_syntax_errors?
-        @tick += 1
-
-        if frontier.expand?
-          expand_existing
-        else
-          create_blocks_from_untracked_lines
-        end
-      end
-
-      @invalid_blocks.concat(frontier.detect_invalid_blocks)
-      @invalid_blocks.sort_by! { |block| block.starts_at }
-      self
-    end
-  end
-end

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

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# Ruby 3.2+ has a cleaner way to hook into Ruby that doesn't use `require`
-if SyntaxError.method_defined?(:detailed_message)
-  module SyntaxSuggest
-    # SyntaxSuggest.module_for_detailed_message [Private]
-    #
-    # Used to monkeypatch SyntaxError via Module.prepend
-    def self.module_for_detailed_message
-      Module.new {
-        def detailed_message(highlight: true, syntax_suggest: true, **kwargs)
-          return super unless syntax_suggest
-
-          require "syntax_suggest/api" unless defined?(SyntaxSuggest::DEFAULT_VALUE)
-
-          message = super
-
-          if path
-            file = Pathname.new(path)
-            io = SyntaxSuggest::MiniStringIO.new
-
-            SyntaxSuggest.call(
-              io: io,
-              source: file.read,
-              filename: file,
-              terminal: highlight
-            )
-            annotation = io.string
-
-            annotation += "\n" unless annotation.end_with?("\n")
-
-            annotation + message
-          else
-            message
-          end
-        rescue => e
-          if ENV["SYNTAX_SUGGEST_DEBUG"]
-            $stderr.warn(e.message)
-            $stderr.warn(e.backtrace)
-          end
-
-          # Ignore internal errors
-          message
-        end
-      }
-    end
-  end
-
-  SyntaxError.prepend(SyntaxSuggest.module_for_detailed_message)
-else
-  autoload :Pathname, "pathname"
-
-  #--
-  # Monkey patch kernel to ensure that all `require` calls call the same
-  # method
-  #++
-  module Kernel
-    # :stopdoc:
-
-    module_function
-
-    alias_method :syntax_suggest_original_require, :require
-    alias_method :syntax_suggest_original_require_relative, :require_relative
-    alias_method :syntax_suggest_original_load, :load
-
-    def load(file, wrap = false)
-      syntax_suggest_original_load(file)
-    rescue SyntaxError => e
-      require "syntax_suggest/api" unless defined?(SyntaxSuggest::DEFAULT_VALUE)
-
-      SyntaxSuggest.handle_error(e)
-    end
-
-    def require(file)
-      syntax_suggest_original_require(file)
-    rescue SyntaxError => e
-      require "syntax_suggest/api" unless defined?(SyntaxSuggest::DEFAULT_VALUE)
-
-      SyntaxSuggest.handle_error(e)
-    end
-
-    def require_relative(file)
-      if Pathname.new(file).absolute?
-        syntax_suggest_original_require file
-      else
-        relative_from = caller_locations(1..1).first
-        relative_from_path = relative_from.absolute_path || relative_from.path
-        syntax_suggest_original_require File.expand_path("../#{file}", relative_from_path)
-      end
-    rescue SyntaxError => e
-      require "syntax_suggest/api" unless defined?(SyntaxSuggest::DEFAULT_VALUE)
-
-      SyntaxSuggest.handle_error(e)
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Outputs code with highlighted lines
-  #
-  # Whatever is passed to this class will be rendered
-  # even if it is "marked invisible" any filtering of
-  # output should be done before calling this class.
-  #
-  #   DisplayCodeWithLineNumbers.new(
-  #     lines: lines,
-  #     highlight_lines: [lines[2], lines[3]]
-  #   ).call
-  #   # =>
-  #       1
-  #       2  def cat
-  #     > 3    Dir.chdir
-  #     > 4    end
-  #       5  end
-  #       6
-  class DisplayCodeWithLineNumbers
-    TERMINAL_HIGHLIGHT = "\e[1;3m" # Bold, italics
-    TERMINAL_END = "\e[0m"
-
-    def initialize(lines:, highlight_lines: [], terminal: false)
-      @lines = Array(lines).sort
-      @terminal = terminal
-      @highlight_line_hash = Array(highlight_lines).each_with_object({}) { |line, h| h[line] = true }
-      @digit_count = @lines.last&.line_number.to_s.length
-    end
-
-    def call
-      @lines.map do |line|
-        format_line(line)
-      end.join
-    end
-
-    private def format_line(code_line)
-      # Handle trailing slash lines
-      code_line.original.lines.map.with_index do |contents, i|
-        format(
-          empty: code_line.empty?,
-          number: (code_line.number + i).to_s,
-          contents: contents,
-          highlight: @highlight_line_hash[code_line]
-        )
-      end.join
-    end
-
-    private def format(contents:, number:, empty:, highlight: false)
-      string = +""
-      string << if highlight
-        "> "
-      else
-        "  "
-      end
-
-      string << number.rjust(@digit_count).to_s
-      if empty
-        string << contents
-      else
-        string << "  "
-        string << TERMINAL_HIGHLIGHT if @terminal && highlight
-        string << contents
-        string << TERMINAL_END if @terminal
-      end
-      string
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "capture_code_context"
-require_relative "display_code_with_line_numbers"
-
-module SyntaxSuggest
-  # Used for formatting invalid blocks
-  class DisplayInvalidBlocks
-    attr_reader :filename
-
-    def initialize(code_lines:, blocks:, io: $stderr, filename: nil, terminal: DEFAULT_VALUE)
-      @io = io
-      @blocks = Array(blocks)
-      @filename = filename
-      @code_lines = code_lines
-
-      @terminal = (terminal == DEFAULT_VALUE) ? io.isatty : terminal
-    end
-
-    def document_ok?
-      @blocks.none? { |b| !b.hidden? }
-    end
-
-    def call
-      if document_ok?
-        return self
-      end
-
-      if filename
-        @io.puts("--> #{filename}")
-        @io.puts
-      end
-      @blocks.each do |block|
-        display_block(block)
-      end
-
-      self
-    end
-
-    private def display_block(block)
-      # Build explanation
-      explain = ExplainSyntax.new(
-        code_lines: block.lines
-      ).call
-
-      # Enhance code output
-      # Also handles several ambiguious cases
-      lines = CaptureCodeContext.new(
-        blocks: block,
-        code_lines: @code_lines
-      ).call
-
-      # Build code output
-      document = DisplayCodeWithLineNumbers.new(
-        lines: lines,
-        terminal: @terminal,
-        highlight_lines: block.lines
-      ).call
-
-      # Output syntax error explanation
-      explain.errors.each do |e|
-        @io.puts e
-      end
-      @io.puts
-
-      # Output code
-      @io.puts(document)
-    end
-
-    private def code_with_context
-      lines = CaptureCodeContext.new(
-        blocks: @blocks,
-        code_lines: @code_lines
-      ).call
-
-      DisplayCodeWithLineNumbers.new(
-        lines: lines,
-        terminal: @terminal,
-        highlight_lines: @invalid_lines
-      ).call
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "left_right_lex_count"
-
-if !SyntaxSuggest.use_prism_parser?
-  require_relative "ripper_errors"
-end
-
-module SyntaxSuggest
-  class GetParseErrors
-    def self.errors(source)
-      if SyntaxSuggest.use_prism_parser?
-        Prism.parse(source).errors.map(&:message)
-      else
-        RipperErrors.new(source).call.errors
-      end
-    end
-  end
-
-  # Explains syntax errors based on their source
-  #
-  # example:
-  #
-  #   source = "def foo; puts 'lol'" # Note missing end
-  #   explain ExplainSyntax.new(
-  #     code_lines: CodeLine.from_source(source)
-  #   ).call
-  #   explain.errors.first
-  #   # => "Unmatched keyword, missing `end' ?"
-  #
-  # When the error cannot be determined by lexical counting
-  # then the parser is run against the input and the raw
-  # errors are returned.
-  #
-  # Example:
-  #
-  #   source = "1 * " # Note missing a second number
-  #   explain ExplainSyntax.new(
-  #     code_lines: CodeLine.from_source(source)
-  #   ).call
-  #   explain.errors.first
-  #   # => "syntax error, unexpected end-of-input"
-  class ExplainSyntax
-    INVERSE = {
-      "{" => "}",
-      "}" => "{",
-      "[" => "]",
-      "]" => "[",
-      "(" => ")",
-      ")" => "(",
-      "|" => "|"
-    }.freeze
-
-    def initialize(code_lines:)
-      @code_lines = code_lines
-      @left_right = LeftRightLexCount.new
-      @missing = nil
-    end
-
-    def call
-      @code_lines.each do |line|
-        line.lex.each do |lex|
-          @left_right.count_lex(lex)
-        end
-      end
-
-      self
-    end
-
-    # Returns an array of missing elements
-    #
-    # For example this:
-    #
-    #   ExplainSyntax.new(code_lines: lines).missing
-    #   # => ["}"]
-    #
-    # Would indicate that the source is missing
-    # a `}` character in the source code
-    def missing
-      @missing ||= @left_right.missing
-    end
-
-    # Converts a missing string to
-    # an human understandable explanation.
-    #
-    # Example:
-    #
-    #   explain.why("}")
-    #   # => "Unmatched `{', missing `}' ?"
-    #
-    def why(miss)
-      case miss
-      when "keyword"
-        "Unmatched `end', missing keyword (`do', `def`, `if`, etc.) ?"
-      when "end"
-        "Unmatched keyword, missing `end' ?"
-      else
-        inverse = INVERSE.fetch(miss) {
-          raise "Unknown explain syntax char or key: #{miss.inspect}"
-        }
-        "Unmatched `#{inverse}', missing `#{miss}' ?"
-      end
-    end
-
-    # Returns an array of syntax error messages
-    #
-    # If no missing pairs are found it falls back
-    # on the original error messages
-    def errors
-      if missing.empty?
-        return GetParseErrors.errors(@code_lines.map(&:original).join).uniq
-      end
-
-      missing.map { |miss| why(miss) }
-    end
-  end
-end

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

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Find mis-matched syntax based on lexical count
-  #
-  # Used for detecting missing pairs of elements
-  # each keyword needs an end, each '{' needs a '}'
-  # etc.
-  #
-  # Example:
-  #
-  #   left_right = LeftRightLexCount.new
-  #   left_right.count_kw
-  #   left_right.missing.first
-  #   # => "end"
-  #
-  #   left_right = LeftRightLexCount.new
-  #   source = "{ a: b, c: d" # Note missing '}'
-  #   LexAll.new(source: source).each do |lex|
-  #     left_right.count_lex(lex)
-  #   end
-  #   left_right.missing.first
-  #   # => "}"
-  class LeftRightLexCount
-    def initialize
-      @kw_count = 0
-      @end_count = 0
-
-      @count_for_char = {
-        "{" => 0,
-        "}" => 0,
-        "[" => 0,
-        "]" => 0,
-        "(" => 0,
-        ")" => 0,
-        "|" => 0
-      }
-    end
-
-    def count_kw
-      @kw_count += 1
-    end
-
-    def count_end
-      @end_count += 1
-    end
-
-    # Count source code characters
-    #
-    # Example:
-    #
-    #   left_right = LeftRightLexCount.new
-    #   left_right.count_lex(LexValue.new(1, :on_lbrace, "{", Ripper::EXPR_BEG))
-    #   left_right.count_for_char("{")
-    #   # => 1
-    #   left_right.count_for_char("}")
-    #   # => 0
-    def count_lex(lex)
-      case lex.type
-      when :on_tstring_content
-        # ^^^
-        # Means it's a string or a symbol `"{"` rather than being
-        # part of a data structure (like a hash) `{ a: b }`
-        # ignore it.
-      when :on_words_beg, :on_symbos_beg, :on_qwords_beg,
-           :on_qsymbols_beg, :on_regexp_beg, :on_tstring_beg
-        # ^^^
-        # Handle shorthand syntaxes like `%Q{ i am a string }`
-        #
-        # The start token will be the full thing `%Q{` but we
-        # need to count it as if it's a `{`. Any token
-        # can be used
-        char = lex.token[-1]
-        @count_for_char[char] += 1 if @count_for_char.key?(char)
-      when :on_embexpr_beg
-        # ^^^
-        # Embedded string expressions like `"#{foo} <-embed"`
-        # are parsed with chars:
-        #
-        # `#{` as :on_embexpr_beg
-        #  `}` as :on_embexpr_end
-        #
-        # We cannot ignore both :on_emb_expr_beg and :on_embexpr_end
-        # because sometimes the lexer thinks something is an embed
-        # string end, when it is not like `lol = }` (no clue why).
-        #
-        # When we see `#{` count it as a `{` or we will
-        # have a mis-match count.
-        #
-        case lex.token
-        when "\#{"
-          @count_for_char["{"] += 1
-        end
-      else
-        @end_count += 1 if lex.is_end?
-        @kw_count += 1 if lex.is_kw?
-        @count_for_char[lex.token] += 1 if @count_for_char.key?(lex.token)
-      end
-    end
-
-    def count_for_char(char)
-      @count_for_char[char]
-    end
-
-    # Returns an array of missing syntax characters
-    # or `"end"` or `"keyword"`
-    #
-    #   left_right.missing
-    #   # => ["}"]
-    def missing
-      out = missing_pairs
-      out << missing_pipe
-      out << missing_keyword_end
-      out.compact!
-      out
-    end
-
-    PAIRS = {
-      "{" => "}",
-      "[" => "]",
-      "(" => ")"
-    }.freeze
-
-    # Opening characters like `{` need closing characters # like `}`.
-    #
-    # When a mis-match count is detected, suggest the
-    # missing member.
-    #
-    # For example if there are 3 `}` and only two `{`
-    # return `"{"`
-    private def missing_pairs
-      PAIRS.map do |(left, right)|
-        case @count_for_char[left] <=> @count_for_char[right]
-        when 1
-          right
-        when 0
-          nil
-        when -1
-          left
-        end
-      end
-    end
-
-    # Keywords need ends and ends need keywords
-    #
-    # If we have more keywords, there's a missing `end`
-    # if we have more `end`-s, there's a missing keyword
-    private def missing_keyword_end
-      case @kw_count <=> @end_count
-      when 1
-        "end"
-      when 0
-        nil
-      when -1
-        "keyword"
-      end
-    end
-
-    # Pipes come in pairs.
-    # If there's an odd number of pipes then we
-    # are missing one
-    private def missing_pipe
-      if @count_for_char["|"].odd?
-        "|"
-      end
-    end
-  end
-end