katakata_irb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07b0eb3288cc4eec15c83de9bd27948379bca2c1dfa233104cba59dff6826c7c
+  data.tar.gz: 20d4feb90c4df7e10554e045addfb242af50205dd0b187635a81ac3bc5b073b2
+SHA512:
+  metadata.gz: 7a376d7deb729f3a2e2f3b18041e89606d668e331ece73c32d5b7ae9ff6b8d87bffa89f4ab3d1dc66c8354b3af2ad733bee211868e01bd8814055f3cc72fe83b
+  data.tar.gz: 50eaa7061da8609623f1fccc5d0fbe12685f888d7a565eede06e19993b435aa766ce6458668fa787369bef62ce5601b6dd9c4118fa534457c89341881367722d

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in katakata_irb.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    katakata_irb (0.1.0)
+      rbs
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.16.3)
+    rake (13.0.6)
+    rbs (2.7.0)
+
+PLATFORMS
+  x86_64-darwin-20
+
+DEPENDENCIES
+  katakata_irb!
+  minitest (~> 5.0)
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.4.0.dev

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 tompng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# KatakataIrb: IRB with Kata(型 Type) completion
+
+KatakataIrb might provide a better autocompletion based on type analysis to irb.
+
+## Installation
+
+```
+gem install katakata_irb
+```
+## Usage
+
+```
+% kirb
+irb(main):001:0> [1,'a'].sample.a█
+                |[1,'a'].sample.abs        |
+                |[1,'a'].sample.abs2       |
+                |[1,'a'].sample.allbits?   |
+                |[1,'a'].sample.angle      |
+                |[1,'a'].sample.anybits?   |
+                |[1,'a'].sample.arg        |
+                |[1,'a'].sample.ascii_only?|
+```
+
+```
+% kirb
+irb(main):001:0> a = 10
+=> 10
+irb(main):002:1* if true
+irb(main):003:2*   b = a.times.map do
+irb(main):004:2*     _1.to_s
+irb(main):005:1*   end
+irb(main):006:1*   b[0].a█
+                  |b[0].ascii_only?|
+```
+
+```ruby
+require 'katakata_irb/completor'
+KatakataIrb::Completor.setup
+10.times do |i|
+  binding.irb
+end
+```
+
+## Options
+
+### `kirb --debug-output`
+Show debug output if it meets unimplemented syntax or something
+
+### `kirb --without-patch`
+`kirb` will apply some patches to reline and irb/ruby-lex.rb by default. This option will disable it.
+See `lib/katakata_irb/ruby_lex_patch.rb` and `lib/katakata_irb/reline_patches/*.patch`

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require_relative '../lib/katakata_irb'
+require_relative '../lib/katakata_irb/reline_patch'
+KatakataIrb::RelinePatch.require_patched_reline
+KatakataIrb.log_output = STDERR
+require 'bundler/setup'
+require 'katakata_irb'
+require 'katakata_irb/ruby_lex_patch'
+KatakataIrb::RubyLexPatch.patch_to_ruby_lex
+KatakataIrb.repl

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/kirb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+unless ARGV.delete '--without-patch'
+  require_relative '../lib/katakata_irb/reline_patch'
+  KatakataIrb::RelinePatch.require_patched_reline
+  require 'katakata_irb/ruby_lex_patch'
+  KatakataIrb::RubyLexPatch.patch_to_ruby_lex
+end
+require 'katakata_irb'
+KatakataIrb.log_output = STDERR if ARGV.delete '--debug-output'
+KatakataIrb.repl

data/katakata_irb.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/katakata_irb/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "katakata_irb"
+  spec.version = KatakataIrb::VERSION
+  spec.authors = ["tompng"]
+  spec.email = ["tomoyapenguin@gmail.com"]
+
+  spec.summary = "IRB with Typed Completion"
+  spec.description = "IRB with Typed Completion"
+  spec.homepage = "http://github.com/tompng/katakata_irb"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "http://github.com/tompng/katakata_irb"
+
+  # 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(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'rbs'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/katakata_irb/completor.rb

