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

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Ripper.lex is not guaranteed to lex the entire source document
-  #
-  # This class guarantees the whole document is lex-ed by iteratively
-  # lexing the document where ripper stopped.
-  #
-  # Prism likely doesn't have the same problem. Once ripper support is removed
-  # we can likely reduce the complexity here if not remove the whole concept.
-  #
-  # Example usage:
-  #
-  #   lex = LexAll.new(source: source)
-  #   lex.each do |value|
-  #     puts value.line
-  #   end
-  class LexAll
-    include Enumerable
-
-    def initialize(source:, source_lines: nil)
-      @lex = self.class.lex(source, 1)
-      lineno = @lex.last[0][0] + 1
-      source_lines ||= source.lines
-      last_lineno = source_lines.length
-
-      until lineno >= last_lineno
-        lines = source_lines[lineno..]
-
-        @lex.concat(
-          self.class.lex(lines.join, lineno + 1)
-        )
-
-        lineno = @lex.last[0].first + 1
-      end
-
-      last_lex = nil
-      @lex.map! { |elem|
-        last_lex = LexValue.new(elem[0].first, elem[1], elem[2], elem[3], last_lex)
-      }
-    end
-
-    if SyntaxSuggest.use_prism_parser?
-      def self.lex(source, line_number)
-        Prism.lex_compat(source, line: line_number).value.sort_by { |values| values[0] }
-      end
-    else
-      def self.lex(source, line_number)
-        Ripper::Lexer.new(source, "-", line_number).parse.sort_by(&:pos)
-      end
-    end
-
-    def to_a
-      @lex
-    end
-
-    def each
-      return @lex.each unless block_given?
-      @lex.each do |x|
-        yield x
-      end
-    end
-
-    def [](index)
-      @lex[index]
-    end
-
-    def last
-      @lex.last
-    end
-  end
-end
-
-require_relative "lex_value"

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Value object for accessing lex values
-  #
-  # This lex:
-  #
-  #   [1, 0], :on_ident, "describe", CMDARG
-  #
-  # Would translate into:
-  #
-  #  lex.line # => 1
-  #  lex.type # => :on_indent
-  #  lex.token # => "describe"
-  class LexValue
-    attr_reader :line, :type, :token, :state
-
-    def initialize(line, type, token, state, last_lex = nil)
-      @line = line
-      @type = type
-      @token = token
-      @state = state
-
-      set_kw_end(last_lex)
-    end
-
-    private def set_kw_end(last_lex)
-      @is_end = false
-      @is_kw = false
-      return if type != :on_kw
-
-      return if last_lex && last_lex.fname? # https://github.com/ruby/ruby/commit/776759e300e4659bb7468e2b97c8c2d4359a2953
-
-      case token
-      when "if", "unless", "while", "until"
-        # Only count if/unless when it's not a "trailing" if/unless
-        # https://github.com/ruby/ruby/blob/06b44f819eb7b5ede1ff69cecb25682b56a1d60c/lib/irb/ruby-lex.rb#L374-L375
-        @is_kw = true unless expr_label?
-      when "def", "case", "for", "begin", "class", "module", "do"
-        @is_kw = true
-      when "end"
-        @is_end = true
-      end
-    end
-
-    def fname?
-      state.allbits?(Ripper::EXPR_FNAME)
-    end
-
-    def ignore_newline?
-      type == :on_ignored_nl
-    end
-
-    def is_end?
-      @is_end
-    end
-
-    def is_kw?
-      @is_kw
-    end
-
-    def expr_beg?
-      state.anybits?(Ripper::EXPR_BEG)
-    end
-
-    def expr_label?
-      state.allbits?(Ripper::EXPR_LABEL)
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Mini String IO [Private]
-  #
-  # Acts like a StringIO with reduced API, but without having to require that
-  # class.
-  #
-  # The original codebase emitted directly to $stderr, but now SyntaxError#detailed_message
-  # needs a string output. To accomplish that we kept the original print infrastructure in place and
-  # added this class to accumulate the print output into a string.
-  class MiniStringIO
-    EMPTY_ARG = Object.new
-
-    def initialize(isatty: $stderr.isatty)
-      @string = +""
-      @isatty = isatty
-    end
-
-    attr_reader :isatty
-    def puts(value = EMPTY_ARG, **)
-      if !value.equal?(EMPTY_ARG)
-        @string << value
-      end
-      @string << $/
-    end
-
-    attr_reader :string
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # This class is responsible for generating initial code blocks
-  # that will then later be expanded.
-  #
-  # The biggest concern when guessing code blocks, is accidentally
-  # grabbing one that contains only an "end". In this example:
-  #
-  #   def dog
-  #     begonn # misspelled `begin`
-  #     puts "bark"
-  #     end
-  #   end
-  #
-  # The following lines would be matched (from bottom to top):
-  #
-  #   1) end
-  #
-  #   2) puts "bark"
-  #      end
-  #
-  #   3) begonn
-  #      puts "bark"
-  #      end
-  #
-  # At this point it has no where else to expand, and it will yield this inner
-  # code as a block
-  class ParseBlocksFromIndentLine
-    attr_reader :code_lines
-
-    def initialize(code_lines:)
-      @code_lines = code_lines
-    end
-
-    # Builds blocks from bottom up
-    def each_neighbor_block(target_line)
-      scan = AroundBlockScan.new(code_lines: code_lines, block: CodeBlock.new(lines: target_line))
-        .force_add_empty
-        .force_add_hidden
-        .scan_while { |line| line.indent >= target_line.indent }
-
-      neighbors = scan.code_block.lines
-
-      block = CodeBlock.new(lines: neighbors)
-      if neighbors.length <= 2 || block.valid?
-        yield block
-      else
-        until neighbors.empty?
-          lines = [neighbors.pop]
-          while (block = CodeBlock.new(lines: lines)) && block.invalid? && neighbors.any?
-            lines.prepend neighbors.pop
-          end
-
-          yield block if block
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Converts a SyntaxError message to a path
-  #
-  # Handles the case where the filename has a colon in it
-  # such as on a windows file system: https://github.com/ruby/syntax_suggest/issues/111
-  #
-  # Example:
-  #
-  #    message = "/tmp/scratch:2:in `require_relative': /private/tmp/bad.rb:1: syntax error, unexpected `end' (SyntaxError)"
-  #    puts PathnameFromMessage.new(message).call.name
-  #    # => "/tmp/scratch.rb"
-  #
-  class PathnameFromMessage
-    EVAL_RE = /^\(eval.*\):\d+/
-    STREAMING_RE = /^-:\d+/
-    attr_reader :name
-
-    def initialize(message, io: $stderr)
-      @line = message.lines.first
-      @parts = @line.split(":")
-      @guess = []
-      @name = nil
-      @io = io
-    end
-
-    def call
-      if skip_missing_file_name?
-        if ENV["SYNTAX_SUGGEST_DEBUG"]
-          @io.puts "SyntaxSuggest: Could not find filename from #{@line.inspect}"
-        end
-      else
-        until stop?
-          @guess << @parts.shift
-          @name = Pathname(@guess.join(":"))
-        end
-
-        if @parts.empty?
-          @io.puts "SyntaxSuggest: Could not find filename from #{@line.inspect}"
-          @name = nil
-        end
-      end
-
-      self
-    end
-
-    def stop?
-      return true if @parts.empty?
-      return false if @guess.empty?
-
-      @name&.exist?
-    end
-
-    def skip_missing_file_name?
-      @line.match?(EVAL_RE) || @line.match?(STREAMING_RE)
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Keeps track of what elements are in the queue in
-  # priority and also ensures that when one element
-  # engulfs/covers/eats another that the larger element
-  # evicts the smaller element
-  class PriorityEngulfQueue
-    def initialize
-      @queue = PriorityQueue.new
-    end
-
-    def to_a
-      @queue.to_a
-    end
-
-    def empty?
-      @queue.empty?
-    end
-
-    def length
-      @queue.length
-    end
-
-    def peek
-      @queue.peek
-    end
-
-    def pop
-      @queue.pop
-    end
-
-    def push(block)
-      prune_engulf(block)
-      @queue << block
-      flush_deleted
-
-      self
-    end
-
-    private def flush_deleted
-      while @queue&.peek&.deleted?
-        @queue.pop
-      end
-    end
-
-    private def prune_engulf(block)
-      # If we're about to pop off the same block, we can skip deleting
-      # things from the frontier this iteration since we'll get it
-      # on the next iteration
-      return if @queue.peek && (block <=> @queue.peek) == 1
-
-      if block.starts_at != block.ends_at # A block of size 1 cannot engulf another
-        @queue.to_a.each { |b|
-          if b.starts_at >= block.starts_at && b.ends_at <= block.ends_at
-            b.delete
-            true
-          end
-        }
-      end
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Holds elements in a priority heap on insert
-  #
-  # Instead of constantly calling `sort!`, put
-  # the element where it belongs the first time
-  # around
-  #
-  # Example:
-  #
-  #   queue = PriorityQueue.new
-  #   queue << 33
-  #   queue << 44
-  #   queue << 1
-  #
-  #   puts queue.peek # => 44
-  #
-  class PriorityQueue
-    attr_reader :elements
-
-    def initialize
-      @elements = []
-    end
-
-    def <<(element)
-      @elements << element
-      bubble_up(last_index, element)
-    end
-
-    def pop
-      exchange(0, last_index)
-      max = @elements.pop
-      bubble_down(0)
-      max
-    end
-
-    def length
-      @elements.length
-    end
-
-    def empty?
-      @elements.empty?
-    end
-
-    def peek
-      @elements.first
-    end
-
-    def to_a
-      @elements
-    end
-
-    # Used for testing, extremely not performant
-    def sorted
-      out = []
-      elements = @elements.dup
-      while (element = pop)
-        out << element
-      end
-      @elements = elements
-      out.reverse
-    end
-
-    private def last_index
-      @elements.size - 1
-    end
-
-    private def bubble_up(index, element)
-      return if index <= 0
-
-      parent_index = (index - 1) / 2
-      parent = @elements[parent_index]
-
-      return if (parent <=> element) >= 0
-
-      exchange(index, parent_index)
-      bubble_up(parent_index, element)
-    end
-
-    private def bubble_down(index)
-      child_index = (index * 2) + 1
-
-      return if child_index > last_index
-
-      not_the_last_element = child_index < last_index
-      left_element = @elements[child_index]
-      right_element = @elements[child_index + 1]
-
-      child_index += 1 if not_the_last_element && (right_element <=> left_element) == 1
-
-      return if (@elements[index] <=> @elements[child_index]) >= 0
-
-      exchange(index, child_index)
-      bubble_down(child_index)
-    end
-
-    def exchange(source, target)
-      a = @elements[source]
-      b = @elements[target]
-      @elements[source] = b
-      @elements[target] = a
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Capture parse errors from Ripper
-  #
-  # Prism returns the errors with their messages, but Ripper
-  # does not. To get them we must make a custom subclass.
-  #
-  # Example:
-  #
-  #   puts RipperErrors.new(" def foo").call.errors
-  #   # => ["syntax error, unexpected end-of-input, expecting ';' or '\\n'"]
-  class RipperErrors < Ripper
-    attr_reader :errors
-
-    # Comes from ripper, called
-    # on every parse error, msg
-    # is a string
-    def on_parse_error(msg)
-      @errors ||= []
-      @errors << msg
-    end
-
-    alias_method :on_alias_error, :on_parse_error
-    alias_method :on_assign_error, :on_parse_error
-    alias_method :on_class_name_error, :on_parse_error
-    alias_method :on_param_error, :on_parse_error
-    alias_method :compile_error, :on_parse_error
-
-    def call
-      @run_once ||= begin
-        @errors = []
-        parse
-        true
-      end
-      self
-    end
-  end
-end

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

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Scans up/down from the given block
-  #
-  # You can try out a change, stash it, or commit it to save for later
-  #
-  # Example:
-  #
-  #   scanner = ScanHistory.new(code_lines: code_lines, block: block)
-  #   scanner.scan(
-  #     up: ->(_, _, _) { true },
-  #     down: ->(_, _, _) { true }
-  #   )
-  #   scanner.changed? # => true
-  #   expect(scanner.lines).to eq(code_lines)
-  #
-  #   scanner.stash_changes
-  #
-  #   expect(scanner.lines).to_not eq(code_lines)
-  class ScanHistory
-    attr_reader :before_index, :after_index
-
-    def initialize(code_lines:, block:)
-      @code_lines = code_lines
-      @history = [block]
-      refresh_index
-    end
-
-    def commit_if_changed
-      if changed?
-        @history << CodeBlock.new(lines: @code_lines[before_index..after_index])
-      end
-
-      self
-    end
-
-    # Discards any changes that have not been committed
-    def stash_changes
-      refresh_index
-      self
-    end
-
-    # Discard changes that have not been committed and revert the last commit
-    #
-    # Cannot revert the first commit
-    def revert_last_commit
-      if @history.length > 1
-        @history.pop
-        refresh_index
-      end
-
-      self
-    end
-
-    def changed?
-      @before_index != current.lines.first.index ||
-        @after_index != current.lines.last.index
-    end
-
-    # Iterates up and down
-    #
-    # Returns line, kw_count, end_count for each iteration
-    def scan(up:, down:)
-      kw_count = 0
-      end_count = 0
-
-      up_index = before_lines.reverse_each.take_while do |line|
-        kw_count += 1 if line.is_kw?
-        end_count += 1 if line.is_end?
-        up.call(line, kw_count, end_count)
-      end.last&.index
-
-      kw_count = 0
-      end_count = 0
-
-      down_index = after_lines.each.take_while do |line|
-        kw_count += 1 if line.is_kw?
-        end_count += 1 if line.is_end?
-        down.call(line, kw_count, end_count)
-      end.last&.index
-
-      @before_index = if up_index && up_index < @before_index
-        up_index
-      else
-        @before_index
-      end
-
-      @after_index = if down_index && down_index > @after_index
-        down_index
-      else
-        @after_index
-      end
-
-      self
-    end
-
-    def next_up
-      return nil if @before_index <= 0
-
-      @code_lines[@before_index - 1]
-    end
-
-    def next_down
-      return nil if @after_index >= @code_lines.length
-
-      @code_lines[@after_index + 1]
-    end
-
-    def lines
-      @code_lines[@before_index..@after_index]
-    end
-
-    private def before_lines
-      @code_lines[0...@before_index] || []
-    end
-
-    # Returns an array of all the CodeLines that exist after
-    # the currently scanned block
-    private def after_lines
-      @code_lines[@after_index.next..] || []
-    end
-
-    private def current
-      @history.last
-    end
-
-    private def refresh_index
-      @before_index = current.lines.first.index
-      @after_index = current.lines.last.index
-      self
-    end
-  end
-end

