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

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

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  module Capture
-    # Shows the context around code provided by "falling" indentation
-    #
-    # If this is the original code lines:
-    #
-    #   class OH
-    #     def hello
-    #       it "foo" do
-    #     end
-    #   end
-    #
-    # And this is the line that is captured
-    #
-    #       it "foo" do
-    #
-    # It will yield its surrounding context:
-    #
-    #   class OH
-    #     def hello
-    #     end
-    #   end
-    #
-    # Example:
-    #
-    #   FallingIndentLines.new(
-    #       block: block,
-    #       code_lines: @code_lines
-    #   ).call do |line|
-    #     @lines_to_output << line
-    #   end
-    #
-    class FallingIndentLines
-      def initialize(code_lines:, block:)
-        @lines = nil
-        @scanner = ScanHistory.new(code_lines: code_lines, block: block)
-        @original_indent = block.current_indent
-      end
-
-      def call(&yieldable)
-        last_indent_up = @original_indent
-        last_indent_down = @original_indent
-
-        @scanner.commit_if_changed
-        @scanner.scan(
-          up: ->(line, _, _) {
-            next true if line.empty?
-
-            if line.indent < last_indent_up
-              yieldable.call(line)
-              last_indent_up = line.indent
-            end
-            true
-          },
-          down: ->(line, _, _) {
-            next true if line.empty?
-
-            if line.indent < last_indent_down
-              yieldable.call(line)
-              last_indent_down = line.indent
-            end
-            true
-          }
-        )
-        @scanner.stash_changes
-      end
-    end
-  end
-end

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

@@ -1,245 +0,0 @@
-# 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 meaningful
-  #
-  # 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 ambiguity 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

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

