katakata_irb 0.1.3 → 0.1.5

data/lib/katakata_irb/reline_patches/wholelines.patch

@@ -1,102 +0,0 @@
-diff --git a/lib/reline/line_editor.rb b/lib/reline/line_editor.rb
-index 8153aab..1c33a4b 100644
---- a/lib/reline/line_editor.rb
-+++ b/lib/reline/line_editor.rb
-@@ -449,12 +449,8 @@ class Reline::LineEditor
-       Reline::IOGate.move_cursor_up(@first_line_started_from + @started_from - @scroll_partial_screen)
-       Reline::IOGate.move_cursor_column(0)
-       @scroll_partial_screen = nil
--      prompt, prompt_width, prompt_list = check_multiline_prompt(whole_lines)
--      if @previous_line_index
--        new_lines = whole_lines(index: @previous_line_index, line: @line)
--      else
--        new_lines = whole_lines
--      end
-+      new_lines = whole_lines
-+      prompt, prompt_width, prompt_list = check_multiline_prompt(new_lines)
-       modify_lines(new_lines).each_with_index do |line, index|
-         @output.write "#{prompt_list ? prompt_list[index] : prompt}#{line}\n"
-         Reline::IOGate.erase_after_cursor
-@@ -490,11 +486,7 @@ class Reline::LineEditor
-     if @is_multiline
-       if finished?
-         # Always rerender on finish because output_modifier_proc may return a different output.
--        if @previous_line_index
--          new_lines = whole_lines(index: @previous_line_index, line: @line)
--        else
--          new_lines = whole_lines
--        end
-+        new_lines = whole_lines
-         line = modify_lines(new_lines)[@line_index]
-         clear_dialog
-         prompt, prompt_width, prompt_list = check_multiline_prompt(new_lines)
-@@ -1013,11 +1005,7 @@ class Reline::LineEditor
-   end
- 
-   private def rerender_changed_current_line
--    if @previous_line_index
--      new_lines = whole_lines(index: @previous_line_index, line: @line)
--    else
--      new_lines = whole_lines
--    end
-+    new_lines = whole_lines
-     prompt, prompt_width, prompt_list = check_multiline_prompt(new_lines)
-     all_height = calculate_height_by_lines(new_lines, prompt_list || prompt)
-     diff = all_height - @highest_in_all
-@@ -1698,7 +1686,7 @@ class Reline::LineEditor
-     return if not @check_new_auto_indent and @previous_line_index # move cursor up or down
-     if @check_new_auto_indent and @previous_line_index and @previous_line_index > 0 and @line_index > @previous_line_index
-       # Fix indent of a line when a newline is inserted to the next
--      new_lines = whole_lines(index: @previous_line_index, line: @line)
-+      new_lines = whole_lines
-       new_indent = @auto_indent_proc.(new_lines[0..-3].push(''), @line_index - 1, 0, true)
-       md = @line.match(/\A */)
-       prev_indent = md[0].count(' ')
-@@ -1713,11 +1701,7 @@ class Reline::LineEditor
-         @line = ' ' * new_indent + @line.lstrip
-       end
-     end
--    if @previous_line_index
--      new_lines = whole_lines(index: @previous_line_index, line: @line)
--    else
--      new_lines = whole_lines
--    end
-+    new_lines = whole_lines
-     new_indent = @auto_indent_proc.(new_lines, @line_index, @byte_pointer, @check_new_auto_indent)
-     new_indent = @cursor_max if new_indent&.> @cursor_max
-     if new_indent&.>= 0
-@@ -1803,11 +1787,7 @@ class Reline::LineEditor
-       target = before
-     end
-     if @is_multiline
--      if @previous_line_index
--        lines = whole_lines(index: @previous_line_index, line: @line)
--      else
--        lines = whole_lines
--      end
-+      lines = whole_lines
-       if @line_index > 0
-         preposing = lines[0..(@line_index - 1)].join("\n") + "\n" + preposing
-       end
-@@ -1907,7 +1887,7 @@ class Reline::LineEditor
-     @cursor_max = calculate_width(@line)
-   end
- 
--  def whole_lines(index: @line_index, line: @line)
-+  def whole_lines(index: @previous_line_index || @line_index, line: @line)
-     temp_lines = @buffer_of_lines.dup
-     temp_lines[index] = line
-     temp_lines
-@@ -1917,11 +1897,7 @@ class Reline::LineEditor
-     if @buffer_of_lines.size == 1 and @line.nil?
-       nil
-     else
--      if @previous_line_index
--        whole_lines(index: @previous_line_index, line: @line).join("\n")
--      else
--        whole_lines.join("\n")
--      end
-+      whole_lines.join("\n")
-     end
-   end
- 