package/lib/ruby/3.4.11/syntax_suggest/syntax_suggest.gemspec

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require_relative "lib/syntax_suggest/version"
-rescue LoadError # Fallback to load version file in ruby core repository
-  require_relative "version"
-end
-
-Gem::Specification.new do |spec|
-  spec.name = "syntax_suggest"
-  spec.version = SyntaxSuggest::VERSION
-  spec.authors = ["schneems"]
-  spec.email = ["richard.schneeman+foo@gmail.com"]
-
-  spec.summary = "Find syntax errors in your source in a snap"
-  spec.description = 'When you get an "unexpected end" in your syntax this gem helps you find it'
-  spec.homepage = "https://github.com/ruby/syntax_suggest.git"
-  spec.license = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/ruby/syntax_suggest.git"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|assets)/}) }
-  end
-  spec.bindir = "exe"
-  spec.executables = ["syntax_suggest"]
-  spec.require_paths = ["lib"]
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Tracks which lines various code blocks have expanded to
-  # and which are still unexplored
-  class UnvisitedLines
-    def initialize(code_lines:)
-      @unvisited = code_lines.sort_by(&:indent_index)
-      @visited_lines = {}
-      @visited_lines.compare_by_identity
-    end
-
-    def empty?
-      @unvisited.empty?
-    end
-
-    def peek
-      @unvisited.last
-    end
-
-    def pop
-      @unvisited.pop
-    end
-
-    def visit_block(block)
-      block.lines.each do |line|
-        next if @visited_lines[line]
-        @visited_lines[line] = true
-      end
-
-      while @visited_lines[@unvisited.last]
-        @unvisited.pop
-      end
-    end
-  end
-end