@@ -1,306 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxSuggest
-  # Parses and sanitizes source into a lexically aware document
-  #
-  # Internally the document is represented by an array with each
-  # index containing a CodeLine correlating to a line from the source code.
-  #
-  # There are three main phases in the algorithm:
-  #
-  # 1. Sanitize/format input source
-  # 2. Search for invalid blocks
-  # 3. Format invalid blocks into something meaningful
-  #
-  # This class handles the first part.
-  #
-  # The reason this class exists is to format input source
-  # for better/easier/cleaner exploration.
-  #
-  # The CodeSearch class operates at the line level so
-  # we must be careful to not introduce lines that look
-  # valid by themselves, but when removed will trigger syntax errors
-  # or strange behavior.
-  #
-  # ## Join Trailing slashes
-  #
-  # Code with a trailing slash is logically treated as a single line:
-  #
-  #     1 it "code can be split" \
-  #     2    "across multiple lines" do
-  #
-  # In this case removing line 2 would add a syntax error. We get around
-  # this by internally joining the two lines into a single "line" object
-  #
-  # ## Logically Consecutive lines
-  #
-  # Code that can be broken over multiple
-  # lines such as method calls are on different lines:
-  #
-  #     1 User.
-  #     2   where(name: "schneems").
-  #     3   first
-  #
-  # Removing line 2 can introduce a syntax error. To fix this, all lines
-  # are joined into one.
-  #
-  # ## Heredocs
-  #
-  # A heredoc is an way of defining a multi-line string. They can cause many
-  # problems. If left as a single line, the parser would try to parse the contents
-  # as ruby code rather than as a string. Even without this problem, we still
-  # hit an issue with indentation:
-  #
-  #    1 foo = <<~HEREDOC
-  #    2  "Be yourself; everyone else is already taken.""
-  #    3    ― Oscar Wilde
-  #    4      puts "I look like ruby code" # but i'm still a heredoc
-  #    5 HEREDOC
-  #
-  # If we didn't join these lines then our algorithm would think that line 4
-  # is separate from the rest, has a higher indentation, then look at it first
-  # and remove it.
-  #
-  # If the code evaluates line 5 by itself it will think line 5 is a constant,
-  # remove it, and introduce a syntax errror.
-  #
-  # All of these problems are fixed by joining the whole heredoc into a single
-  # line.
-  #
-  # ## Comments and whitespace
-  #
-  # Comments can throw off the way the lexer tells us that the line
-  # logically belongs with the next line. This is valid ruby but
-  # results in a different lex output than before:
-  #
-  #     1 User.
-  #     2   where(name: "schneems").
-  #     3   # Comment here
-  #     4   first
-  #
-  # To handle this we can replace comment lines with empty lines
-  # and then re-lex the source. This removal and re-lexing preserves
-  # line index and document size, but generates an easier to work with
-  # document.
-  #
-  class CleanDocument
-    def initialize(source:)
-      lines = clean_sweep(source: source)
-      @document = CodeLine.from_source(lines.join, lines: lines)
-    end
-
-    # Call all of the document "cleaners"
-    # and return self
-    def call
-      join_trailing_slash!
-      join_consecutive!
-      join_heredoc!
-
-      self
-    end
-
-    # Return an array of CodeLines in the
-    # document
-    def lines
-      @document
-    end
-
-    # Renders the document back to a string
-    def to_s
-      @document.join
-    end
-
-    # Remove comments
-    #
-    # replace with empty newlines
-    #
-    #     source = <<~'EOM'
-    #       # Comment 1
-    #       puts "hello"
-    #       # Comment 2
-    #       puts "world"
-    #     EOM
-    #
-    #     lines = CleanDocument.new(source: source).lines
-    #     expect(lines[0].to_s).to eq("\n")
-    #     expect(lines[1].to_s).to eq("puts "hello")
-    #     expect(lines[2].to_s).to eq("\n")
-    #     expect(lines[3].to_s).to eq("puts "world")
-    #
-    # Important: This must be done before lexing.
-    #
-    # After this change is made, we lex the document because
-    # removing comments can change how the doc is parsed.
-    #
-    # For example:
-    #
-    #     values = LexAll.new(source: <<~EOM))
-    #       User.
-    #         # comment
-    #         where(name: 'schneems')
-    #     EOM
-    #     expect(
-    #       values.count {|v| v.type == :on_ignored_nl}
-    #     ).to eq(1)
-    #
-    # After the comment is removed:
-    #
-    #     values = LexAll.new(source: <<~EOM))
-    #       User.
-    #
-    #         where(name: 'schneems')
-    #     EOM
-    #     expect(
-    #      values.count {|v| v.type == :on_ignored_nl}
-    #    ).to eq(2)
-    #
-    def clean_sweep(source:)
-      # Match comments, but not HEREDOC strings with #{variable} interpolation
-      # https://rubular.com/r/HPwtW9OYxKUHXQ
-      source.lines.map do |line|
-        if line.match?(/^\s*#([^{].*|)$/)
-          $/
-        else
-          line
-        end
-      end
-    end
-
-    # Smushes all heredoc lines into one line
-    #
-    #     source = <<~'EOM'
-    #       foo = <<~HEREDOC
-    #          lol
-    #          hehehe
-    #       HEREDOC
-    #     EOM
-    #
-    #     lines = CleanDocument.new(source: source).join_heredoc!.lines
-    #     expect(lines[0].to_s).to eq(source)
-    #     expect(lines[1].to_s).to eq("")
-    def join_heredoc!
-      start_index_stack = []
-      heredoc_beg_end_index = []
-      lines.each do |line|
-        line.lex.each do |lex_value|
-          case lex_value.type
-          when :on_heredoc_beg
-            start_index_stack << line.index
-          when :on_heredoc_end
-            start_index = start_index_stack.pop
-            end_index = line.index
-            heredoc_beg_end_index << [start_index, end_index]
-          end
-        end
-      end
-
-      heredoc_groups = heredoc_beg_end_index.map { |start_index, end_index| @document[start_index..end_index] }
-
-      join_groups(heredoc_groups)
-      self
-    end
-
-    # Smushes logically "consecutive" lines
-    #
-    #     source = <<~'EOM'
-    #       User.
-    #         where(name: 'schneems').
-    #         first
-    #     EOM
-    #
-    #     lines = CleanDocument.new(source: source).join_consecutive!.lines
-    #     expect(lines[0].to_s).to eq(source)
-    #     expect(lines[1].to_s).to eq("")
-    #
-    # The one known case this doesn't handle is:
-    #
-    #     Ripper.lex <<~EOM
-    #       a &&
-    #        b ||
-    #        c
-    #     EOM
-    #
-    # For some reason this introduces `on_ignore_newline` but with BEG type
-    #
-    def join_consecutive!
-      consecutive_groups = @document.select(&:ignore_newline_not_beg?).map do |code_line|
-        take_while_including(code_line.index..) do |line|
-          line.ignore_newline_not_beg?
-        end
-      end
-
-      join_groups(consecutive_groups)
-      self
-    end
-
-    # Join lines with a trailing slash
-    #
-    #     source = <<~'EOM'
-    #       it "code can be split" \
-    #          "across multiple lines" do
-    #     EOM
-    #
-    #     lines = CleanDocument.new(source: source).join_consecutive!.lines
-    #     expect(lines[0].to_s).to eq(source)
-    #     expect(lines[1].to_s).to eq("")
-    def join_trailing_slash!
-      trailing_groups = @document.select(&:trailing_slash?).map do |code_line|
-        take_while_including(code_line.index..) { |x| x.trailing_slash? }
-      end
-      join_groups(trailing_groups)
-      self
-    end
-
-    # Helper method for joining "groups" of lines
-    #
-    # Input is expected to be type Array<Array<CodeLine>>
-    #
-    # The outer array holds the various "groups" while the
-    # inner array holds code lines.
-    #
-    # All code lines are "joined" into the first line in
-    # their group.
-    #
-    # To preserve document size, empty lines are placed
-    # in the place of the lines that were "joined"
-    def join_groups(groups)
-      groups.each do |lines|
-        line = lines.first
-
-        # Handle the case of multiple groups in a row
-        # if one is already replaced, move on
-        next if @document[line.index].empty?
-
-        # Join group into the first line
-        @document[line.index] = CodeLine.new(
-          lex: lines.map(&:lex).flatten,
-          line: lines.join,
-          index: line.index
-        )
-
-        # Hide the rest of the lines
-        lines[1..].each do |line|
-          # The above lines already have newlines in them, if add more
-          # then there will be double newline, use an empty line instead
-          @document[line.index] = CodeLine.new(line: "", index: line.index, lex: [])
-        end
-      end
-      self
-    end
-
-    # Helper method for grabbing elements from document
-    #
-    # Like `take_while` except when it stops
-    # iterating, it also returns the line
-    # that caused it to stop
-    def take_while_including(range = 0..)
-      take_next_and_stop = false
-      @document[range].take_while do |line|
-        next if take_next_and_stop
-
-        take_next_and_stop = !(yield line)
-        true
-      end
-    end
-  end
-end