data/lib/katakata_irb/ruby_lex_patch.rb

@@ -1,221 +0,0 @@
-require 'irb'
-require_relative 'trex'
-
-module KatakataIrb::RubyLexPatch
-  def self.patch_to_ruby_lex
-    (RubyLex.instance_methods(false) - [:set_prompt, :process_continue, :check_code_block]).each { RubyLex.remove_method _1 }
-    RubyLex.prepend self
-  end
-
-  def self.complete_tokens(code, context: nil)
-    incomplete_tokens = RubyLex.ripper_lex_without_warning(code, context: context)
-    KatakataIrb::TRex.interpolate_ripper_ignored_tokens(code, incomplete_tokens)
-  end
-
-  def calc_nesting_depth(opens)
-    indent_level = 0
-    nesting_level = 0
-    opens.each_with_index do |t, index|
-      case t.event
-      when :on_heredoc_beg
-        if opens[index + 1]&.event != :on_heredoc_beg
-          if t.tok.start_with?('<<~')
-            indent_level += 1
-          else
-            indent_level = 0
-          end
-        end
-      when :on_tstring_beg, :on_regexp_beg, :on_symbeg
-        indent_level += 1 if t.tok[0] == '%'
-      when :on_embdoc_beg
-        indent_level = 0
-      else
-        nesting_level += 1
-        indent_level += 1
-      end
-    end
-    [indent_level, nesting_level]
-  end
-
-  def process_indent_level(tokens)
-    opens = KatakataIrb::TRex.parse(tokens)
-    indent, _nesting = calc_nesting_depth(opens)
-    indent * 2
-  end
-
-  def check_corresponding_token_depth(tokens, line_index)
-    line_results = KatakataIrb::TRex.parse_line(tokens)
-    result = line_results[line_index]
-    return unless result
-    _tokens, prev, opens, min_depth = result
-    depth, = calc_nesting_depth(opens.take(min_depth))
-    prev_depth, = calc_nesting_depth(prev)
-    depth * 2 if depth < prev_depth
-  end
-
-  def ltype_from_open_tokens(opens)
-    return nil if opens.empty?
-    case opens.last.tok
-    when ?`, /^<<[-~]?`/, /^%x.$/
-      ?`
-    when ?', /^<<[-~]?'/, /^%q.$/
-      ?'
-    when ?", /^<</, /^%.$/, /^%Q.$/
-      ?"
-    when ":'", ':"', ':', /^%s.$/
-      ':'
-    when /^%[iwIW].$/
-      ']'
-    when '/', /^%r.$/
-      '/'
-    end
-  end
-
-  def check_termination_in_prev_line(code, context: nil)
-    tokens = self.class.ripper_lex_without_warning(code, context: context)
-    last_newline_index = tokens.rindex { |t| t.tok.include?("\n") }
-    index = (0...last_newline_index).reverse_each.find { |i| tokens[i].tok.include?("\n") }
-    return false unless index
-
-    last_line_tokens = tokens[(index + 1)..(tokens.size - 1)]
-    first_token = last_line_tokens.find do |t|
-      ![:on_sp, :on_ignored_sp, :on_comment].include?(t.event)
-    end
-
-    if first_token && first_token.state != Ripper::EXPR_DOT
-      tokens_without_last_line = tokens[0..index]
-      if check_termination(tokens_without_last_line.map(&:tok).join, context: context)
-        return last_line_tokens.map(&:tok).join
-      end
-    end
-    false
-  end
-
-  def check_termination(code, context: nil)
-    tokens = KatakataIrb::RubyLexPatch.complete_tokens(code, context: context)
-    opens = KatakataIrb::TRex.parse(tokens)
-    opens.empty? && !process_continue(tokens) && !check_code_block(code, tokens)
-  end
-
-  def set_input(io, p = nil, context: nil, &block)
-    @io = io
-    if @io.respond_to?(:check_termination)
-      @io.check_termination do |code|
-        if Reline::IOGate.in_pasting?
-          rest = check_termination_in_prev_line(code, context: context)
-          if rest
-            Reline.delete_text
-            rest.bytes.reverse_each do |c|
-              Reline.ungetc(c)
-            end
-            true
-          else
-            false
-          end
-        else
-          # Accept any single-line input for symbol aliases or commands that transform args
-          command = code.split(/\s/, 2).first
-          if context.symbol_alias?(command) || context.transform_args?(command)
-            next true
-          end
-
-          code.gsub!(/\s*\z/, '').concat("\n")
-          check_termination(code, context: context)
-        end
-      end
-    end
-    if @io.respond_to?(:dynamic_prompt)
-      @io.dynamic_prompt do |lines|
-        lines << '' if lines.empty?
-        code = lines.map{ |l| l + "\n" }.join
-        tokens = KatakataIrb::RubyLexPatch.complete_tokens code, context: context
-        line_results = KatakataIrb::TRex.parse_line(tokens)
-        continue = false
-        tokens_until_line = []
-        line_results.map.with_index do |(line_tokens, _prev_opens, next_opens), line_num_offset|
-          line_tokens.each do |token, _s|
-            tokens_until_line << token if token != tokens_until_line.last
-          end
-          continue = process_continue(tokens_until_line)
-          prompt next_opens, continue, line_num_offset
-        end
-      end
-    end
-
-    if p.respond_to?(:call)
-      @input = p
-    elsif block_given?
-      @input = block
-    else
-      @input = Proc.new{@io.gets}
-    end
-  end
-
-  def set_auto_indent(context)
-    if @io.respond_to?(:auto_indent) and context.auto_indent_mode
-      @io.auto_indent do |lines, line_index, byte_pointer, is_newline|
-        if is_newline
-          tokens = KatakataIrb::RubyLexPatch.complete_tokens(lines[0..line_index].join("\n"), context: context)
-          process_indent_level(tokens)
-        else
-          code = line_index.zero? ? '' : lines[0..(line_index - 1)].map{ |l| l + "\n" }.join
-          last_line = lines[line_index]&.byteslice(0, byte_pointer)
-          code += last_line if last_line
-          tokens = KatakataIrb::RubyLexPatch.complete_tokens(code, context: context)
-          check_corresponding_token_depth(tokens, line_index)
-        end
-      end
-    end
-  end
-
-  def prompt(opens, continue, line_num_offset)
-    ltype = ltype_from_open_tokens(opens)
-    _indent, nesting_level = calc_nesting_depth(opens)
-    @prompt.call(ltype, nesting_level, opens.any? || continue, @line_no + line_num_offset)
-  end
-
-  # TODO: do not use this. change the api. example: @input.call(prompt)
-  def store_prompt_to_irb(opens, continue, line_num_offset)
-    prompt(opens, continue, line_num_offset)
-  end
-
-  def readmultiline(context)
-    if @io.respond_to? :check_termination
-      store_prompt_to_irb([], false, 0)
-      @input.call
-    else
-      # nomultiline
-      line = ''
-      line_offset = 0
-      store_prompt_to_irb([], false, 0)
-      loop do
-        l = @input.call
-        unless l
-          return if line.empty?
-          next
-        end
-        line << l
-        tokens = KatakataIrb::RubyLexPatch.complete_tokens(line, context: context)
-        _line_tokens, _prev_opens, next_opens = KatakataIrb::TRex.parse_line(tokens).last
-        return line if next_opens.empty?
-        line_offset += 1
-        store_prompt_to_irb(next_opens, true, line_offset)
-      end
-    end
-  end
-
-  def each_top_level_statement(context = nil)
-    loop do
-      begin
-        line = readmultiline(context)
-        break unless line
-        if line != "\n"
-          line.force_encoding(@io.encoding)
-          yield line, @line_no
-        end
-        @line_no += line.count("\n")
-      rescue RubyLex::TerminateLineInput
-      end
-    end
-  end
-end