@@ -0,0 +1,187 @@
+require_relative 'trex'
+require_relative 'type_simulator'
+require 'rbs'
+require 'rbs/cli'
+require 'irb'
+
+module KatakataIrb::Completor
+  using KatakataIrb::TypeSimulator::LexerElemMatcher
+
+  HIDDEN_METHODS = %w[Namespace TypeName] # defined by rbs, should be hidden
+
+  def self.setup
+    completion_proc = ->(target, preposing = nil, postposing = nil) do
+      code = "#{preposing}#{target}"
+      irb_context = IRB.conf[:MAIN_CONTEXT]
+      binding = irb_context.workspace.binding
+      candidates = case analyze code, binding
+      in [:require | :require_relative => method, name]
+        if method == :require
+          IRB::InputCompletor.retrieve_files_to_require_from_load_path
+        else
+          IRB::InputCompletor.retrieve_files_to_require_relative_from_current_dir
+        end
+      in [:call_or_const, type, name, self_call]
+        ((self_call ? type.all_methods: type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
+      in [:const, type, name]
+        type.constants
+      in [:ivar, name, _scope]
+        # TODO: scope
+        ivars = binding.eval('self').instance_variables rescue []
+        cvars = (binding.eval('self').class_variables rescue nil) if name == '@'
+        ivars | (cvars || [])
+      in [:cvar, name, _scope]
+        # TODO: scope
+        binding.eval('self').class_variables rescue []
+      in [:gvar, name]
+        global_variables
+      in [:symbol, name]
+        Symbol.all_symbols
+      in [:call, type, name, self_call]
+        (self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS
+      in [:lvar_or_method, name, scope]
+        scope.self_type.all_methods.map(&:to_s) | scope.local_variables
+      else
+        []
+      end
+      all_symbols_pattern = /\A[ -\/:-@\[-`\{-~]*\z/
+      candidates.map(&:to_s).select { !_1.match?(all_symbols_pattern) && _1.start_with?(name) }.uniq.sort.map do
+        target + _1[name.size..]
+      end
+    end
+    IRB::InputCompletor::CompletionProc.define_singleton_method :call do |*args|
+      completion_proc.call(*args)
+    end
+  end
+
+  def self.analyze(code, binding = Kernel.binding)
+    lvars_code = binding.local_variables.map do |name|
+      "#{name}="
+    end.join + "nil;\n"
+    code = lvars_code + code
+    tokens = RubyLex.ripper_lex_without_warning code
+    tokens = KatakataIrb::TRex.interpolate_ripper_ignored_tokens code, tokens
+    last_opens, unclosed_heredocs = KatakataIrb::TRex.parse(tokens)
+    closings = (last_opens + unclosed_heredocs).map do |t,|
+      case t.tok
+      when /\A%.[<>]\z/
+        '>'
+      when '{', '#{', /\A%.?[{}]\z/
+        '}'
+      when '(', /\A%.?[()]\z/
+        ')'
+      when '[', /\A%.?[\[\]]\z/
+        ']'
+      when /\A%.?(.)\z/
+        $1
+      when '"', "'", '/', '`'
+        t.tok
+      when /\A<<(?:"(?<s>.+)"|'(?<s>.+)'|(?<s>.+))/
+        $3
+      else
+        'end'
+      end
+    end
+
+    return if code =~ /[!?]\z/
+    case tokens.last
+    in { event: :on_ignored_by_ripper, tok: '.' }
+      suffix = 'method'
+      name = ''
+    in { dot: true }
+      suffix = 'method'
+      name = ''
+    in { event: :on_ident | :on_kw, tok: }
+      return unless code.delete_suffix! tok
+      suffix = 'method'
+      name = tok
+    in { event: :on_const, tok: }
+      return unless code.delete_suffix! tok
+      suffix = 'Const'
+      name = tok
+    in { event: :on_tstring_content, tok: }
+      return unless code.delete_suffix! tok
+      suffix = 'string'
+      name = tok.rstrip
+    else
+      return
+    end
+
+    closings = $/ + closings.reverse.join($/)
+    sexp = Ripper.sexp code + suffix + closings
+    lines = code.lines
+    line_no = lines.size
+    col = lines.last.bytesize
+    if lines.last.end_with? "\n"
+      line_no += 1
+      col = 0
+    end
+
+    if sexp in [:program, [lvars_exp, *rest_statements]]
+      sexp = [:program, rest_statements]
+    end
+
+    *parents, expression, target = find_target sexp, line_no, col
+    in_class_module = parents&.any? { _1 in [:class | :module,] }
+    icvar_available = !in_class_module
+    return unless target in [type, String, [Integer, Integer]]
+    if target in [:@ivar,]
+      return [:ivar, name] if icvar_available
+    elsif target in [:@cvar,]
+      return [:cvar, name] if icvar_available
+    end
+    return unless expression
+    if (target in [:@tstring_content,]) && (parents[-4] in [:command, [:@ident, 'require' | 'require_relative' => require_method,],])
+      return [require_method.to_sym, name.rstrip]
+    end
+    calculate_scope = -> { KatakataIrb::TypeSimulator.calculate_binding_scope binding, parents, expression }
+    calculate_receiver = -> receiver { KatakataIrb::TypeSimulator.calculate_receiver binding, parents, receiver }
+    case expression
+    in [:vcall | :var_ref, [:@ident,]]
+      [:lvar_or_method, name, calculate_scope.call]
+    in [:symbol, [:@ident | :@const | :@op | :@kw,]]
+      [:symbol, name]
+    in [:var_ref | :const_ref, [:@const,]]
+      # TODO
+      [:const, KatakataIrb::Types::SingletonType.new(Object), name]
+    in [:var_ref, [:@gvar,]]
+      [:gvar, name]
+    in [:var_ref, [:@ivar,]]
+      [:ivar, name, calculate_scope.call.self_type] if icvar_available
+    in [:var_ref, [:@cvar,]]
+      [:cvar, name, calculate_scope.call.self_type] if icvar_available
+    in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, [:@ident | :@const,]]
+      self_call = (receiver in [:var_ref, [:@kw, 'self',]])
+      [dot == :'::' ? :call_or_const : :call, calculate_receiver.call(receiver), name, self_call]
+    in [:const_path_ref, receiver, [:@const,]]
+      [:const, calculate_receiver.call(receiver), name]
+    in [:top_const_ref, [:@const,]]
+      [:const, KatakataIrb::Types::SingletonType.new(Object), name]
+    in [:def,] | [:string_content,] | [:var_field,] | [:defs,] | [:rest_param,] | [:kwrest_param,] | [:blockarg,] | [[:@ident,],]
+    in [Array,] # `xstring`, /regexp/
+    else
+      KatakataIrb.log_puts
+      KatakataIrb.log_puts [:NEW_EXPRESSION, expression].inspect
+      KatakataIrb.log_puts
+    end
+  end
+
+  def self.find_target(sexp, line, col, stack = [sexp])
+    return unless sexp.is_a? Array
+    sexp.each do |child|
+      case child
+      in [Symbol, String, [Integer => l, Integer => c]]
+        if l == line && c == col
+          stack << child
+          return stack
+        end
+      else
+        stack << child
+        result = find_target(child, line, col, stack)
+        return result if result
+        stack.pop
+      end
+    end
+    nil
+  end
+end

data/lib/katakata_irb/reline_patch.rb

@@ -0,0 +1,40 @@
+module KatakataIrb; end
+module KatakataIrb::RelinePatch
+  module RelinePatchIseqLoader; end
+  def self.require_patched_reline
+    # Apply patches of unmerged pull-request to reline
+    patches = %w[wholelines escapeseq indent fullwidth raw scrollbar]
+    patched = {}
+    require 'reline/version.rb' # result of $LOAD_PATH.resolve_feature_path will change after this require
+    patches.each do |patch_name|
+      patch = File.read File.expand_path("reline_patches/#{patch_name}.patch", File.dirname(__FILE__))
+      current_patched = {}
+      patch.gsub(/^diff.+\nindex.+$/, '').split(/^--- a(.+)\n\+\+\+ b(.+)\n/).drop(1).each_slice(3) do |file, newfile, diff|
+        raise if file != newfile
+        _, path = $LOAD_PATH.resolve_feature_path file.sub(%r{^/lib/}, '')
+        code = current_patched[path] || patched[path] || File.read(path)
+        diff.split(/^@@.+\n/).drop(1).map(&:lines).each do |lines|
+          target = lines.reject { _1[0] == '+' }.map { _1[1..] }.join
+          replace = lines.reject { _1[0] == '-' }.map { _1[1..] }.join
+          raise unless code.include? target
+          code.sub! target, replace
+        end
+        current_patched[path] = code
+      end
+      patched.update current_patched
+    rescue
+      puts "Failed to apply katakata_irb/reline_patches/#{patch_name}.patch to reline"
+    end
+
+    RelinePatchIseqLoader.define_method :load_iseq do |fname|
+      if patched.key? fname
+        RubyVM::InstructionSequence.compile patched[fname], fname
+      else
+        RubyVM::InstructionSequence.compile_file fname
+      end
+    end
+    RubyVM::InstructionSequence.singleton_class.prepend RelinePatchIseqLoader
+    require 'reline'
+    RelinePatchIseqLoader.undef_method :load_iseq
+  end
+end

data/lib/katakata_irb/reline_patches/escapeseq.patch

@@ -0,0 +1,45 @@
+diff --git a/lib/reline/line_editor.rb b/lib/reline/line_editor.rb
+index 1c33a4b..bbf5e6c 100644
+--- a/lib/reline/line_editor.rb
++++ b/lib/reline/line_editor.rb
+@@ -663,8 +663,10 @@ class Reline::LineEditor
+     dialog.set_cursor_pos(cursor_column, @first_line_started_from + @started_from)
+     dialog_render_info = dialog.call(@last_key)
+     if dialog_render_info.nil? or dialog_render_info.contents.nil? or dialog_render_info.contents.empty?
++      lines = whole_lines
+       dialog.lines_backup = {
+-        lines: modify_lines(whole_lines),
++        unmodified_lines: lines,
++        lines: modify_lines(lines),
+         line_index: @line_index,
+         first_line_started_from: @first_line_started_from,
+         started_from: @started_from,
+@@ -766,8 +768,10 @@ class Reline::LineEditor
+     Reline::IOGate.move_cursor_column(cursor_column)
+     move_cursor_up(dialog.vertical_offset + dialog.contents.size - 1)
+     Reline::IOGate.show_cursor
++    lines = whole_lines
+     dialog.lines_backup = {
+-      lines: modify_lines(whole_lines),
++      unmodified_lines: lines,
++      lines: modify_lines(lines),
+       line_index: @line_index,
+       first_line_started_from: @first_line_started_from,
+       started_from: @started_from,
+@@ -777,7 +781,7 @@ class Reline::LineEditor
+   private def reset_dialog(dialog, old_dialog)
+     return if dialog.lines_backup.nil? or old_dialog.contents.nil?
+-    prompt, prompt_width, prompt_list = check_multiline_prompt(dialog.lines_backup[:lines])
++    prompt, prompt_width, prompt_list = check_multiline_prompt(dialog.lines_backup[:unmodified_lines])
+     visual_lines = []
+     visual_start = nil
+     dialog.lines_backup[:lines].each_with_index { |l, i|
+@@ -888,7 +892,7 @@ class Reline::LineEditor
+   private def clear_each_dialog(dialog)
+     dialog.trap_key = nil
+     return unless dialog.contents
+-    prompt, prompt_width, prompt_list = check_multiline_prompt(dialog.lines_backup[:lines])
++    prompt, prompt_width, prompt_list = check_multiline_prompt(dialog.lines_backup[:unmodified_lines])
+     visual_lines = []
+     visual_lines_under_dialog = []
+     visual_start = nil

data/lib/katakata_irb/reline_patches/fullwidth.patch

@@ -0,0 +1,200 @@
+diff --git a/lib/reline/line_editor.rb b/lib/reline/line_editor.rb
+index c9e613e..6acf969 100644
+--- a/lib/reline/line_editor.rb
++++ b/lib/reline/line_editor.rb
+@@ -748,3 +741,3 @@ class Reline::LineEditor
+       end
+       str_width = dialog.width - (dialog.scrollbar_pos.nil? ? 0 : @block_elem_width)
+-      str = padding_space_with_escape_sequences(Reline::Unicode.take_range(item, 0, str_width), str_width)
++      str, = Reline::Unicode.take_range(item, 0, str_width, padding: true)
+@@ -793,85 +786,42 @@ class Reline::LineEditor
+       end
+       visual_lines.concat(vl)
+     }
+-    old_y = dialog.lines_backup[:first_line_started_from] + dialog.lines_backup[:started_from]
+-    y = @first_line_started_from + @started_from
+-    y_diff = y - old_y
+-    if (old_y + old_dialog.vertical_offset) < (y + dialog.vertical_offset)
+-      # rerender top
+-      move_cursor_down(old_dialog.vertical_offset - y_diff)
+-      start = visual_start + old_dialog.vertical_offset
+-      line_num = dialog.vertical_offset - old_dialog.vertical_offset
+-      line_num.times do |i|
+-        Reline::IOGate.move_cursor_column(old_dialog.column)
+-        if visual_lines[start + i].nil?
+-          s = ' ' * old_dialog.width
+-        else
+-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column, old_dialog.width)
+-          s = padding_space_with_escape_sequences(s, old_dialog.width)
+-        end
+-        @output.write "\e[0m#{s}\e[0m"
+-        move_cursor_down(1) if i < (line_num - 1)
+-      end
+-      move_cursor_up(old_dialog.vertical_offset + line_num - 1 - y_diff)
+-    end
+-    if (old_y + old_dialog.vertical_offset + old_dialog.contents.size) > (y + dialog.vertical_offset + dialog.contents.size)
+-      # rerender bottom
+-      move_cursor_down(dialog.vertical_offset + dialog.contents.size - y_diff)
+-      start = visual_start + dialog.vertical_offset + dialog.contents.size
+-      line_num = (old_dialog.vertical_offset + old_dialog.contents.size) - (dialog.vertical_offset + dialog.contents.size)
+-      line_num.times do |i|
+-        Reline::IOGate.move_cursor_column(old_dialog.column)
+-        if visual_lines[start + i].nil?
+-          s = ' ' * old_dialog.width
+-        else
+-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column, old_dialog.width)
+-          s = padding_space_with_escape_sequences(s, old_dialog.width)
++    old_dialog_y = dialog.lines_backup[:first_line_started_from] + dialog.lines_backup[:started_from]
++    dialog_y = @first_line_started_from + @started_from
++
++    x_range = dialog.column...dialog.column + dialog.width
++    old_x_range = old_dialog.column...old_dialog.column + old_dialog.width
++    y_range = dialog_y + dialog.vertical_offset...dialog_y + dialog.vertical_offset + dialog.contents.size
++    old_y_range = old_dialog_y + old_dialog.vertical_offset...old_dialog_y + old_dialog.vertical_offset + old_dialog.contents.size
++
++    cursor_y = dialog_y
++    old_y_range.each do |y|
++      rerender_ranges = []
++      if y_range.cover?(y) && x_range.any?(old_x_range)
++        if old_x_range.begin < x_range.begin
++          # rerender left
++          rerender_ranges << [old_x_range.begin...[old_x_range.end, x_range.begin].min, true, false]
+         end
+-        @output.write "\e[0m#{s}\e[0m"
+-        move_cursor_down(1) if i < (line_num - 1)
+-      end
+-      move_cursor_up(dialog.vertical_offset + dialog.contents.size + line_num - 1 - y_diff)
+-    end
+-    if old_dialog.column < dialog.column
+-      # rerender left
+-      move_cursor_down(old_dialog.vertical_offset - y_diff)
+-      width = dialog.column - old_dialog.column
+-      start = visual_start + old_dialog.vertical_offset
+-      line_num = old_dialog.contents.size
+-      line_num.times do |i|
+-        Reline::IOGate.move_cursor_column(old_dialog.column)
+-        if visual_lines[start + i].nil?
+-          s = ' ' * width
+-        else
+-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column, width)
+-          s = padding_space_with_escape_sequences(s, dialog.width)
++        if x_range.end < old_x_range.end
++          # rerender right
++          rerender_ranges << [[x_range.end, old_x_range.begin].max...old_x_range.end, false, true]
+         end
++      else
++        rerender_ranges << [old_x_range, true, true]
++      end
++
++      rerender_ranges.each do |range, cover_begin, cover_end|
++        move_cursor_down(y - cursor_y)
++        cursor_y = y
++        col = range.begin
++        width = range.end - range.begin
++        line = visual_lines[y + visual_start - old_dialog_y] || ''
++        s, col = Reline::Unicode.take_range(line, col, width, cover_begin: cover_begin, cover_end: cover_end, padding: true)
++        Reline::IOGate.move_cursor_column(col)
+         @output.write "\e[0m#{s}\e[0m"
+-        move_cursor_down(1) if i < (line_num - 1)
+-      end
+-      move_cursor_up(old_dialog.vertical_offset + line_num - 1 - y_diff)
+-    end
+-    if (old_dialog.column + old_dialog.width) > (dialog.column + dialog.width)
+-      # rerender right
+-      move_cursor_down(old_dialog.vertical_offset + y_diff)
+-      width = (old_dialog.column + old_dialog.width) - (dialog.column + dialog.width)
+-      start = visual_start + old_dialog.vertical_offset
+-      line_num = old_dialog.contents.size
+-      line_num.times do |i|
+-        Reline::IOGate.move_cursor_column(old_dialog.column + dialog.width)
+-        if visual_lines[start + i].nil?
+-          s = ' ' * width
+-        else
+-          s = Reline::Unicode.take_range(visual_lines[start + i], old_dialog.column + dialog.width, width)
+-          rerender_width = old_dialog.width - dialog.width
+-          s = padding_space_with_escape_sequences(s, rerender_width)
+-        end
+-        Reline::IOGate.move_cursor_column(dialog.column + dialog.width)
+-        @output.write "\e[0m#{s}\e[0m"
+-        move_cursor_down(1) if i < (line_num - 1)
+       end
+-      move_cursor_up(old_dialog.vertical_offset + line_num - 1 + y_diff)
+     end
++    move_cursor_up(cursor_y - dialog_y)
+     Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
+   end
+ 
+@@ -912,9 +862,8 @@ class Reline::LineEditor
+     dialog_vertical_size = dialog.contents.size
+     dialog_vertical_size.times do |i|
+       if i < visual_lines_under_dialog.size
+-        Reline::IOGate.move_cursor_column(dialog.column)
+-        str = Reline::Unicode.take_range(visual_lines_under_dialog[i], dialog.column, dialog.width)
+-        str = padding_space_with_escape_sequences(str, dialog.width)
++        str, start_pos = Reline::Unicode.take_range(visual_lines_under_dialog[i], dialog.column, dialog.width, cover_begin: true, cover_end: true, padding: true)
++        Reline::IOGate.move_cursor_column(start_pos)
+         @output.write "\e[0m#{str}\e[0m"
+       else
+         Reline::IOGate.move_cursor_column(dialog.column)
+diff --git a/lib/reline/unicode.rb b/lib/reline/unicode.rb
+index 6000c9f..03074dd 100644
+--- a/lib/reline/unicode.rb
++++ b/lib/reline/unicode.rb
+@@ -194,17 +194,21 @@ class Reline::Unicode
+   end
+ 
+   # Take a chunk of a String cut by width with escape sequences.
+-  def self.take_range(str, start_col, max_width, encoding = str.encoding)
++  def self.take_range(str, start_col, width, encoding: str.encoding, cover_begin: false, cover_end: false, padding: false)
+     chunk = String.new(encoding: encoding)
+     total_width = 0
+     rest = str.encode(Encoding::UTF_8)
+     in_zero_width = false
++    chunk_start_col = nil
++    chunk_end_col = nil
+     rest.scan(WIDTH_SCANNER) do |gc|
+       case
+       when gc[NON_PRINTING_START_INDEX]
+         in_zero_width = true
++        chunk << NON_PRINTING_START
+       when gc[NON_PRINTING_END_INDEX]
+         in_zero_width = false
++        chunk << NON_PRINTING_END
+       when gc[CSI_REGEXP_INDEX]
+         chunk << gc[CSI_REGEXP_INDEX]
+       when gc[OSC_REGEXP_INDEX]
+@@ -215,13 +219,31 @@ class Reline::Unicode
+           chunk << gc
+         else
+           mbchar_width = get_mbchar_width(gc)
++          prev_width = total_width
+           total_width += mbchar_width
+-          break if (start_col + max_width) < total_width
+-          chunk << gc if start_col < total_width
++          break if !cover_end && total_width > start_col + width
++          if cover_begin ? start_col < total_width : start_col <= prev_width
++            chunk << gc
++            chunk_start_col ||= prev_width
++            chunk_end_col = total_width
++          end
++          break if total_width >= start_col + width
+         end
+       end
+     end
+-    chunk
++    chunk_start_col ||= start_col
++    chunk_end_col ||= start_col
++    if padding
++      if start_col < chunk_start_col
++        chunk = ' ' * (chunk_start_col - start_col) + chunk
++        chunk_start_col = start_col
++      end
++      if chunk_end_col < start_col + width
++        chunk << ' ' * (start_col + width - chunk_end_col)
++        chunk_end_col = start_col + width
++      end
++    end
++    [chunk, chunk_start_col, chunk_end_col - chunk_start_col]
+   end
+ 
+   def self.get_next_mbchar_size(line, byte_pointer)